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

Open in your IDE?
  1. <?php
  3. namespace Webkul\UVDesk\CoreFrameworkBundle\Services;
  5. use Doctrine\ORM\EntityManagerInterface;
  6. use Doctrine\ORM\Query;
  7. use Symfony\Component\DependencyInjection\ContainerInterface;
  8. use Symfony\Component\Filesystem\Filesystem;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\HttpFoundation\RequestStack;
  12. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  13. use Symfony\Component\Yaml\Yaml;
  14. use UVDesk\CommunityPackages\UVDesk\FormComponent\Entity;
  15. use UVDesk\CommunityPackages\UVDesk\FormComponent\Entity as CommunityPackageEntities;
  16. use Webkul\UVDesk\AutomationBundle\Entity\PreparedResponses;
  17. use Webkul\UVDesk\CoreFrameworkBundle\Entity\User;
  18. use Webkul\UVDesk\CoreFrameworkBundle\Entity\UserInstance;
  19. use Webkul\UVDesk\CoreFrameworkBundle\Entity\AgentActivity;
  20. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Ticket;
  21. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Thread;
  22. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Tag;
  23. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketType;
  24. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketStatus;
  25. use Webkul\UVDesk\CoreFrameworkBundle\Entity\TicketPriority;
  26. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportRole;
  27. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Website;
  28. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportGroup;
  29. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportTeam;
  30. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportLabel;
  31. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SavedReplies;
  32. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Attachment;
  33. use Webkul\UVDesk\CoreFrameworkBundle\Utils\TokenGenerator;
  34. use Webkul\UVDesk\CoreFrameworkBundle\Workflow\Events as CoreWorkflowEvents;
  35. use Webkul\UVDesk\CoreFrameworkBundle\Services\FileUploadService;
  36. use Webkul\UVDesk\CoreFrameworkBundle\Services\UserService;
  37. use Webkul\UVDesk\MailboxBundle\Utils\Mailbox\Mailbox;
  38. use Webkul\UVDesk\MailboxBundle\Utils\MailboxConfiguration;
  39. use Webkul\UVDesk\MailboxBundle\Utils\IMAP\Configuration as ImapConfiguration;
  40. use Webkul\UVDesk\SupportCenterBundle\Entity\Article;
  41. use Webkul\UVDesk\SupportCenterBundle\Entity\KnowledgebaseWebsite;
  42. use Webkul\UVDesk\MailboxBundle\Services\MailboxService;
  43. use Symfony\Contracts\Translation\TranslatorInterface;
  44. use UVDesk\CommunityPackages\UVDesk as UVDeskCommunityPackages;
  46. class TicketService
  47. {
  48.     const PATH_TO_CONFIG = '/config/packages/uvdesk_mailbox.yaml';
  50.     protected $container;
  51.     protected $requestStack;
  52.     protected $entityManager;
  53.     protected $fileUploadService;
  54.     protected $userService;
  55.     
  56.     public function __construct(
  57.         ContainerInterface $container,
  58.         RequestStack $requestStack,
  59.         EntityManagerInterface $entityManager,
  60.         FileUploadService $fileUploadService,
  61.         UserService $userService,
  62.         MailboxService $mailboxService,
  63.         TranslatorInterface $translator
  64.     ) {
  65.         $this->container = $container;
  66.         $this->requestStack = $requestStack;
  67.         $this->entityManager = $entityManager;
  68.         $this->fileUploadService = $fileUploadService;
  69.         $this->userService = $userService;
  70.         $this->mailboxService = $mailboxService;
  71.         $this->translator = $translator;
  72.     }
  74.     public function getAllMailboxes()
  75.     {
  76.         $mailboxConfiguration = $this->mailboxService->parseMailboxConfigurations();
  78.         $defaultMailbox = $mailboxConfiguration->getDefaultMailbox();
  80.         $collection = array_map(function ($mailbox) use ($defaultMailbox) {
  81.             return [
  82.                 'id'        => $mailbox->getId(),
  83.                 'name'      => $mailbox->getName(),
  84.                 'isEnabled' => $mailbox->getIsEnabled(),
  85.                 'email'     => $mailbox->getImapConfiguration()->getUsername(),
  86.             ];
  87.         }, array_values($mailboxConfiguration->getMailboxes()));
  89.         return ($collection ?? []);
  90.     }
  92.     public function generateRandomEmailReferenceId()
  93.     {
  94.         $emailDomain = null;
  95.         $mailbox = $this->mailboxService->parseMailboxConfigurations()->getDefaultMailbox();
  97.         if (!empty($mailbox)) {
  98.             $smtpConfiguration = $mailbox->getSmtpConfiguration();
  100.             if (!empty($smtpConfiguration)) {
  101.                 $emailDomain = substr($smtpConfiguration->getUsername(), strpos($smtpConfiguration->getUsername(), '@'));
  102.             }
  103.         }
  105.         if (!empty($emailDomain)) {
  106.             return sprintf("<%s%s>", TokenGenerator::generateToken(20, '0123456789abcdefghijklmnopqrstuvwxyz'), $emailDomain);
  107.         }
  109.         return null;
  110.     }
  112.     // @TODO: Refactor this out of this service. Use UserService::getSessionUser() instead.
  113.     public function getUser()
  114.     {
  115.         return $this->container->get('user.service')->getCurrentUser();
  116.     }
  118.     public function getDefaultType()
  119.     {
  120.         $typeCode = $this->container->getParameter('uvdesk.default.ticket.type');
  121.         $ticketType = $this->entityManager->getRepository(TicketType::class)->findOneByCode($typeCode);
  123.         return !empty($ticketType) ? $ticketType : null;
  124.     }
  126.     public function getDefaultStatus()
  127.     {
  128.         $statusCode = $this->container->getParameter('uvdesk.default.ticket.status');
  129.         $ticketStatus = $this->entityManager->getRepository(TicketStatus::class)->findOneByCode($statusCode);
  131.         return !empty($ticketStatus) ? $ticketStatus : null;
  132.     }
  134.     public function getDefaultPriority()
  135.     {
  136.         $priorityCode = $this->container->getParameter('uvdesk.default.ticket.priority');
  137.         $ticketPriority = $this->entityManager->getRepository(TicketPriority::class)->findOneByCode($priorityCode);
  139.         return !empty($ticketPriority) ? $ticketPriority : null;
  140.     }
  142.     public function appendTwigSnippet($snippet = '')
  143.     {
  144.         switch ($snippet) {
  145.             case 'createMemberTicket':
  146.                 return $this->getMemberCreateTicketSnippet();
  147.                 break;
  148.             default:
  149.                 break;
  150.         }
  152.         return '';
  153.     }
  155.     public function getMemberCreateTicketSnippet()
  156.     {   
  157.         $twigTemplatingEngine = $this->container->get('twig');
  158.         $ticketTypeCollection = $this->entityManager->getRepository(TicketType::class)->findByIsActive(true);
  159.         
  160.         try {
  161.             if ($this->userService->isFileExists('apps/uvdesk/custom-fields')) {
  162.                 $headerCustomFields = $this->container->get('uvdesk_package_custom_fields.service')->getCustomFieldsArray('user');
  163.             } else if ($this->userService->isFileExists('apps/uvdesk/form-component')) {
  164.                 $headerCustomFields = $this->container->get('uvdesk_package_form_component.service')->getCustomFieldsArray('user');
  165.             }
  166.         } catch (\Exception $e) {
  167.             // @TODO: Log exception message
  168.         }
  170.         return $twigTemplatingEngine->render('@UVDeskCoreFramework/Snippets/createMemberTicket.html.twig', [
  171.             'ticketTypeCollection' => $ticketTypeCollection,
  172.             'headerCustomFields'   => $headerCustomFields ?? null,
  173.         ]);
  174.     }
  176.     public function getCustomerCreateTicketCustomFieldSnippet()
  177.     {
  178.         try {
  179.             if ($this->userService->isFileExists('apps/uvdesk/custom-fields')) {
  180.                 $customFields = $this->container->get('uvdesk_package_custom_fields.service')->getCustomFieldsArray('customer');
  181.             } else if ($this->userService->isFileExists('apps/uvdesk/form-component')) {
  182.                 $customFields = $this->container->get('uvdesk_package_form_component.service')->getCustomFieldsArray('customer');
  183.             }
  184.         } catch (\Exception $e) {
  185.             // @TODO: Log exception message
  186.         }
  188.         return $customFields ?? null;
  189.     }
  191.     public function createTicket(array $params = [])
  192.     {
  193.         $thread = $this->entityManager->getRepository(Thread::class)->findOneByMessageId($params['messageId']);
  195.         if (empty($thread)) {
  196.             $user = $this->entityManager->getRepository(User::class)->findOneByEmail($params['from']);
  198.             if (empty($user) || null == $user->getCustomerInstance()) {
  199.                 $role = $this->entityManager->getRepository(SupportRole::class)->findOneByCode($params['role']);
  200.                 if (empty($role)) {
  201.                     throw new \Exception("The requested role '" . $params['role'] . "' does not exist.");
  202.                 }
  203.                 
  204.                 // Create User Instance
  205.                 $user = $this->container->get('user.service')->createUserInstance($params['from'], $params['name'], $role, [
  206.                     'source' => strtolower($params['source']),
  207.                     'active' => true,
  208.                 ]);
  209.             }
  211.             $params['role'] = 4;
  212.             $params['mailboxEmail'] = current($params['replyTo']); 
  213.             $params['customer'] = $params['user'] = $user;
  215.             return $this->createTicketBase($params);
  216.         }
  218.         return;
  219.     }
  221.     public function getDemanedFilterOptions($filterType,$ids) {
  222.         $qb = $this->entityManager->createQueryBuilder();
  223.         switch ($filterType) {
  224.             case 'agent':
  225.                 $qb->select("u.id,u.email,CONCAT(u.firstName,' ', u.lastName) AS name")->from(User::class, 'u')
  226.                         ->leftJoin(UserInstance::class, 'ud', 'WITH', 'u.id = ud.user')
  227.                         ->where('ud.supportRole != :roles')
  228.                         ->andwhere('ud.isActive = 1')
  229.                         ->andwhere('u.id IN (:ids)')
  230.                         ->setParameter('roles', 4)
  231.                         ->setParameter('ids', $ids)
  232.                         ->orderBy('name','ASC');
  234.                 return $qb->getQuery()->getArrayResult();
  235.             case 'customer':
  236.                 $qb->select("c.id,c.email,CONCAT(c.firstName,' ', c.lastName) AS name")->from(User::class, 'c')
  237.                         ->leftJoin(UserInstance::class, 'ud', 'WITH', 'c.id = ud.user')
  238.                         ->where('ud.supportRole = :roles')
  239.                         ->andwhere('ud.isActive = 1')
  240.                         ->andwhere('c.id IN (:ids)')
  241.                         ->setParameter('roles', 4)
  242.                         ->setParameter('ids', $ids)
  243.                         ->orderBy('name','ASC');
  245.                 return $qb->getQuery()->getArrayResult();
  246.             case 'group':
  247.                 $qb->select("ug.id,ug.description")->from(SupportGroup::class, 'ug')
  248.                         ->andwhere('ug.isEnabled = 1')
  249.                         ->andwhere('ug.id IN (:ids)')
  250.                         ->setParameter('ids', $ids)
  251.                         ->orderBy('ug.description','ASC');
  253.                 return $qb->getQuery()->getArrayResult();
  254.             case 'team':
  255.                 $qb->select("usg.id,usg.description")->from(SupportTeam::class, 'usg')
  256.                         ->andwhere('usg.isActive = 1')
  257.                         ->andwhere('usg.id IN (:ids)')
  258.                         ->setParameter('ids', $ids)
  259.                         ->orderBy('usg.description','ASC');
  261.                 return $qb->getQuery()->getArrayResult();
  262.             case 'tag':
  263.                 $qb->select("t.id,t.name")->from(Tag::class, 't')
  264.                         ->andwhere('t.id IN (:ids)')
  265.                         ->setParameter('ids', $ids)
  266.                         ->orderBy('t.name','ASC');
  268.                 return $qb->getQuery()->getArrayResult();
  269.         }
  270.     }
  272.     public function createTicketBase(array $ticketData = [])
  273.     {
  274.         if ('email' == $ticketData['source']) {
  275.             try {
  276.                 if (array_key_exists('UVDeskMailboxBundle', $this->container->getParameter('kernel.bundles'))) {
  277.                     $mailbox = $this->mailboxService->getMailboxByEmail($ticketData['mailboxEmail']);
  278.                     $ticketData['mailboxEmail'] = $mailbox['email'];
  279.                 }
  280.             } catch (\Exception $e) {
  281.                 // No mailbox found for this email. Skip ticket creation.
  282.                 return;
  283.             }
  284.         }
  286.         // Set Defaults
  287.         $ticketType = !empty($ticketData['type']) ? $ticketData['type'] : $this->getDefaultType();
  288.         $ticketStatus = !empty($ticketData['status']) ? $ticketData['status'] : $this->getDefaultStatus();
  289.         $ticketPriority = !empty($ticketData['priority']) ? $ticketData['priority'] : $this->getDefaultPriority();
  291.         if ('email' == $ticketData['source']) {
  292.             $ticketMessageId = !empty($ticketData['messageId']) ? $ticketData['messageId'] : null;
  293.         } else {
  294.             $ticketMessageId = $this->generateRandomEmailReferenceId();
  295.         }
  297.         $ticketData['type'] = $ticketType;
  298.         $ticketData['status'] = $ticketStatus;
  299.         $ticketData['priority'] = $ticketPriority;
  300.         $ticketData['messageId'] = $ticketMessageId;
  301.         $ticketData['isTrashed'] = false;
  303.         $ticket = new Ticket();
  304.         foreach ($ticketData as $property => $value) {
  305.             $callable = 'set' . ucwords($property);
  307.             if (method_exists($ticket, $callable)) {
  308.                 $ticket->$callable($value);
  309.             }
  310.         }
  312.         $this->entityManager->persist($ticket);
  313.         $this->entityManager->flush();
  315.         return $this->createThread($ticket, $ticketData);
  316.     }
  317.     
  318.     public function createThread(Ticket $ticket, array $threadData)
  319.     {
  320.         $threadData['isLocked'] = 0;
  321.       
  322.         if ('forward' === $threadData['threadType']) {
  323.             $threadData['replyTo'] = $threadData['to'];
  324.         }
  326.         $collaboratorEmails = [];
  327.         // check if $threadData['cc'] is not empty then merge it with $collaboratorEmails
  328.         if (! empty($threadData['cc'])) {
  329.             if (! is_array($threadData['cc'])) {
  330.                 $threadData['cc'] = [$threadData['cc']];
  331.             }
  333.             $collaboratorEmails = array_merge($collaboratorEmails, $threadData['cc']);
  334.         }
  336.         // check if $threadData['cccol'] is not empty
  337.         if (! empty($threadData['cccol'])) {
  338.             if (! is_array($threadData['cccol'])) {
  339.                 $threadData['cccol'] = [$threadData['cccol']];
  340.             }
  342.             $collaboratorEmails = array_merge($collaboratorEmails, $threadData['cccol']);
  343.         }
  345.         if (! empty($collaboratorEmails)) {
  346.             $threadData['cc'] = $collaboratorEmails;
  347.         }
  349.         $thread = new Thread();
  350.         $thread->setTicket($ticket);
  351.         $thread->setCreatedAt(new \DateTime());
  352.         $thread->setUpdatedAt(new \DateTime());
  354.         if ($threadData['threadType'] != "note") {
  355.             foreach ($threadData as $property => $value) {
  356.                 if (!empty($value)) {
  357.                     $callable = 'set' . ucwords($property);
  358.                     if (method_exists($thread, $callable)) {
  359.                         $thread->$callable($value);
  360.                     }
  361.                 }
  362.             }
  363.         } else {
  364.             $this->setTicketNotePlaceholderValue($thread, $threadData, $ticket);
  365.         }
  367.         // Update ticket reference ids is thread message id is defined
  368.         if (null != $thread->getMessageId() && false === strpos($ticket->getReferenceIds(), $thread->getMessageId())) {
  369.             $updatedReferenceIds = $ticket->getReferenceIds() . ' ' . $thread->getMessageId();            
  370.             $ticket->setReferenceIds($updatedReferenceIds);
  372.             $this->entityManager->persist($ticket);
  373.         }
  375.         if ('reply' === $threadData['threadType']) {
  376.             if ('agent' === $threadData['createdBy']) {
  377.                 // Ticket has been updated by support agents, mark as agent replied | customer view pending
  378.                 $ticket->setIsCustomerViewed(false);
  379.                 $ticket->setIsReplied(true);
  381.                 $customerName = $ticket->getCustomer()->getFirstName().' '.$ticket->getCustomer()->getLastName();
  383.                 $agentActivity = new AgentActivity();
  384.                 $agentActivity->setThreadType('reply');
  385.                 $agentActivity->setTicket($ticket);
  386.                 $agentActivity->setAgent($thread->getUser());
  387.                 $agentActivity->setCustomerName($customerName);
  388.                 $agentActivity->setAgentName('agent');
  389.                 $agentActivity->setCreatedAt(new \DateTime());
  391.                 $this->entityManager->persist($agentActivity);
  392.             } else {
  393.                 // Ticket has been updated by customer, mark as agent view | reply pending
  394.                 $ticket->setIsAgentViewed(false);
  395.                 $ticket->setIsReplied(false);
  396.             }
  398.             $this->entityManager->persist($ticket);
  399.         } else if ('create' === $threadData['threadType']) {
  400.             $ticket->setIsReplied(false);
  401.             $this->entityManager->persist($ticket);
  403.             $customerName = $ticket->getCustomer()->getFirstName().' '.$ticket->getCustomer()->getLastName();
  405.             $agentActivity = new AgentActivity();
  406.             $agentActivity->setThreadType('create');
  407.             $agentActivity->setTicket($ticket);
  408.             $agentActivity->setAgent($thread->getUser());
  409.             $agentActivity->setCustomerName($customerName );
  410.             $agentActivity->setAgentName('agent');
  411.             $agentActivity->setCreatedAt(new \DateTime());
  413.             $this->entityManager->persist($agentActivity);
  414.         }
  415.         
  416.         $ticket->currentThread = $this->entityManager->getRepository(Thread::class)->getTicketCurrentThread($ticket);
  417.         
  418.         $this->entityManager->persist($thread);
  419.         $this->entityManager->flush();
  420.         
  421.         $ticket->createdThread = $thread;
  423.         // Uploading Attachments.
  424.         if (
  425.             (isset($threadData['attachments']) && ! empty($threadData['attachments'])) || (isset($threadData['attachmentContent']) && ! empty($threadData['attachmentContent']))
  426.         ) {
  427.             if ('email' == $threadData['source']) {
  428.                 // Saving Email attachments in case of outlook with $threadData['attachmentContent']
  429.                 $this->saveThreadEmailAttachments($thread, $threadData['attachments'], $threadData['attachmentContent'] ?? []);
  430.             } else if (!empty($threadData['attachments'])) {
  431.                 $this->saveThreadAttachment($thread, $threadData['attachments']);
  432.             }
  433.         }
  435.         return $thread;
  436.     }
  438.     public function setTicketNotePlaceholderValue($thread, $threadData, $ticket)
  439.     {
  440.         if (!empty($threadData)) {
  441.             foreach ($threadData as $property => $value) {
  442.                 if (!empty($value)) {
  443.                     $callable = 'set' . ucwords($property);
  444.                     if (method_exists($thread, $callable)) {
  445.                         if($callable != "setMessage") {
  446.                             $thread->$callable($value);
  447.                         } else {
  448.                             $notesPlaceholders = $this->getNotePlaceholderValues($ticket, 'customer');
  449.                             $content = $value;
  450.                             foreach ($notesPlaceholders as $key => $val) {
  451.                                 if(strpos($value, "{%$key%}") !== false){
  452.                                     $content = strtr($value, ["{%$key%}" => $val, "{% $key %}" => $val]);
  453.                                 }
  454.                             }
  455.                             
  456.                             $content = stripslashes($content);
  457.                             $thread->$callable($content);
  458.                         }
  459.                     }
  460.                 }
  461.             }
  462.         }
  463.     }
  465.     public function saveThreadAttachment($thread, array $attachments)
  466.     {
  467.         $prefix = 'threads/' . $thread->getId();
  468.         $uploadManager = $this->container->get('uvdesk.core.file_system.service')->getUploadManager();
  470.         foreach ($attachments as $attachment) {
  471.             $uploadedFileAttributes = $uploadManager->uploadFile($attachment, $prefix);
  473.             if (!empty($uploadedFileAttributes['path'])) {
  474.                 ($threadAttachment = new Attachment())
  475.                     ->setThread($thread)
  476.                     ->setName($uploadedFileAttributes['name'])
  477.                     ->setPath($uploadedFileAttributes['path'])
  478.                     ->setSize($uploadedFileAttributes['size'])
  479.                     ->setContentType($uploadedFileAttributes['content-type']);
  480.                 
  481.                 $this->entityManager->persist($threadAttachment);
  482.             }
  483.         }
  485.         $this->entityManager->flush();
  486.     }
  488.     public function saveThreadEmailAttachments($thread, array $attachments, array $attachmentContents)
  489.     {
  490.         $prefix = 'threads/' . $thread->getId();
  491.         $uploadManager = $this->container->get('uvdesk.core.file_system.service')->getUploadManager();
  492.         
  493.         // Upload thread attachments
  494.         foreach ($attachments as $attachment) {
  495.             $uploadedFileAttributes = $uploadManager->uploadEmailAttachment($attachment, $prefix);
  496.             
  497.             if (!empty($uploadedFileAttributes['path'])) {
  498.                 ($threadAttachment = new Attachment())
  499.                     ->setThread($thread)
  500.                     ->setName($uploadedFileAttributes['name'])
  501.                     ->setPath($uploadedFileAttributes['path'])
  502.                     ->setSize($uploadedFileAttributes['size'])
  503.                     ->setContentType($uploadedFileAttributes['content-type']);
  504.                 
  505.                 $this->entityManager->persist($threadAttachment);
  506.             }
  507.         }
  509.         // Microsoft 365 Attachments.
  510.         $prefixOutlook = 'public/assets/threads/'. $thread->getId(). '/';
  511.         foreach ($attachmentContents as $attachmentContent) {
  512.             $decodedData = base64_decode(preg_replace('#^data:image/\w+;base64,#i', '', $attachmentContent['content']));
  513.             
  514.             $filePath = $prefixOutlook . $attachmentContent['name'];
  516.             if (! is_dir($prefixOutlook)) {
  517.                 mkdir($prefixOutlook, 0755, true);
  518.             }
  519.     
  520.             // Save attachment content to file
  521.             if (file_put_contents($filePath, $decodedData) === false) {
  522.                 error_log("Error: Failed to save attachment to $filePath");
  523.             }
  525.             if (! empty($filePath)) {
  526.                 ($threadAttachment = new Attachment())
  527.                     ->setThread($thread)
  528.                     ->setName($attachmentContent['name'])
  529.                     ->setPath(str_replace('public/', '' , $filePath))
  530.                     ->setSize(23343)
  531.                     ->setContentType($attachmentContent['mimeType']);
  533.                 $this->entityManager->persist($threadAttachment);
  534.             }
  536.             $this->entityManager->flush();
  537.         }
  538.     }
  540.     public function getTypes()
  541.     {
  542.         static $types;
  543.         if (null !== $types)
  544.             return $types;
  546.         $qb = $this->entityManager->createQueryBuilder();
  547.         $qb->select('tp.id','tp.code As name')->from(TicketType::class, 'tp')
  548.                 ->andWhere('tp.isActive = 1')
  549.                 ->orderBy('tp.code', 'ASC');
  551.         return $types = $qb->getQuery()->getArrayResult();
  552.     }
  554.     public function getStatus()
  555.     {
  556.         static $statuses;
  557.         if (null !== $statuses)
  558.             return $statuses;
  560.         $qb = $this->entityManager->createQueryBuilder();
  561.         $qb->select('ts')->from(TicketStatus::class, 'ts');
  562.         // $qb->orderBy('ts.sortOrder', Criteria::ASC);
  564.         return $statuses = $qb->getQuery()->getArrayResult();
  565.     }
  567.     public function getTicketTotalThreads($ticketId)
  568.     {
  569.         $qb = $this->entityManager->createQueryBuilder();
  570.         $qb->select('COUNT(th.id) as threadCount')->from(Ticket::class, 't')
  571.             ->leftJoin('t.threads', 'th')
  572.             ->andWhere('t.id = :ticketId')
  573.             ->andWhere('th.threadType = :threadType')
  574.             ->setParameter('threadType','reply')
  575.             ->setParameter('ticketId', $ticketId);
  577.         $qb = $this->entityManager->createQueryBuilder();
  578.         $qb->select('COUNT(t.id) as threadCount')->from(Thread::class, 't')
  579.             ->andWhere('t.ticket = :ticketId')
  580.             ->andWhere('t.threadType = :threadType')
  581.             ->setParameter('threadType','reply')
  582.             ->setParameter('ticketId', $ticketId);
  584.         return $qb->getQuery()->getSingleScalarResult();
  585.     }
  587.     public function getTicketTags($request = null)
  588.     {
  589.         $qb = $this->entityManager->createQueryBuilder();
  590.         $qb->select('tg')->from(Tag::class, 'tg');
  592.         if($request) {
  593.             $qb->andWhere("tg.name LIKE :tagName");
  594.             $qb->setParameter('tagName', '%'.urldecode(trim($request->query->get('query'))).'%');
  595.             $qb->andWhere("tg.id NOT IN (:ids)");
  596.             $qb->setParameter('ids', explode(',',urldecode($request->query->get('not'))));
  597.         }
  599.         return $qb->getQuery()->getArrayResult();
  600.     }
  601.     
  602.     public function paginateMembersTicketCollection(Request $request)
  603.     {
  604.         $params = $request->query->all();
  605.         $activeUser = $this->container->get('user.service')->getSessionUser();
  606.         $activeUserTimeZone = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  607.         $agentTimeZone = !empty($activeUser->getTimezone()) ? $activeUser->getTimezone() : $activeUserTimeZone->getTimezone();
  608.         $agentTimeFormat = !empty($activeUser->getTimeformat()) ? $activeUser->getTimeformat() : $activeUserTimeZone->getTimeformat();
  610.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  612.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'helpdesk']);
  613.         $timeZone = $website->getTimezone();
  614.         $timeFormat = $website->getTimeformat();
  616.         $supportGroupReference = $this->entityManager->getRepository(User::class)->getUserSupportGroupReferences($activeUser);
  617.         $supportTeamReference  = $this->entityManager->getRepository(User::class)->getUserSupportTeamReferences($activeUser);
  619.         // Get base query
  620.         $baseQuery = $ticketRepository->prepareBaseTicketQuery($activeUser, $supportGroupReference, $supportTeamReference, $params);
  621.         $ticketTabs = $ticketRepository->getTicketTabDetails($activeUser, $supportGroupReference, $supportTeamReference, $params);
  623.         // Apply Pagination
  624.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  625.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  627.         if (isset($params['repliesLess']) || isset($params['repliesMore'])) {
  628.             $paginationOptions = ['wrap-queries' => true];
  629.             $paginationQuery = $baseQuery->getQuery()
  630.                 ->setHydrationMode(Query::HYDRATE_ARRAY);
  631.         } else {
  632.             $paginationOptions = ['distinct' => true];
  633.             $paginationQuery = $baseQuery->getQuery()
  634.                 ->setHydrationMode(Query::HYDRATE_ARRAY)
  635.                 ->setHint('knp_paginator.count', isset($params['status']) ? $ticketTabs[$params['status']] : $ticketTabs[1]);
  636.         }
  638.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  639.         // Process Pagination Response
  640.         $ticketCollection = [];
  641.         $paginationParams = $pagination->getParams();
  642.         $paginationData = $pagination->getPaginationData();
  644.         $paginationParams['page'] = 'replacePage';
  645.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  646.         // $container->get('default.service')->buildSessionUrl('ticket',$queryParameters);
  649.         $ticketThreadCountQueryTemplate = $this->entityManager->createQueryBuilder()
  650.             ->select('COUNT(thread.id) as threadCount')
  651.             ->from(Ticket::class, 'ticket')
  652.             ->leftJoin('ticket.threads', 'thread')
  653.             ->where('ticket.id = :ticketId')
  654.             ->andWhere('thread.threadType = :threadType')->setParameter('threadType', 'reply');
  655.         
  656.         foreach ($pagination->getItems() as $ticketDetails) {
  657.             $ticket = array_shift($ticketDetails);
  659.             $ticketThreadCountQuery = clone $ticketThreadCountQueryTemplate;
  660.             $ticketThreadCountQuery->setParameter('ticketId', $ticket['id']);
  662.             $totalTicketReplies = (int) $ticketThreadCountQuery->getQuery()->getSingleScalarResult();
  663.             $ticketHasAttachments = false;
  664.             $dbTime = $ticket['createdAt'];
  665.             
  666.             $formattedTime= $this->fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat);
  668.             $currentDateTime  = new \DateTime('now');
  669.             if ($this->getLastReply($ticket['id'])) {
  670.                 $lastRepliedTime = 
  671.                 $this->time2string($currentDateTime->getTimeStamp() - $this->getLastReply($ticket['id'])['createdAt']->getTimeStamp());
  672.             } else {
  673.                 $lastRepliedTime = 
  674.                 $this->time2string($currentDateTime->getTimeStamp() - $ticket['createdAt']->getTimeStamp());
  675.             }
  677.             $ticketResponse = [
  678.                 'id'                => $ticket['id'],
  679.                 'subject'           => $ticket['subject'],
  680.                 'isStarred'         => $ticket['isStarred'],
  681.                 'isAgentView'       => $ticket['isAgentViewed'],
  682.                 'isTrashed'         => $ticket['isTrashed'],
  683.                 'source'            => $ticket['source'],
  684.                 'group'             => $ticketDetails['groupName'],
  685.                 'team'              => $ticketDetails['teamName'],
  686.                 'priority'          => $ticket['priority'],
  687.                 'type'              => $ticketDetails['typeName'],
  688.                 'timestamp'         => $formattedTime['dateTimeZone'],
  689.                 'formatedCreatedAt' => $formattedTime['dateTimeZone']->format($formattedTime['timeFormatString']),
  690.                 'totalThreads'      => $totalTicketReplies,
  691.                 'agent'             => null,
  692.                 'customer'          => null,
  693.                 'hasAttachments'    => $ticketHasAttachments,
  694.                 'lastReplyTime'     => $lastRepliedTime
  695.             ];
  696.            
  697.             if (!empty($ticketDetails['agentId'])) {
  698.                 $ticketResponse['agent'] = [
  699.                     'id' => $ticketDetails['agentId'],
  700.                     'name' => $ticketDetails['agentName'],
  701.                     'smallThumbnail' => $ticketDetails['smallThumbnail'],
  702.                 ];
  703.             }
  705.             if (!empty($ticketDetails['customerId'])) {
  706.                 $ticketResponse['customer'] = [
  707.                     'id'             => $ticketDetails['customerId'],
  708.                     'name'           => $ticketDetails['customerName'],
  709.                     'email'          => $ticketDetails['customerEmail'],
  710.                     'smallThumbnail' => $ticketDetails['customersmallThumbnail'],
  711.                 ];
  712.             }
  714.             array_push($ticketCollection, $ticketResponse);
  715.         }
  716.          
  717.         return [
  718.             'tickets'    => $ticketCollection,
  719.             'pagination' => $paginationData,
  720.             'tabs'       => $ticketTabs,
  721.             'labels' => [
  722.                 'predefind' => $this->getPredefindLabelDetails($activeUser, $supportGroupReference, $supportTeamReference, $params),
  723.                 'custom'    => $this->getCustomLabelDetails($this->container),
  724.             ],
  725.           
  726.         ];
  727.     }
  729.     // Convert Timestamp to day/hour/min
  730.     Public function time2string($time) {
  731.         $d = floor($time/86400);
  732.         $_d = ($d < 10 ? '0' : '').$d;
  734.         $h = floor(($time-$d*86400)/3600);
  735.         $_h = ($h < 10 ? '0' : '').$h;
  737.         $m = floor(($time-($d*86400+$h*3600))/60);
  738.         $_m = ($m < 10 ? '0' : '').$m;
  740.         $s = $time-($d*86400+$h*3600+$m*60);
  741.         $_s = ($s < 10 ? '0' : '').$s;
  743.         $time_str = "0 minutes";
  744.         if ($_d != 00)
  745.             $time_str = $_d." ".'days';
  746.         elseif ($_h != 00)
  747.             $time_str = $_h." ".'hours';
  748.         elseif ($_m != 00)
  749.             $time_str = $_m." ".'minutes';
  751.         return $time_str." "."ago";
  752.     }
  754.     public function getPredefindLabelDetails(User $currentUser, array $supportGroupIds = [], array $supportTeamIds = [], array $params = [])
  755.     {
  756.         $data = array();
  757.         $queryBuilder = $this->entityManager->createQueryBuilder();
  758.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  759.         $queryBuilder->select('COUNT(DISTINCT ticket.id) as ticketCount')->from(Ticket::class, 'ticket');
  760.             
  761.         // // applyFilter according to permission
  762.         $queryBuilder->where('ticket.isTrashed != 1');
  763.         $userInstance = $currentUser->getAgentInstance();
  765.         if (!empty($userInstance) &&  'ROLE_AGENT' == $userInstance->getSupportRole()->getCode() 
  766.         && $userInstance->getTicketAccesslevel() != 1) {
  767.             $supportGroupIds = implode(',', $supportGroupIds);
  768.             $supportTeamIds = implode(',', $supportTeamIds);
  770.             if ($userInstance->getTicketAccesslevel() == 4) {
  771.                 $queryBuilder->andWhere('ticket.agent = ' . $currentUser->getId());
  772.             } elseif ($userInstance->getTicketAccesslevel() == 2) {
  773.                 $query = '';
  774.                 if ($supportGroupIds){
  775.                     $query .= ' OR supportGroup.id IN('.$supportGroupIds.') ';
  776.                 }
  777.                 if ($supportTeamIds) {
  778.                     $query .= ' OR supportTeam.id IN('.$supportTeamIds.') ';
  779.                 }
  780.                 $queryBuilder->leftJoin('ticket.supportGroup', 'supportGroup')
  781.                             ->leftJoin('ticket.supportTeam', 'supportTeam')
  782.                             ->andWhere('( ticket.agent = ' . $currentUser->getId().$query.')');
  783.                     
  784.             } elseif ($userInstance->getTicketAccesslevel() == 3) {
  785.                 $query = '';
  786.                 if ($supportTeamIds) {
  787.                     $query .= ' OR supportTeam.id IN('.$supportTeamIds.') ';
  788.                 }
  789.                 $queryBuilder->leftJoin('ticket.supportGroup', 'supportGroup')
  790.                             ->leftJoin('ticket.supportTeam', 'supportTeam')
  791.                             ->andWhere('( ticket.agent = ' . $currentUser->getId().$query. ')');
  792.             }
  793.         }
  795.         // for all tickets count
  796.         $data['all'] = $queryBuilder->getQuery()->getSingleScalarResult();
  798.         // for new tickets count
  799.         $newQb = clone $queryBuilder;
  800.         $newQb->andWhere('ticket.isNew = 1');
  801.         $data['new'] = $newQb->getQuery()->getSingleScalarResult();
  803.         // for unassigned tickets count
  804.         $unassignedQb = clone $queryBuilder;
  805.         $unassignedQb->andWhere("ticket.agent is NULL");
  806.         $data['unassigned'] = $unassignedQb->getQuery()->getSingleScalarResult();
  808.         // for unanswered ticket count
  809.         $unansweredQb = clone $queryBuilder;
  810.         $unansweredQb->andWhere('ticket.isReplied = 0');
  811.         $data['notreplied'] = $unansweredQb->getQuery()->getSingleScalarResult();
  813.         // for my tickets count
  814.         $mineQb = clone $queryBuilder;
  815.         $mineQb->andWhere("ticket.agent = :agentId")
  816.                 ->setParameter('agentId', $currentUser->getId());
  817.         $data['mine'] = $mineQb->getQuery()->getSingleScalarResult();
  819.         // for starred tickets count
  820.         $starredQb = clone $queryBuilder;
  821.         $starredQb->andWhere('ticket.isStarred = 1');
  822.         $data['starred'] = $starredQb->getQuery()->getSingleScalarResult();
  824.         // for trashed tickets count
  825.         $trashedQb = clone $queryBuilder;
  826.         $trashedQb->where('ticket.isTrashed = 1');
  827.         if ($currentUser->getRoles()[0] != 'ROLE_SUPER_ADMIN' && $userInstance->getTicketAccesslevel() != 1) {
  828.             $trashedQb->andWhere('ticket.agent = ' . $currentUser->getId());
  829.         }
  830.         $data['trashed'] = $trashedQb->getQuery()->getSingleScalarResult();
  832.         return $data;
  833.     }
  834.     
  835.     public function paginateMembersTicketThreadCollection(Ticket $ticket, Request $request)
  836.     {
  837.         $params = $request->query->all();
  838.         $entityManager = $this->entityManager;
  839.         $activeUser = $this->container->get('user.service')->getSessionUser();
  841.         $activeUserTimeZone = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  842.         $agentTimeZone = !empty($activeUser->getTimezone()) ? $activeUser->getTimezone() : $activeUserTimeZone->getTimezone();
  843.         $agentTimeFormat = !empty($activeUser->getTimeformat()) ? $activeUser->getTimeformat() : $activeUserTimeZone->getTimeformat();
  844.         
  845.         $threadRepository = $entityManager->getRepository(Thread::class);
  846.         $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  848.         // Get base query
  849.         $enableLockedThreads = $this->container->get('user.service')->isAccessAuthorized('ROLE_AGENT_MANAGE_LOCK_AND_UNLOCK_THREAD');
  850.         $baseQuery = $threadRepository->prepareBasePaginationRecentThreadsQuery($ticket, $params, $enableLockedThreads);
  851.         
  852.         // Apply Pagination
  853.         $paginationItemsQuery = clone $baseQuery;
  854.         $totalPaginationItems = $paginationItemsQuery->select('COUNT(DISTINCT thread.id)')->getQuery()->getSingleScalarResult();
  855.         
  856.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  857.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $threadRepository::DEFAULT_PAGINATION_LIMIT;
  858.         
  859.         $paginationOptions = ['distinct' => true];
  860.         $paginationQuery = $baseQuery->getQuery()->setHydrationMode(Query::HYDRATE_ARRAY)->setHint('knp_paginator.count', (int) $totalPaginationItems);
  862.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  864.         // Process Pagination Response
  865.         $threadCollection = [];
  866.         $paginationParams = $pagination->getParams();
  867.         $paginationData = $pagination->getPaginationData();
  869.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'helpdesk']);
  870.         $timeZone = $website->getTimezone();
  871.         $timeFormat = $website->getTimeformat();
  873.         if (!empty($params['threadRequestedId'])) {
  874.             $requestedThreadCollection = $baseQuery
  875.                 ->andWhere('thread.id >= :threadRequestedId')->setParameter('threadRequestedId', (int) $params['threadRequestedId'])
  876.                 ->getQuery()->getArrayResult();
  877.             
  878.             $totalRequestedThreads = count($requestedThreadCollection);
  879.             $paginationData['current'] = ceil($totalRequestedThreads / $threadRepository::DEFAULT_PAGINATION_LIMIT);
  881.             if ($paginationData['current'] > 1) {
  882.                 $paginationData['firstItemNumber'] = 1;
  883.                 $paginationData['lastItemNumber'] = $totalRequestedThreads;
  884.                 $paginationData['next'] = ceil(($totalRequestedThreads + 1) / $threadRepository::DEFAULT_PAGINATION_LIMIT);
  885.             }
  886.         }
  888.         $paginationParams['page'] = 'replacePage';
  889.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  890.         foreach ($pagination->getItems() as $threadDetails) {
  891.             $dbTime = $threadDetails['createdAt'];
  892.             $formattedTime = $this->fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat);
  894.             $threadResponse = [
  895.                 'id'                => $threadDetails['id'],
  896.                 'user'              => null,
  897.                 'fullname'          => null,
  898.                 'reply'             => html_entity_decode($threadDetails['message']),
  899.                 'source'            => $threadDetails['source'],
  900.                 'threadType'        => $threadDetails['threadType'],
  901.                 'userType'          => $threadDetails['createdBy'],
  902.                 'timestamp'         => $formattedTime['dateTimeZone'],
  903.                 'formatedCreatedAt' => $formattedTime['dateTimeZone']->format($formattedTime['timeFormatString']),
  904.                 'bookmark'          => $threadDetails['isBookmarked'],
  905.                 'isLocked'          => $threadDetails['isLocked'],
  906.                 'replyTo'           => $threadDetails['replyTo'],
  907.                 'cc'                => $threadDetails['cc'],
  908.                 'bcc'               => $threadDetails['bcc'],
  909.                 'attachments'       => $threadDetails['attachments'],
  910.             ];
  911.   
  912.             if (!empty($threadDetails['user'])) {
  913.                 $threadResponse['fullname'] = trim($threadDetails['user']['firstName'] . ' ' . $threadDetails['user']['lastName']);
  914.                 $threadResponse['user'] = [
  915.                     'id' => $threadDetails['user']['id'],
  916.                     'smallThumbnail' => $threadDetails['user']['userInstance'][0]['profileImagePath'],
  917.                     'name' => $threadResponse['fullname'],
  918.                 ];
  919.             }
  921.             if (!empty($threadResponse['attachments'])) {
  922.                 $threadResponse['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService) {
  923.                     $attachmentReferenceObject = $entityManager->getReference(Attachment::class, $attachment['id']);
  924.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject);
  925.                 }, $threadResponse['attachments']);
  926.             }
  928.             array_push($threadCollection, $threadResponse);
  929.         }
  931.         return [
  932.             'threads'    => $threadCollection,
  933.             'pagination' => $paginationData,
  934.         ];
  935.     }
  937.     public function massXhrUpdate(Request $request)
  938.     {
  939.         $params = $request->request->get('data');
  941.         foreach ($params['ids'] as $ticketId) {
  942.             $ticket = $this->entityManager->getRepository(Ticket::class)->find($ticketId);
  944.             if (false == $this->isTicketAccessGranted($ticket)) {
  945.                 throw new \Exception('Access Denied', 403);
  946.             }
  947.             
  948.             if (empty($ticket)) {
  949.                 continue;
  950.             }
  952.             switch ($params['actionType']) {
  953.                 case 'trashed':
  954.                     if (false == $ticket->getIsTrashed()) {
  955.                         $ticket->setIsTrashed(true);
  956.                         
  957.                         $this->entityManager->persist($ticket);
  958.                     }
  960.                     // Trigger ticket delete event
  961.                     $event = new CoreWorkflowEvents\Ticket\Delete();
  962.                     $event
  963.                         ->setTicket($ticket)
  964.                     ;
  966.                     $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  968.                     break;
  969.                 case 'delete':
  970.                     $threads = $ticket->getThreads();
  971.                     $fileService = new Filesystem();
  973.                     if (count($threads) > 0) {
  974.                         foreach($threads as $thread) {
  975.                             if (!empty($thread)) {
  976.                                 $fileService->remove($this->container->getParameter('kernel.project_dir').'/public/assets/threads/'.$thread->getId());
  977.                             }
  978.                         }
  979.                     }
  981.                     $this->entityManager->remove($ticket);
  982.                     
  983.                     break;
  984.                 case 'restored':
  985.                     if (true == $ticket->getIsTrashed()) {
  986.                         $ticket->setIsTrashed(false);
  988.                         $this->entityManager->persist($ticket);
  989.                     }
  991.                     break;
  992.                 case 'agent':
  993.                     if ($ticket->getAgent() == null || $ticket->getAgent() && $ticket->getAgent()->getId() != $params['targetId']) {
  995.                         $agent = $this->entityManager->getRepository(User::class)->find($params['targetId']);
  996.                         $ticket->setAgent($agent);
  997.     
  998.                         $this->entityManager->persist($ticket);
  999.     
  1000.                         // Trigger Agent Assign event
  1001.                         $event = new CoreWorkflowEvents\Ticket\Agent();
  1002.                         $event
  1003.                             ->setTicket($ticket)
  1004.                         ;
  1005.     
  1006.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1007.                     }
  1009.                     break;
  1010.                 case 'status':
  1011.                     if ($ticket->getStatus() == null || $ticket->getStatus() && $ticket->getStatus()->getId() != $params['targetId']) {
  1013.                         $status = $this->entityManager->getRepository(TicketStatus::class)->findOneById($params['targetId']);
  1014.                         $ticket->setStatus($status);
  1016.                         $this->entityManager->persist($ticket);
  1018.                         // Trigger ticket status event
  1019.                         $event = new CoreWorkflowEvents\Ticket\Status();
  1020.                         $event
  1021.                             ->setTicket($ticket)
  1022.                         ;
  1023.                         
  1024.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1025.                     }
  1026.                     
  1027.                     break;
  1028.                 case 'type':
  1029.                     if ($ticket->getType() == null || $ticket->getType() && $ticket->getType()->getId() != $params['targetId']) {
  1031.                         $type = $this->entityManager->getRepository(TicketType::class)->findOneById($params['targetId']);
  1032.                         $ticket->setType($type);
  1033.     
  1034.                         $this->entityManager->persist($ticket);
  1035.     
  1036.                         // Trigger ticket type event
  1037.                         $event = new CoreWorkflowEvents\Ticket\Type();
  1038.                         $event
  1039.                             ->setTicket($ticket)
  1040.                         ;
  1041.     
  1042.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1043.                     }
  1045.                     break;
  1046.                 case 'group':
  1047.                     if ($ticket->getSupportGroup() == null || $ticket->getSupportGroup() && $ticket->getSupportGroup()->getId() != $params['targetId']) {
  1049.                         $group = $this->entityManager->getRepository(SupportGroup::class)->find($params['targetId']);
  1050.                         $ticket->setSupportGroup($group);
  1051.     
  1052.                         $this->entityManager->persist($ticket);
  1053.     
  1054.                         // Trigger Support group event
  1055.                         $event = new CoreWorkflowEvents\Ticket\Group();
  1056.                         $event
  1057.                             ->setTicket($ticket)
  1058.                         ;
  1059.     
  1060.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1061.                     }
  1063.                     break;
  1064.                 case 'team':
  1065.                     if ($ticket->getSupportTeam() == null || $ticket->getSupportTeam() && $ticket->getSupportTeam()->getId() != $params['targetId']){
  1067.                         $team = $this->entityManager->getRepository(SupportTeam::class)->find($params['targetId']);
  1068.                         $ticket->setSupportTeam($team);
  1069.                         
  1070.                         $this->entityManager->persist($ticket);
  1071.         
  1072.                         // Trigger team event
  1073.                         $event = new CoreWorkflowEvents\Ticket\Team();
  1074.                         $event
  1075.                             ->setTicket($ticket)
  1076.                         ;
  1077.         
  1078.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1079.                     }
  1081.                     break;
  1082.                 case 'priority':
  1083.                     if ($ticket->getPriority() == null || $ticket->getPriority() && $ticket->getPriority()->getId() != $params['targetId']) {
  1084.                         
  1085.                         $priority = $this->entityManager->getRepository(TicketPriority::class)->find($params['targetId']);
  1086.                         $ticket->setPriority($priority);
  1087.     
  1088.                         $this->entityManager->persist($ticket);
  1089.     
  1090.                         // Trigger ticket Priority event
  1091.                         $event = new CoreWorkflowEvents\Ticket\Priority();
  1092.                         $event
  1093.                             ->setTicket($ticket)
  1094.                         ;
  1095.     
  1096.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  1097.                     }
  1099.                     break;
  1100.                 case 'label':
  1101.                     $label = $this->entityManager->getRepository(SupportLabel::class)->find($params['targetId']);
  1102.                     
  1103.                     if ($label && !$this->entityManager->getRepository(Ticket::class)->isLabelAlreadyAdded($ticket, $label)) {
  1104.                         $ticket->addSupportLabel($label);
  1105.                     }
  1106.                     
  1107.                     $this->entityManager->persist($ticket);
  1109.                     break;
  1110.                 default:
  1111.                     break;
  1112.             }
  1113.         } 
  1115.         $this->entityManager->flush();
  1117.         if ($params['actionType'] == 'trashed') {
  1118.             $message = 'Success ! Tickets moved to trashed successfully.';
  1119.         } elseif ($params['actionType'] == 'restored') {
  1120.             $message = 'Success ! Tickets restored successfully.';
  1121.         } elseif ($params['actionType'] == 'delete') {
  1122.             $message = 'Success ! Tickets removed successfully.';
  1123.         } elseif ($params['actionType'] == 'agent'){
  1124.             $message = 'Success ! Agent assigned successfully.';
  1125.         } elseif ($params['actionType'] == 'status'){
  1126.             $message = 'Success ! Tickets status updated successfully.';
  1127.         } elseif ($params['actionType'] == 'type'){
  1128.             $message = 'Success ! Tickets type updated successfully.';
  1129.         } elseif ($params['actionType'] == 'group'){
  1130.             $message = 'Success ! Tickets group updated successfully.';
  1131.         } elseif ($params['actionType'] == 'team') {
  1132.             $message = 'Success ! Tickets team updated successfully.';
  1133.         } elseif ($params['actionType'] == 'priority') {
  1134.             $message = 'Success ! Tickets priority updated successfully.';
  1135.         } elseif ($params['actionType'] == 'label') {
  1136.             $message = 'Success ! Tickets added to label successfully.';  
  1137.         } else {
  1138.             $message = 'Success ! Tickets have been updated successfully';
  1139.         }
  1141.         return [
  1142.             'alertClass' => 'success',
  1143.             'alertMessage' => $this->trans($message),
  1144.         ];
  1145.     }
  1146.     
  1147.     public function getNotePlaceholderValues($ticket, $type = "customer")
  1148.     {
  1149.         $variables = array();
  1150.         $variables['ticket.id'] = $ticket->getId();
  1151.         $variables['ticket.subject'] = $ticket->getSubject();
  1153.         $variables['ticket.status'] = $ticket->getStatus()->getCode();
  1154.         $variables['ticket.priority'] = $ticket->getPriority()->getCode();
  1155.         if($ticket->getSupportGroup())
  1156.             $variables['ticket.group'] = $ticket->getSupportGroup()->getName();
  1157.         else
  1158.             $variables['ticket.group'] = '';
  1160.         $variables['ticket.team'] = ($ticket->getSupportTeam() ? $ticket->getSupportTeam()->getName() : '');
  1162.         $customer = $this->container->get('user.service')->getCustomerPartialDetailById($ticket->getCustomer()->getId());
  1163.         $variables['ticket.customerName'] = $customer['name'];
  1164.         $userService = $this->container->get('user.service');
  1165.       
  1166.         $variables['ticket.agentName'] = '';
  1167.         $variables['ticket.agentEmail'] = '';
  1168.         if ($ticket->getAgent()) {
  1169.             $agent = $this->container->get('user.service')->getAgentDetailById($ticket->getAgent()->getId());
  1170.             if($agent) {
  1171.                 $variables['ticket.agentName'] = $agent['name'];
  1172.                 $variables['ticket.agentEmail'] = $agent['email'];
  1173.             }
  1174.         }
  1176.         $router = $this->container->get('router');
  1178.         if ($type == 'customer') {
  1179.             $ticketListURL = $router->generate('helpdesk_member_ticket_collection', [
  1180.                 'id' => $ticket->getId(),
  1181.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1182.         } else {
  1183.             $ticketListURL = $router->generate('helpdesk_customer_ticket_collection', [
  1184.                 'id' => $ticket->getId(),
  1185.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1186.         }
  1188.         $variables['ticket.link'] = sprintf("<a href='%s'>#%s</a>", $ticketListURL, $ticket->getId());
  1190.         return $variables;
  1191.     }
  1193.     public function paginateMembersTicketTypeCollection(Request $request)
  1194.     {
  1195.         // Get base query
  1196.         $params = $request->query->all();
  1197.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  1198.         $paginationQuery = $ticketRepository->prepareBasePaginationTicketTypesQuery($params);
  1200.         // Apply Pagination
  1201.         $paginationOptions = ['distinct' => true];
  1202.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  1203.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  1205.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  1207.         // Process Pagination Response
  1208.         $paginationParams = $pagination->getParams();
  1209.         $paginationData = $pagination->getPaginationData();
  1211.         $paginationParams['page'] = 'replacePage';
  1212.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  1214.         return [
  1215.             'types' => array_map(function ($ticketType) {
  1216.                 return [
  1217.                     'id' => $ticketType->getId(),
  1218.                     'code' => strtoupper($ticketType->getCode()),
  1219.                     'description' => $ticketType->getDescription(),
  1220.                     'isActive' => $ticketType->getIsActive(),
  1221.                 ];
  1222.             }, $pagination->getItems()),
  1223.             'pagination_data' => $paginationData,
  1224.         ];
  1225.     }
  1227.     public function paginateMembersTagCollection(Request $request)
  1228.     {
  1229.         // Get base query
  1230.         $params = $request->query->all();
  1231.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  1232.         $baseQuery = $ticketRepository->prepareBasePaginationTagsQuery($params);
  1234.         // Apply Pagination
  1235.         $paginationResultsQuery = clone $baseQuery;
  1236.         $paginationResultsQuery->select('COUNT(supportTag.id)');
  1237.         $paginationQuery = $baseQuery->getQuery()->setHydrationMode(Query::HYDRATE_ARRAY)->setHint('knp_paginator.count', count($paginationResultsQuery->getQuery()->getResult()));
  1239.         $paginationOptions = ['distinct' => true];
  1240.         $pageNumber = !empty($params['page']) ? (int) $params['page'] : 1;
  1241.         $itemsLimit = !empty($params['limit']) ? (int) $params['limit'] : $ticketRepository::DEFAULT_PAGINATION_LIMIT;
  1243.         $pagination = $this->container->get('knp_paginator')->paginate($paginationQuery, $pageNumber, $itemsLimit, $paginationOptions);
  1245.         // Process Pagination Response
  1246.         $paginationParams = $pagination->getParams();
  1247.         $paginationData = $pagination->getPaginationData();
  1249.         $paginationParams['page'] = 'replacePage';
  1250.         $paginationData['url'] = '#' . $this->container->get('uvdesk.service')->buildPaginationQuery($paginationParams);
  1252.         if (in_array('UVDeskSupportCenterBundle', array_keys($this->container->getParameter('kernel.bundles')))) {
  1253.             $articleRepository = $this->entityManager->getRepository(Article::class);
  1255.             return [
  1256.                 'tags' => array_map(function ($supportTag) use ($articleRepository) {
  1257.                     return [
  1258.                         'id'           => $supportTag['id'],
  1259.                         'name'         => $supportTag['name'],
  1260.                         'ticketCount'  => $supportTag['totalTickets'],
  1261.                         'articleCount' => $articleRepository->getTotalArticlesBySupportTag($supportTag['id']),
  1262.                     ];
  1263.                 }, $pagination->getItems()),
  1264.                 'pagination_data' => $paginationData,
  1265.             ];
  1266.         } else {
  1267.             return [
  1268.                 'tags' => array_map(function ($supportTag) {
  1269.                     return [
  1270.                         'id'          => $supportTag['id'],
  1271.                         'name'        => $supportTag['name'],
  1272.                         'ticketCount' => $supportTag['totalTickets'],
  1273.                     ];
  1274.                 }, $pagination->getItems()),
  1275.                 'pagination_data' => $paginationData,
  1276.             ];
  1277.         }
  1278.     }
  1280.     public function getTicketInitialThreadDetails(Ticket $ticket)
  1281.     {
  1282.         $initialThread = $this->entityManager->getRepository(Thread::class)->findOneBy([
  1283.             'ticket'     => $ticket,
  1284.             'threadType' => 'create',
  1285.         ]);
  1287.         if (!empty($initialThread)) {
  1288.             $author = $initialThread->getUser();
  1289.             $authorInstance = 'agent' == $initialThread->getCreatedBy() ? $author->getAgentInstance() : $author->getCustomerInstance();
  1290.         
  1291.             $threadDetails = [
  1292.                 'id'          => $initialThread->getId(),
  1293.                 'source'      => $initialThread->getSource(),
  1294.                 'messageId'   => $initialThread->getMessageId(),
  1295.                 'threadType'  => $initialThread->getThreadType(),
  1296.                 'createdBy'   => $initialThread->getCreatedBy(),
  1297.                 'message'     => html_entity_decode($initialThread->getMessage()),
  1298.                 'attachments' => $initialThread->getAttachments(),
  1299.                 'timestamp'   => $initialThread->getCreatedAt()->getTimestamp(),
  1300.                 'createdAt'   => $initialThread->getCreatedAt()->format('d-m-Y h:ia'),
  1301.                 'user'        => $authorInstance->getPartialDetails(),
  1302.                 'cc'          => is_array($initialThread->getCc()) ? implode(', ', $initialThread->getCc()) : '',
  1303.             ];
  1305.             $attachments = $threadDetails['attachments']->getValues();
  1307.             if (!empty($attachments)) {
  1308.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1310.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($uvdeskFileSystemService) {
  1311.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachment);
  1312.                 }, $attachments);
  1313.             }
  1314.         }
  1316.         return $threadDetails ?? null;
  1317.     }
  1319.     public function getCreateReply($ticketId, $firewall = 'member')
  1320.     {
  1321.         $qb = $this->entityManager->createQueryBuilder();
  1322.         $qb->select("th,a,u.id as userId")->from(Thread::class, 'th')
  1323.                 ->leftJoin('th.ticket','t')
  1324.                 ->leftJoin('th.attachments', 'a')
  1325.                 ->leftJoin('th.user','u')
  1326.                 ->andWhere('t.id = :ticketId')
  1327.                 ->andWhere('th.threadType = :threadType')
  1328.                 ->setParameter('threadType','create')
  1329.                 ->setParameter('ticketId',$ticketId)
  1330.                 ->orderBy('th.id', 'DESC')
  1331.                 ->getMaxResults(1);
  1333.         $threadResponse = $qb->getQuery()->getArrayResult();
  1335.         if ((!empty($threadResponse[0][0]))) {
  1336.             $threadDetails = $threadResponse[0][0];
  1337.             $userService = $this->container->get('user.service');
  1338.             
  1339.             if ($threadDetails['createdBy'] == 'agent') {
  1340.                 $threadDetails['user'] = $userService->getAgentDetailById($threadResponse[0]['userId']);
  1341.             } else {
  1342.                 $threadDetails['user'] = $userService->getCustomerPartialDetailById($threadResponse[0]['userId']);
  1343.             }
  1344.             
  1345.             $threadDetails['reply'] = html_entity_decode($threadDetails['message']);
  1346.             $threadDetails['formatedCreatedAt'] = $this->timeZoneConverter($threadDetails['createdAt']);    
  1347.             $threadDetails['timestamp'] = $userService->convertToDatetimeTimezoneTimestamp($threadDetails['createdAt']);
  1348.         
  1349.             if (!empty($threadDetails['attachments'])) {
  1350.                 $entityManager = $this->entityManager;
  1351.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1353.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService, $firewall) {
  1354.                     $attachmentReferenceObject = $entityManager->getReference(Attachment::class, $attachment['id']);
  1355.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject, $firewall);
  1356.                 }, $threadDetails['attachments']);
  1357.             }
  1358.         }
  1359.         
  1360.         return $threadDetails ?? null;
  1361.     }
  1363.     public function hasAttachments($ticketId) {
  1364.         $qb = $this->entityManager->createQueryBuilder();
  1365.         $qb->select("DISTINCT COUNT(a.id) as attachmentCount")->from(Thread::class, 'th')
  1366.                 ->leftJoin('th.ticket','t')
  1367.                 ->leftJoin('th.attachments','a')
  1368.                 ->andWhere('t.id = :ticketId')
  1369.                 ->setParameter('ticketId',$ticketId);
  1371.         return intval($qb->getQuery()->getSingleScalarResult());
  1372.     }
  1374.     public function getAgentDraftReply()
  1375.     {
  1376.         $signature = $this->getUser()->getAgentInstance()->getSignature();
  1377.         
  1378.         return str_replace( "\n", '<br/>', $signature);
  1379.     }
  1381.     public function trans($text)
  1382.     {
  1383.         return $this->container->get('translator')->trans($text);
  1384.     }
  1386.     public function getAllSources()
  1387.     {
  1388.         $sources = ['email' => 'Email', 'website' => 'Website'];
  1390.         return $sources;
  1391.     }
  1393.     public function getCustomLabelDetails($container)
  1394.     {
  1395.         $currentUser = $container->get('user.service')->getCurrentUser();
  1397.         $qb = $this->entityManager->createQueryBuilder();
  1398.         $qb->select('COUNT(DISTINCT t) as ticketCount,sl.id')->from(Ticket::class, 't')
  1399.                 ->leftJoin('t.supportLabels','sl')
  1400.                 ->andWhere('sl.user = :userId')
  1401.                 ->setParameter('userId', $currentUser->getId())
  1402.                 ->groupBy('sl.id');
  1404.         $ticketCountResult = $qb->getQuery()->getResult();
  1406.         $data = array();
  1407.         $qb = $this->entityManager->createQueryBuilder();
  1408.         $qb->select('sl.id,sl.name,sl.colorCode')->from(SupportLabel::class, 'sl')
  1409.                 ->andWhere('sl.user = :userId')
  1410.                 ->setParameter('userId', $currentUser->getId());
  1412.         $labels = $qb->getQuery()->getResult();
  1414.         foreach ($labels as $key => $label) {
  1415.             $labels[$key]['count'] = 0;
  1416.             foreach ($ticketCountResult as $ticketCount) {
  1417.                 if (($label['id'] == $ticketCount['id']))
  1418.                     $labels[$key]['count'] = $ticketCount['ticketCount'] ?: 0;
  1419.             }
  1420.         }
  1422.         return $labels;
  1423.     }
  1425.     public function getLabels($request = null)
  1426.     {
  1427.         static $labels;
  1428.         if (null !== $labels)
  1429.             return $labels;
  1431.         $qb = $this->entityManager->createQueryBuilder();
  1432.         $qb->select('sl')->from(SupportLabel::class, 'sl')
  1433.             ->andWhere('sl.user = :userId')
  1434.             ->setParameter('userId', $this->getUser()->getId());
  1436.         if ($request) {
  1437.             $qb->andWhere("sl.name LIKE :labelName");
  1438.             $qb->setParameter('labelName', '%'.urldecode(trim($request->query->get('query'))).'%');
  1439.         }
  1441.         return $labels = $qb->getQuery()->getArrayResult();
  1442.     }
  1444.     public function getTicketCollaborators($ticketId)
  1445.     {
  1446.         $qb = $this->entityManager->createQueryBuilder();
  1447.         $qb->select("DISTINCT c.id, c.email, CONCAT(c.firstName,' ', c.lastName) AS name, userInstance.profileImagePath, userInstance.profileImagePath as smallThumbnail")->from(Ticket::class, 't')
  1448.                 ->leftJoin('t.collaborators', 'c')
  1449.                 ->leftJoin('c.userInstance', 'userInstance')
  1450.                 ->andWhere('t.id = :ticketId')
  1451.                 ->andWhere('userInstance.supportRole = :roles')
  1452.                 ->setParameter('ticketId', $ticketId)
  1453.                 ->setParameter('roles', 4)
  1454.                 ->orderBy('name','ASC');
  1456.         return $qb->getQuery()->getArrayResult();
  1457.     }
  1459.     public function getTicketTagsById($ticketId)
  1460.     {
  1461.         $qb = $this->entityManager->createQueryBuilder();
  1462.         $qb->select('tg')->from(Tag::class, 'tg')
  1463.                 ->leftJoin('tg.tickets' ,'t')
  1464.                 ->andWhere('t.id = :ticketId')
  1465.                 ->setParameter('ticketId', $ticketId);
  1467.         return $qb->getQuery()->getArrayResult();
  1468.     }
  1470.     public function getTicketLabels($ticketId)
  1471.     {
  1472.         $qb = $this->entityManager->createQueryBuilder();
  1473.         $qb->select('DISTINCT sl.id,sl.name,sl.colorCode')->from(Ticket::class, 't')
  1474.                 ->leftJoin('t.supportLabels','sl')
  1475.                 ->leftJoin('sl.user','slu')
  1476.                 ->andWhere('slu.id = :userId')
  1477.                 ->andWhere('t.id = :ticketId')
  1478.                 ->setParameter('userId', $this->getUser()->getId())
  1479.                 ->setParameter('ticketId', $ticketId);
  1481.         $result = $qb->getQuery()->getResult();
  1482.         
  1483.         return $result ? $result : [];
  1484.     }
  1486.     public function getUserLabels()
  1487.     {
  1488.         $qb = $this->entityManager->createQueryBuilder();
  1489.         $qb->select('sl')->from(SupportLabel::class, 'sl')
  1490.                 ->leftJoin('sl.user','slu')
  1491.                 ->andWhere('slu.id = :userId')
  1492.                 ->setParameter('userId', $this->getUser()->getId());
  1494.         $result = $qb->getQuery()->getResult();
  1495.         
  1496.         return $result ? $result : [];
  1497.     }
  1499.     public function getTicketLabelsAll($ticketId)
  1500.     {
  1501.         $qb = $this->entityManager->createQueryBuilder();
  1502.         $qb->select('DISTINCT sl.id,sl.name,sl.colorCode')->from(Ticket::class, 't')
  1503.                 ->leftJoin('t.supportLabels','sl')
  1504.                 ->andWhere('t.id = :ticketId')
  1505.                 ->setParameter('ticketId', $ticketId);
  1507.         $result = $qb->getQuery()->getResult();
  1508.         
  1509.         return $result ? $result : [];
  1510.     }
  1512.     public function getManualWorkflow()
  1513.     {
  1514.         $preparedResponseIds = [];
  1515.         $groupIds = [];
  1516.         $teamIds = []; 
  1517.         $userId = $this->container->get('user.service')->getCurrentUser()->getAgentInstance()->getId();
  1519.         $preparedResponseRepo = $this->entityManager->getRepository(PreparedResponses::class)->findAll();
  1521.         foreach ($preparedResponseRepo as $pr) {
  1522.             if ($userId == $pr->getUser()->getId()) {
  1523.                 //Save the ids of the saved reply.
  1524.                 array_push($preparedResponseIds, (int)$pr->getId());
  1525.             }
  1526.         }
  1528.         // Get the ids of the Group(s) the current user is associated with.
  1529.         $query = "select * from uv_user_support_groups where userInstanceId =".$userId;
  1530.         $connection = $this->entityManager->getConnection();
  1531.         $stmt = $connection->prepare($query);
  1532.         $stmt->execute();
  1533.         $result = $stmt->fetchAll();
  1535.         foreach ($result as $row) {
  1536.             array_push($groupIds, $row['supportGroupId']);
  1537.         }
  1539.         // Get all the saved reply's ids that is associated with the user's group(s).
  1540.         $query = "select * from uv_prepared_response_support_groups";
  1541.         $stmt = $connection->prepare($query);
  1542.         $stmt->execute();
  1543.         $result = $stmt->fetchAll();
  1545.         foreach ($result as $row) {
  1546.             if (in_array($row['group_id'], $groupIds)) {
  1547.                 array_push($preparedResponseIds, (int) $row['savedReply_id']);
  1548.             }
  1549.         }
  1551.         // Get the ids of the Team(s) the current user is associated with.
  1552.         $query = "select * from uv_user_support_teams";
  1553.         $connection = $this->entityManager->getConnection();
  1554.         $stmt = $connection->prepare($query);
  1555.         $stmt->execute();
  1556.         $result = $stmt->fetchAll();
  1558.         foreach($result as $row) {
  1559.             if ($row['userInstanceId'] == $userId) {
  1560.                 array_push($teamIds, $row['supportTeamId']);
  1561.             }
  1562.         }
  1564.         $query = "select * from uv_prepared_response_support_teams";
  1565.         $stmt = $connection->prepare($query);
  1566.         $stmt->execute();
  1567.         $result = $stmt->fetchAll();
  1569.         foreach ($result as $row) {
  1570.             if (in_array($row['subgroup_id'], $teamIds)) {
  1571.                 array_push($preparedResponseIds, (int)$row['savedReply_id']);
  1572.             }
  1573.         }
  1575.         $qb = $this->entityManager->createQueryBuilder();
  1576.         $qb->select('DISTINCT mw')
  1577.             ->from(PreparedResponses::class, 'mw')
  1578.             ->where('mw.status = 1')
  1579.             ->andWhere('mw.id IN (:ids)')
  1580.             ->setParameter('ids', $preparedResponseIds);
  1581.         
  1582.         return $qb->getQuery()->getResult();
  1583.     }
  1585.     public function getSavedReplies()
  1586.     {   
  1587.         $savedReplyIds = [];
  1588.         $groupIds = [];
  1589.         $teamIds = []; 
  1590.         $userId = $this->container->get('user.service')->getCurrentUser()->getAgentInstance()->getId();
  1592.         $savedReplyRepo = $this->entityManager->getRepository(SavedReplies::class)->findAll();
  1594.         foreach ($savedReplyRepo as $sr) {
  1595.             if ($userId == $sr->getUser()->getId()) {
  1596.                 //Save the ids of the saved reply.
  1597.                 array_push($savedReplyIds, (int)$sr->getId());
  1598.             }
  1599.         }
  1601.         // Get the ids of the Group(s) the current user is associated with.
  1602.         $query = "select * from uv_user_support_groups where userInstanceId =".$userId;
  1603.         $connection = $this->entityManager->getConnection();
  1604.         $stmt = $connection->prepare($query);
  1605.         $stmt->execute();
  1606.         $result = $stmt->fetchAll();
  1608.         foreach ($result as $row) {
  1609.             array_push($groupIds, $row['supportGroupId']);
  1610.         }
  1612.         // Get all the saved reply's ids that is associated with the user's group(s).
  1613.         $query = "select * from uv_saved_replies_groups";
  1614.         $stmt = $connection->prepare($query);
  1615.         $stmt->execute();
  1616.         $result = $stmt->fetchAll();
  1618.         foreach ($result as $row) {
  1619.             if (in_array($row['group_id'], $groupIds)) {
  1620.                 array_push($savedReplyIds, (int) $row['savedReply_id']);
  1621.             }
  1622.         }
  1624.         // Get the ids of the Team(s) the current user is associated with.
  1625.         $query = "select * from uv_user_support_teams";
  1626.         $connection = $this->entityManager->getConnection();
  1627.         $stmt = $connection->prepare($query);
  1628.         $stmt->execute();
  1629.         $result = $stmt->fetchAll();
  1631.         foreach ($result as $row) {
  1632.             if ($row['userInstanceId'] == $userId) {
  1633.                 array_push($teamIds, $row['supportTeamId']);
  1634.             }
  1635.         }
  1637.         $query = "select * from uv_saved_replies_teams";
  1638.         $stmt = $connection->prepare($query);
  1639.         $stmt->execute();
  1640.         $result = $stmt->fetchAll();
  1642.         foreach ($result as $row) {
  1643.             if (in_array($row['subgroup_id'], $teamIds)) {
  1644.                 array_push($savedReplyIds, (int)$row['savedReply_id']);
  1645.             }
  1646.         }
  1648.         $qb = $this->entityManager->createQueryBuilder();
  1649.         $qb->select('DISTINCT sr')
  1650.         ->from(SavedReplies::class, 'sr')
  1651.         ->Where('sr.id IN (:ids)')
  1652.         ->setParameter('ids', $savedReplyIds);
  1653.         
  1654.         return $qb->getQuery()->getResult();
  1655.     }
  1657.     public function getPriorities()
  1658.     {
  1659.         static $priorities;
  1660.         if (null !== $priorities)
  1661.             return $priorities;
  1663.         $qb = $this->entityManager->createQueryBuilder();
  1664.         $qb->select('tp')->from(TicketPriority::class, 'tp');
  1666.         return $priorities = $qb->getQuery()->getArrayResult();
  1667.     }
  1669.     public function getTicketLastThread($ticketId)
  1670.     {
  1671.         $qb = $this->entityManager->createQueryBuilder();
  1672.         $qb->select("th")->from(Thread::class, 'th')
  1673.                 ->leftJoin('th.ticket','t')
  1674.                 ->andWhere('t.id = :ticketId')
  1675.                 ->setParameter('ticketId',$ticketId)
  1676.                 ->orderBy('th.id', 'DESC');
  1678.         return $qb->getQuery()->setMaxResults(1)->getSingleResult();
  1679.     }
  1681.     public function getlastReplyAgentName($ticketId)
  1682.     {
  1683.         $qb = $this->entityManager->createQueryBuilder();
  1684.         $qb->select("u.id,CONCAT(u.firstName,' ', u.lastName) AS name,u.firstName")->from(Thread::class, 'th')
  1685.                 ->leftJoin('th.ticket','t')
  1686.                 ->leftJoin('th.user', 'u')
  1687.                 ->leftJoin('u.userInstance', 'userInstance')
  1688.                 ->andWhere('userInstance.supportRole != :roles')
  1689.                 ->andWhere('t.id = :ticketId')
  1690.                 ->andWhere('th.threadType = :threadType')
  1691.                 ->setParameter('threadType','reply')
  1692.                 ->andWhere('th.createdBy = :createdBy')
  1693.                 ->setParameter('createdBy','agent')
  1694.                 ->setParameter('ticketId',$ticketId)
  1695.                 ->setParameter('roles', 4)
  1696.                 ->orderBy('th.id', 'DESC');
  1698.         $result = $qb->getQuery()->setMaxResults(1)->getResult();
  1700.         return $result ? $result[0] : null;
  1701.     }
  1703.     public function getLastReply($ticketId, $userType = null) 
  1704.     {
  1705.         $queryBuilder = $this->entityManager->createQueryBuilder();
  1706.         $queryBuilder->select("th, a, u.id as userId")
  1707.             ->from(Thread::class, 'th')
  1708.             ->leftJoin('th.ticket','t')
  1709.             ->leftJoin('th.attachments', 'a')
  1710.             ->leftJoin('th.user','u')
  1711.             ->andWhere('t.id = :ticketId')
  1712.             ->andWhere('th.threadType = :threadType')
  1713.             ->setParameter('threadType','reply')
  1714.             ->setParameter('ticketId',$ticketId)
  1715.             ->orderBy('th.id', 'DESC')
  1716.             ->getMaxResults(1);
  1718.         if (!empty($userType)) {
  1719.             $queryBuilder->andWhere('th.createdBy = :createdBy')->setParameter('createdBy', $userType);
  1720.         }
  1721.         
  1722.         $threadResponse = $queryBuilder->getQuery()->getArrayResult();
  1723.         
  1724.         if (!empty($threadResponse[0][0])) {
  1725.             $threadDetails = $threadResponse[0][0];
  1726.             $userService = $this->container->get('user.service');
  1727.             
  1728.             if ($threadDetails['createdBy'] == 'agent') {
  1729.                 $threadDetails['user'] = $userService->getAgentDetailById($threadResponse[0]['userId']);
  1730.             } else {
  1731.                 $threadDetails['user'] = $userService->getCustomerPartialDetailById($threadResponse[0]['userId']);
  1732.             }
  1733.             
  1734.             $threadDetails['reply'] = html_entity_decode($threadDetails['message']);
  1735.             $threadDetails['formatedCreatedAt'] = $this->timeZoneConverter($threadDetails['createdAt']);
  1736.             $threadDetails['timestamp'] = $userService->convertToDatetimeTimezoneTimestamp($threadDetails['createdAt']);
  1738.             if (!empty($threadDetails['attachments'])) {
  1739.                 $entityManager = $this->entityManager;
  1740.                 $uvdeskFileSystemService = $this->container->get('uvdesk.core.file_system.service');
  1742.                 $threadDetails['attachments'] = array_map(function ($attachment) use ($entityManager, $uvdeskFileSystemService) {
  1743.                     $attachmentReferenceObject = $this->entityManager->getReference(Attachment::class, $attachment['id']);
  1744.                     return $uvdeskFileSystemService->getFileTypeAssociations($attachmentReferenceObject);
  1745.                 }, $threadDetails['attachments']);
  1746.             }
  1747.         }
  1749.         return $threadDetails ?? null;
  1750.     }
  1752.     public function getSavedReplyContent($savedReplyId, $ticketId)
  1753.     {
  1754.         $ticket = $this->entityManager->getRepository(Ticket::class)->find($ticketId);
  1755.         $savedReply = $this->entityManager->getRepository(SavedReplies::class)->findOneById($savedReplyId);
  1756.         $emailPlaceholders = $this->getSavedReplyPlaceholderValues($ticket, 'customer');
  1758.         return $this->container->get('email.service')->processEmailContent($savedReply->getMessage(), $emailPlaceholders, true);
  1759.     }
  1761.     public function getSavedReplyPlaceholderValues($ticket, $type = "customer")
  1762.     {
  1763.         $variables = array();
  1764.         $variables['ticket.id'] = $ticket->getId();
  1765.         $variables['ticket.subject'] = $ticket->getSubject();
  1767.         $variables['ticket.status'] = $ticket->getStatus()->getCode();
  1768.         $variables['ticket.priority'] = $ticket->getPriority()->getCode();
  1769.         if ($ticket->getSupportGroup())
  1770.             $variables['ticket.group'] = $ticket->getSupportGroup()->getName();
  1771.         else
  1772.             $variables['ticket.group'] = '';
  1774.         $variables['ticket.team'] = ($ticket->getSupportTeam() ? $ticket->getSupportTeam()->getName() : '');
  1776.         $customer = $this->container->get('user.service')->getCustomerPartialDetailById($ticket->getCustomer()->getId());
  1777.         $variables['ticket.customerName'] = $customer['name'];
  1778.         $variables['ticket.customerEmail'] = $customer['email'];
  1779.         $userService = $this->container->get('user.service');
  1780.       
  1781.         $variables['ticket.agentName'] = '';
  1782.         $variables['ticket.agentEmail'] = '';
  1783.         if ($ticket->getAgent()) {
  1784.             $agent = $this->container->get('user.service')->getAgentDetailById($ticket->getAgent()->getId());
  1785.             if ($agent) {
  1786.                 $variables['ticket.agentName'] = $agent['name'];
  1787.                 $variables['ticket.agentEmail'] = $agent['email'];
  1788.             }
  1789.         }
  1790.         
  1791.         $router = $this->container->get('router');
  1793.         if ($type == 'customer') {
  1794.             $ticketListURL = $router->generate('helpdesk_customer_ticket_collection', [
  1795.                 'id' => $ticket->getId(),
  1796.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1797.         } else {
  1798.             $ticketListURL = $router->generate('helpdesk_member_ticket_collection', [
  1799.                 'id' => $ticket->getId(),
  1800.             ], UrlGeneratorInterface::ABSOLUTE_URL);
  1801.         }
  1803.         $variables['ticket.link'] = sprintf("<a href='%s'>#%s</a>", $ticketListURL, $ticket->getId());
  1805.         return $variables;
  1806.     }
  1808.     public function isEmailBlocked($email, $website) 
  1809.     {
  1810.         $flag = false;
  1811.         $email = strtolower($email);
  1812.         $knowlegeBaseWebsite = $this->entityManager->getRepository(KnowledgebaseWebsite::class)->findOneBy(['website' => $website->getId(), 'isActive' => 1]);
  1813.         $list = $this->container->get('user.service')->getWebsiteSpamDetails($knowlegeBaseWebsite);
  1815.         // Blacklist
  1816.         if (!empty($list['blackList']['email']) && in_array($email, $list['blackList']['email'])) {
  1817.             // Emails
  1818.             $flag = true;
  1819.         } elseif (!empty($list['blackList']['domain'])) {
  1820.             // Domains
  1821.             foreach ($list['blackList']['domain'] as $domain) {
  1822.                 if (strpos($email, $domain)) {
  1823.                     $flag = true;
  1824.                     break;
  1825.                 }
  1826.             }
  1827.         }
  1829.         // Whitelist
  1830.         if ($flag) {
  1831.             if (isset($email, $list['whiteList']['email']) && in_array($email, $list['whiteList']['email'])) {
  1832.                 // Emails
  1833.                 return false;
  1834.             } elseif (isset($list['whiteList']['domain'])) {
  1835.                 // Domains
  1836.                 foreach ($list['whiteList']['domain'] as $domain) {
  1837.                     if (strpos($email, $domain)) {
  1838.                         $flag = false;
  1839.                     }
  1840.                 }
  1841.             }
  1842.         }
  1844.         return $flag;
  1845.     }
  1847.     public function timeZoneConverter($dateFlag)
  1848.     {
  1849.         $website = $this->entityManager->getRepository(Website::class)->findOneBy(['code' => 'Knowledgebase']);
  1850.         $timeZone = $website->getTimezone();
  1851.         $timeFormat = $website->getTimeformat();
  1853.         $activeUser = $this->container->get('user.service')->getSessionUser();
  1854.         $agentTimeZone = !empty($activeUser) ? $activeUser->getTimezone() : null;
  1855.         $agentTimeFormat = !empty($activeUser) ? $activeUser->getTimeformat() : null;
  1857.         $parameterType = gettype($dateFlag);
  1858.         if ($parameterType == 'string') {
  1859.             if (is_null($agentTimeZone) && is_null($agentTimeFormat)) {
  1860.                 if(is_null($timeZone) && is_null($timeFormat)){
  1861.                     $datePattern = date_create($dateFlag);
  1863.                     return date_format($datePattern,'d-m-Y h:ia');
  1864.                 } else {
  1865.                     $dateFlag = new \DateTime($dateFlag);
  1866.                     $datePattern = $dateFlag->setTimezone(new \DateTimeZone($timeZone));
  1868.                     return date_format($datePattern, $timeFormat);
  1869.                 }
  1870.             } else {
  1871.                 $dateFlag = new \DateTime($dateFlag);
  1872.                 $datePattern = $dateFlag->setTimezone(new \DateTimeZone($agentTimeZone));
  1874.                 return date_format($datePattern, $agentTimeFormat);
  1875.             }          
  1876.         } else {
  1877.             if (is_null($agentTimeZone) && is_null($agentTimeFormat)){
  1878.                 if (is_null($timeZone) && is_null($timeFormat)) {
  1879.                     return date_format($dateFlag,'d-m-Y h:ia');
  1880.                 } else {
  1881.                     $datePattern = $dateFlag->setTimezone(new \DateTimeZone($timeZone));
  1882.                     return date_format($datePattern, $timeFormat);
  1883.                 }
  1884.             } else {
  1885.                 $datePattern = $dateFlag->setTimezone(new \DateTimeZone($agentTimeZone));
  1887.                 return date_format($datePattern, $agentTimeFormat);
  1888.             }    
  1889.         }         
  1890.     }
  1892.     public function fomatTimeByPreference($dbTime,$timeZone,$timeFormat,$agentTimeZone,$agentTimeFormat)
  1893.     {
  1894.         if (is_null($agentTimeZone) && is_null($agentTimeFormat)) {
  1895.             if (is_null($timeZone) && is_null($timeFormat)) {
  1896.                 $dateTimeZone = $dbTime;
  1897.                 $timeFormatString = 'd-m-Y h:ia';
  1898.             } else {
  1899.                 $dateTimeZone = $dbTime->setTimezone(new \DateTimeZone($timeZone));
  1900.                 $timeFormatString = $timeFormat;
  1901.             }
  1902.         } else {
  1903.             $dateTimeZone = $dbTime->setTimezone(new \DateTimeZone($agentTimeZone));
  1904.             $timeFormatString = $agentTimeFormat;
  1905.         }
  1907.         $time['dateTimeZone'] = $dateTimeZone;
  1908.         $time['timeFormatString'] = $timeFormatString;
  1910.         return $time;
  1911.     }
  1912.     
  1913.     public function isTicketAccessGranted(Ticket $ticket, User $user = null, $firewall = 'members')
  1914.     {
  1915.         // @TODO: Take current firewall into consideration (access check on behalf of agent/customer)
  1916.         if (empty($user)) {
  1917.             $user = $this->container->get('user.service')->getSessionUser();
  1918.         }
  1920.         if (empty($user)) {
  1921.             return false;
  1922.         } else {
  1923.             $agentInstance = $user->getAgentInstance();
  1924.     
  1925.             if (empty($agentInstance)) {
  1926.                 return false;
  1927.             }
  1928.         }
  1930.         if ($agentInstance->getSupportRole()->getId() == 3 && in_array($agentInstance->getTicketAccessLevel(), [2, 3, 4])) {
  1931.             $accessLevel = $agentInstance->getTicketAccessLevel();
  1933.             // Check if user has been given inidividual access
  1934.             if ($ticket->getAgent() != null && $ticket->getAgent()->getId() == $user->getId()) {
  1935.                 return true;
  1936.             }
  1937.             
  1938.             if ($accessLevel == 2 || $accessLevel == 3) {
  1939.                 // Check if user belongs to a support team assigned to ticket
  1940.                 $teamReferenceIds = array_map(function ($team) { return $team->getId(); }, $agentInstance->getSupportTeams()->toArray());
  1941.                 
  1942.                 if ($ticket->getSupportTeam() != null && in_array($ticket->getSupportTeam()->getId(), $teamReferenceIds)) {
  1943.                     return true;
  1944.                 } else if ($accessLevel == 2) {
  1945.                     // Check if user belongs to a support group assigned to ticket
  1946.                     $groupReferenceIds = array_map(function ($group) { return $group->getId(); }, $agentInstance->getSupportGroups()->toArray());
  1948.                     if ($ticket->getSupportGroup() != null && in_array($ticket->getSupportGroup()->getId(), $groupReferenceIds)) {
  1949.                         return true;
  1950.                     }
  1951.                 }
  1952.             }
  1954.             return false;
  1955.         }
  1957.         return true;
  1958.     }
  1960.     public function addTicketCustomFields($thread, $submittedCustomFields = [], $uploadedFilesCollection = [])
  1961.     {
  1962.         $customFieldsService = null;
  1963.         $customFieldsEntityReference = null;
  1964.         
  1965.         if ($this->userService->isFileExists('apps/uvdesk/custom-fields')) {
  1966.             $customFieldsService = $this->container->get('uvdesk_package_custom_fields.service');
  1967.             $customFieldsEntityReference = UVDeskCommunityPackages\CustomFields\Entity\CustomFields::class;
  1968.             $customFieldValuesEntityReference = UVDeskCommunityPackages\CustomFields\Entity\CustomFieldsValues::class;
  1969.             $ticketCustomFieldValuesEntityReference = UVDeskCommunityPackages\CustomFields\Entity\TicketCustomFieldsValues::class;
  1970.         } else if ($this->userService->isFileExists('apps/uvdesk/form-component')) {
  1971.             $customFieldsService = $this->container->get('uvdesk_package_form_component.service');
  1972.             $customFieldsEntityReference = UVDeskCommunityPackages\FormComponent\Entity\CustomFields::class;
  1973.             $customFieldValuesEntityReference = UVDeskCommunityPackages\FormComponent\Entity\CustomFieldsValues::class;
  1974.             $ticketCustomFieldValuesEntityReference = UVDeskCommunityPackages\FormComponent\Entity\TicketCustomFieldsValues::class;
  1975.         } else {
  1976.             return;
  1977.         }
  1979.         $ticket = $thread->getTicket();
  1980.         $customFieldsCollection = $this->entityManager->getRepository($customFieldsEntityReference)->findAll();
  1981.         $customFieldValuesEntityRepository = $this->entityManager->getRepository($customFieldValuesEntityReference);
  1983.         foreach ($customFieldsCollection as $customFields) {
  1984.             if (in_array($customFields->getFieldType(), ['select', 'checkbox', 'radio']) && !count($customFields->getCustomFieldValues())) {
  1985.                 continue;
  1986.             }
  1987.             
  1988.             if (
  1989.                 !empty($submittedCustomFields) 
  1990.                 && $customFields->getFieldType() != 'file' 
  1991.                 && isset($submittedCustomFields[$customFields->getId()])
  1992.             ) {
  1993.                 // Check if custom field dependency criterias are fullfilled
  1994.                 if (
  1995.                     count($customFields->getCustomFieldsDependency()) 
  1996.                     && !in_array($ticket->getType(), $customFields->getCustomFieldsDependency()->toArray())
  1997.                 ) {
  1998.                     continue;
  1999.                 }
  2001.                 // Save ticket custom fields
  2002.                 $ticketCustomField = new $ticketCustomFieldValuesEntityReference();
  2003.                 $ticketCustomField
  2004.                     ->setTicket($ticket)
  2005.                     ->setTicketCustomFieldsValues($customFields)
  2006.                     ->setValue(json_encode($submittedCustomFields[$customFields->getId()]))
  2007.                 ;
  2009.                 if (in_array($customFields->getFieldType(), ['select', 'checkbox', 'radio'])) {
  2010.                     // Add custom field values mapping too
  2011.                     if (is_array($submittedCustomFields[$customFields->getId()])) {
  2012.                         foreach ($submittedCustomFields[$customFields->getId()] as $value) {
  2013.                             $ticketCustomFieldValues = $customFieldValuesEntityRepository->findOneBy([
  2014.                                 'id'           => $value, 
  2015.                                 'customFields' => $customFields, 
  2016.                             ]);
  2018.                             if (!empty($ticketCustomFieldValues)) {
  2019.                                 $ticketCustomField
  2020.                                     ->setTicketCustomFieldValueValues($ticketCustomFieldValues)
  2021.                                 ;
  2022.                             }
  2023.                         }
  2024.                     } else {
  2025.                         $ticketCustomFieldValues = $customFieldValuesEntityRepository->findOneBy([
  2026.                             'id'           => $submittedCustomFields[$customFields->getId()], 
  2027.                             'customFields' => $customFields, 
  2028.                         ]);
  2030.                         if (!empty($ticketCustomFieldValues)) {
  2031.                             $ticketCustomField
  2032.                                 ->setTicketCustomFieldValueValues($ticketCustomFieldValues)
  2033.                             ;
  2034.                         }
  2035.                     }
  2036.                 }
  2038.                 $this->entityManager->persist($ticketCustomField);
  2039.                 $this->entityManager->flush();
  2040.             } else if (
  2041.                 !empty($uploadedFilesCollection) 
  2042.                 && isset($uploadedFilesCollection[$customFields->getId()]) 
  2043.             ) {
  2044.                 // Upload files
  2045.                 $path = '/custom-fields/ticket/' . $ticket->getId() . '/';
  2046.                 $fileNames = $this->fileUploadService->uploadFile($uploadedFilesCollection[$customFields->getid()], $path, true);
  2048.                 if (!empty($fileNames)) {
  2049.                     // Save files entry to attachment table
  2050.                     try {
  2051.                         $newFilesNames = $customFieldsService->addFilesEntryToAttachmentTable([$fileNames], $thread);
  2053.                         foreach ($newFilesNames as $value) {
  2054.                             // Save ticket custom fields
  2055.                             $ticketCustomField = new $ticketCustomFieldValuesEntityReference();
  2056.                             $ticketCustomField
  2057.                                 ->setTicket($ticket)
  2058.                                 ->setTicketCustomFieldsValues($customFields)
  2059.                                 ->setValue(json_encode([
  2060.                                     'name' => $value['name'], 
  2061.                                     'path' => $value['path'], 
  2062.                                     'id'   => $value['id'], 
  2063.                                 ]))
  2064.                             ;
  2066.                             $this->entityManager->persist($ticketCustomField);
  2067.                             $this->entityManager->flush();
  2068.                         }
  2069.                     } catch (\Exception $e) {
  2070.                         // @TODO: Log execption message
  2071.                     }
  2072.                 }
  2073.             }
  2074.         }
  2075.     }
  2077.     // return attachemnt for initial thread
  2078.     public function getInitialThread($ticketId)
  2079.     {
  2080.         $firstThread = null;
  2081.         $intialThread = $this->entityManager->getRepository(Thread::class)->findBy(['ticket'=>$ticketId]);
  2082.         
  2083.         foreach ($intialThread as $key => $value) {
  2084.             if ($value->getThreadType() == "create"){
  2085.                 $firstThread = $value;
  2086.             }
  2087.         }
  2089.         return $firstThread;
  2090.     }
  2092.     public function getTicketConditions()
  2093.     {
  2094.         $conditions = array(
  2095.             'ticket' => [
  2096.                 ('mail') => array(
  2097.                     [
  2098.                         'lable' => ('from_mail'),
  2099.                         'value' => 'from_mail',
  2100.                         'match' => 'email'
  2101.                     ],
  2102.                     [
  2103.                         'lable' => ('to_mail'),
  2104.                         'value' => 'to_mail',
  2105.                         'match' => 'email'
  2106.                     ],
  2107.                 ),
  2108.                 ('API') => array(
  2109.                     [
  2110.                         'lable' => ('Domain'),
  2111.                         'value' => 'domain',
  2112.                         'match' => 'api'
  2113.                     ],
  2114.                     [
  2115.                         'lable' => ('Locale'),
  2116.                         'value' => 'locale',
  2117.                         'match' => 'api'
  2118.                     ],
  2119.                 ),
  2120.                 ('ticket') => array(
  2121.                     [
  2122.                         'lable' => ('subject'),
  2123.                         'value' => 'subject',
  2124.                         'match' => 'string'
  2125.                     ],
  2126.                     [
  2127.                         'lable' => ('description'),
  2128.                         'value' => 'description',
  2129.                         'match' => 'string'
  2130.                     ],
  2131.                     [
  2132.                         'lable' => ('subject_or_description'),
  2133.                         'value' => 'subject_or_description',
  2134.                         'match' => 'string'
  2135.                     ],
  2136.                     [
  2137.                         'lable' => ('priority'),
  2138.                         'value' => 'priority',
  2139.                         'match' => 'select'
  2140.                     ],
  2141.                     [
  2142.                         'lable' => ('type'),
  2143.                         'value' => 'type',
  2144.                         'match' => 'select'
  2145.                     ],
  2146.                     [
  2147.                         'lable' => ('status'),
  2148.                         'value' => 'status',
  2149.                         'match' => 'select'
  2150.                     ],
  2151.                     [
  2152.                         'lable' => ('source'),
  2153.                         'value' => 'source',
  2154.                         'match' => 'select'
  2155.                     ],
  2156.                     [
  2157.                         'lable' => ('created'),
  2158.                         'value' => 'created',
  2159.                         'match' => 'date'
  2160.                     ],
  2161.                     [
  2162.                         'lable' => ('agent'),
  2163.                         'value' => 'agent',
  2164.                         'match' => 'select'
  2165.                     ],
  2166.                     [
  2167.                         'lable' => ('group'),
  2168.                         'value' => 'group',
  2169.                         'match' => 'select'
  2170.                     ],
  2171.                     [
  2172.                         'lable' => ('team'),
  2173.                         'value' => 'team',
  2174.                         'match' => 'select'
  2175.                     ],
  2176.                 ),
  2177.                 ('customer') => array(
  2178.                     [
  2179.                         'lable' => ('customer_name'),
  2180.                         'value' => 'customer_name',
  2181.                         'match' => 'string'
  2182.                     ],
  2183.                     [
  2184.                         'lable' => ('customer_email'),
  2185.                         'value' => 'customer_email',
  2186.                         'match' => 'email'
  2187.                     ],
  2188.                 ),
  2189.             ],
  2190.             'task' => [
  2191.                 ('task') => array(
  2192.                     [
  2193.                         'lable' => ('subject'),
  2194.                         'value' => 'subject',
  2195.                         'match' => 'string'
  2196.                     ],
  2197.                     [
  2198.                         'lable' => ('description'),
  2199.                         'value' => 'description',
  2200.                         'match' => 'string'
  2201.                     ],
  2202.                     [
  2203.                         'lable' => ('subject_or_description'),
  2204.                         'value' => 'subject_or_description',
  2205.                         'match' => 'string'
  2206.                     ],
  2207.                     [
  2208.                         'lable' => ('priority'),
  2209.                         'value' => 'priority',
  2210.                         'match' => 'select'
  2211.                     ],
  2212.                     [
  2213.                         'lable' => ('stage'),
  2214.                         'value' => 'stage',
  2215.                         'match' => 'select'
  2216.                     ],
  2217.                     [
  2218.                         'lable' => ('created'),
  2219.                         'value' => 'created',
  2220.                         'match' => 'date'
  2221.                     ],
  2222.                     [
  2223.                         'lable' => ('agent_name'),
  2224.                         'value' => 'agent_name',
  2225.                         'match' => 'select'
  2226.                     ],
  2227.                     [
  2228.                         'lable' => ('agent_email'),
  2229.                         'value' => 'agent_email',
  2230.                         'match' => 'select'
  2231.                     ],
  2232.                 ),
  2233.             ]
  2234.         );
  2237.         return $conditions;
  2238.     }
  2240.     public function getAgentMatchConditions()
  2241.     {
  2242.         return [
  2243.             'email' => array(
  2244.                 [
  2245.                     'lable' => ('is'),
  2246.                     'value' => 'is'
  2247.                 ],
  2248.                 [
  2249.                     'lable' => ('isNot'),
  2250.                     'value' => 'isNot'
  2251.                 ],
  2252.                 [
  2253.                     'lable' => ('contains'),
  2254.                     'value' => 'contains'
  2255.                 ],
  2256.                 [
  2257.                     'lable' => ('notContains'),
  2258.                     'value' => 'notContains'
  2259.                 ],
  2260.             ),
  2261.             'api' => array(
  2262.                 [
  2263.                     'lable' => ('is'),
  2264.                     'value' => 'is'
  2265.                 ],
  2266.                 [
  2267.                     'lable' => ('contains'),
  2268.                     'value' => 'contains'
  2269.                 ],
  2270.             ),
  2271.             'string' => array(
  2272.                 [
  2273.                     'lable' => ('is'),
  2274.                     'value' => 'is'
  2275.                 ],
  2276.                 [
  2277.                     'lable' => ('isNot'),
  2278.                     'value' => 'isNot'
  2279.                 ],
  2280.                 [
  2281.                     'lable' => ('contains'),
  2282.                     'value' => 'contains'
  2283.                 ],
  2284.                 [
  2285.                     'lable' => ('notContains'),
  2286.                     'value' => 'notContains'
  2287.                 ],
  2288.                 [
  2289.                     'lable' => ('startWith'),
  2290.                     'value' => 'startWith'
  2291.                 ],
  2292.                 [
  2293.                     'lable' => ('endWith'),
  2294.                     'value' => 'endWith'
  2295.                 ],
  2296.             ),
  2297.             'select' => array(
  2298.                 [
  2299.                     'lable' => ('is'),
  2300.                     'value' => 'is'
  2301.                 ],
  2302.             ),
  2303.             'date' => array(
  2304.                 [
  2305.                     'lable' => ('before'),
  2306.                     'value' => 'before'
  2307.                 ],
  2308.                 [
  2309.                     'lable' => ('beforeOn'),
  2310.                     'value' => 'beforeOn'
  2311.                 ],
  2312.                 [
  2313.                     'lable' => ('after'),
  2314.                     'value' => 'after'
  2315.                 ],
  2316.                 [
  2317.                     'lable' => ('afterOn'),
  2318.                     'value' => 'afterOn'
  2319.                 ],
  2320.             ),
  2321.             'datetime' => array(
  2322.                 [
  2323.                     'lable' => ('before'),
  2324.                     'value' => 'beforeDateTime'
  2325.                 ],
  2326.                 [
  2327.                     'lable' => ('beforeOn'),
  2328.                     'value' => 'beforeDateTimeOn'
  2329.                 ],
  2330.                 [
  2331.                     'lable' => ('after'),
  2332.                     'value' => 'afterDateTime'
  2333.                 ],
  2334.                 [
  2335.                     'lable' => ('afterOn'),
  2336.                     'value' => 'afterDateTimeOn'
  2337.                 ],
  2338.             ),
  2339.             'time' => array(
  2340.                 [
  2341.                     'lable' => ('before'),
  2342.                     'value' => 'beforeTime'
  2343.                 ],
  2344.                 [
  2345.                     'lable' => ('beforeOn'),
  2346.                     'value' => 'beforeTimeOn'
  2347.                 ],
  2348.                 [
  2349.                     'lable' => ('after'),
  2350.                     'value' => 'afterTime'
  2351.                 ],
  2352.                 [
  2353.                     'lable' => ('afterOn'),
  2354.                     'value' => 'afterTimeOn'
  2355.                 ],
  2356.             ),
  2357.             'number' => array(
  2358.                 [
  2359.                     'lable' => ('is'),
  2360.                     'value' => 'is'
  2361.                 ],
  2362.                 [
  2363.                     'lable' => ('isNot'),
  2364.                     'value' => 'isNot'
  2365.                 ],
  2366.                 [
  2367.                     'lable' => ('contains'),
  2368.                     'value' => 'contains'
  2369.                 ],
  2370.                 [
  2371.                     'lable' => ('greaterThan'),
  2372.                     'value' => 'greaterThan'
  2373.                 ],
  2374.                 [
  2375.                     'lable' => ('lessThan'),
  2376.                     'value' => 'lessThan'
  2377.                 ],
  2378.             ),
  2379.         ];
  2380.     }
  2382.     public function getTicketMatchConditions()
  2383.     {
  2384.         return [
  2385.             'email' => array(
  2386.                 [
  2387.                     'lable' => ('is'),
  2388.                     'value' => 'is'
  2389.                 ],
  2390.                 [
  2391.                     'lable' => ('isNot'),
  2392.                     'value' => 'isNot'
  2393.                 ],
  2394.                 [
  2395.                     'lable' => ('contains'),
  2396.                     'value' => 'contains'
  2397.                 ],
  2398.                 [
  2399.                     'lable' => ('notContains'),
  2400.                     'value' => 'notContains'
  2401.                 ],
  2402.             ),
  2403.             'api' => array(
  2404.                 [
  2405.                     'lable' => ('is'),
  2406.                     'value' => 'is'
  2407.                 ],
  2408.                 [
  2409.                     'lable' => ('contains'),
  2410.                     'value' => 'contains'
  2411.                 ],
  2412.             ),
  2413.             'string' => array(
  2414.                 [
  2415.                     'lable' => ('is'),
  2416.                     'value' => 'is'
  2417.                 ],
  2418.                 [
  2419.                     'lable' => ('isNot'),
  2420.                     'value' => 'isNot'
  2421.                 ],
  2422.                 [
  2423.                     'lable' => ('contains'),
  2424.                     'value' => 'contains'
  2425.                 ],
  2426.                 [
  2427.                     'lable' => ('notContains'),
  2428.                     'value' => 'notContains'
  2429.                 ],
  2430.                 [
  2431.                     'lable' => ('startWith'),
  2432.                     'value' => 'startWith'
  2433.                 ],
  2434.                 [
  2435.                     'lable' => ('endWith'),
  2436.                     'value' => 'endWith'
  2437.                 ],
  2438.             ),
  2439.             'select' => array(
  2440.                 [
  2441.                     'lable' => ('is'),
  2442.                     'value' => 'is'
  2443.                 ],
  2444.                 [
  2445.                     'lable' => ('isNot'),
  2446.                     'value' => 'isNot'
  2447.                 ],
  2448.             ),
  2449.             'date' => array(
  2450.                 [
  2451.                     'lable' => ('before'),
  2452.                     'value' => 'before'
  2453.                 ],
  2454.                 [
  2455.                     'lable' => ('beforeOn'),
  2456.                     'value' => 'beforeOn'
  2457.                 ],
  2458.                 [
  2459.                     'lable' => ('after'),
  2460.                     'value' => 'after'
  2461.                 ],
  2462.                 [
  2463.                     'lable' => ('afterOn'),
  2464.                     'value' => 'afterOn'
  2465.                 ],
  2466.             ),
  2467.             'datetime' => array(
  2468.                 [
  2469.                     'lable' => ('before'),
  2470.                     'value' => 'beforeDateTime'
  2471.                 ],
  2472.                 [
  2473.                     'lable' => ('beforeOn'),
  2474.                     'value' => 'beforeDateTimeOn'
  2475.                 ],
  2476.                 [
  2477.                     'lable' => ('after'),
  2478.                     'value' => 'afterDateTime'
  2479.                 ],
  2480.                 [
  2481.                     'lable' => ('afterOn'),
  2482.                     'value' => 'afterDateTimeOn'
  2483.                 ],
  2484.             ),
  2485.             'time' => array(
  2486.                 [
  2487.                     'lable' => ('before'),
  2488.                     'value' => 'beforeTime'
  2489.                 ],
  2490.                 [
  2491.                     'lable' => ('beforeOn'),
  2492.                     'value' => 'beforeTimeOn'
  2493.                 ],
  2494.                 [
  2495.                     'lable' => ('after'),
  2496.                     'value' => 'afterTime'
  2497.                 ],
  2498.                 [
  2499.                     'lable' => ('afterOn'),
  2500.                     'value' => 'afterTimeOn'
  2501.                 ],
  2502.             ),
  2503.             'number' => array(
  2504.                 [
  2505.                     'lable' => ('is'),
  2506.                     'value' => 'is'
  2507.                 ],
  2508.                 [
  2509.                     'lable' => ('isNot'),
  2510.                     'value' => 'isNot'
  2511.                 ],
  2512.                 [
  2513.                     'lable' => ('contains'),
  2514.                     'value' => 'contains'
  2515.                 ],
  2516.                 [
  2517.                     'lable' => ('greaterThan'),
  2518.                     'value' => 'greaterThan'
  2519.                 ],
  2520.                 [
  2521.                     'lable' => ('lessThan'),
  2522.                     'value' => 'lessThan'
  2523.                 ],
  2524.             ),
  2525.         ];
  2526.     }
  2528.     public function getTargetAction() {
  2529.        return [
  2530.             '4' => ['response' => ['time' => '2', 'unit' => 'hours'], 'resolve' => ['time' => '8', 'unit' => 'hours'], 'operational' => 'calendarHours', 'isActive' => 'on'],
  2531.             '3' => ['response' => ['time' => '4', 'unit' => 'hours'], 'resolve' => ['time' => '1', 'unit' => 'days'], 'operational' => 'calendarHours', 'isActive' => 'on'],
  2532.             '2' => ['response' => ['time' => '8', 'unit' => 'hours'], 'resolve' => ['time' => '3', 'unit' => 'days'], 'operational' => 'calendarHours', 'isActive' => 'on'],
  2533.             '1' => ['response' => ['time' => '16', 'unit' => 'hours'], 'resolve' => ['time' => '5', 'unit' => 'days'], 'operational' => 'calendarHours', 'isActive' => 'on'],
  2534.        ];
  2535.     }
  2537.     public function getTicketActions($force = false)
  2538.     {
  2539.         $actionArray =  array(
  2540.             'ticket' => [
  2541.                 'priority'               => ('action.priority'),
  2542.                 'type'                   => ('action.type'),
  2543.                 'status'                 => ('action.status'),
  2544.                 'tag'                    => ('action.tag'),
  2545.                 'note'                   => ('action.note'),
  2546.                 'label'                  => ('action.label'),
  2547.                 'assign_agent'           => ('action.assign_agent'),
  2548.                 'assign_group'           => ('action.assign_group'),
  2549.                 'assign_team'            => ('action.assign_team'),
  2550.                 'mail_agent'             => ('action.mail_agent'),
  2551.                 'mail_group'             => ('action.mail_group'),
  2552.                 'mail_team'              => ('action.mail_team'),
  2553.                 'mail_customer'          => ('action.mail_customer'),
  2554.                 'mail_last_collaborator' => ('action.mail_last_collaborator'),
  2555.                 'mail_all_collaborators' => ('action.mail_all_collaborators'),
  2556.                 'delete_ticket'          => ('action.delete_ticket'),
  2557.                 'mark_spam'              => ('action.mark_spam'),
  2558.             ],
  2559.             'task' => [
  2560.                 'reply'            => ('action.reply'),
  2561.                 'mail_agent'       => ('action.mail_agent'),
  2562.                 'mail_members'     => ('action.mail_members'),
  2563.                 'mail_last_member' => ('action.mail_last_member'),
  2564.             ],
  2565.             'customer' => [
  2566.                 'mail_customer' => ('action.mail_customer'),
  2567.             ],
  2568.             'agent' => [
  2569.                 'mail_agent'    => ('action.mail_agent'),
  2570.                 'task_transfer' => ('action.task_transfer'),
  2571.                 'assign_agent'  => ('action.assign_agent'),
  2572.                 'assign_group'  => ('action.assign_group'),
  2573.                 'assign_team'   => ('action.assign_team'),
  2574.             ],
  2575.         );
  2577.         $actionRoleArray = [
  2578.             'ticket->priority'               => 'ROLE_AGENT_UPDATE_TICKET_PRIORITY',
  2579.             'ticket->type'                   => 'ROLE_AGENT_UPDATE_TICKET_TYPE',
  2580.             'ticket->status'                 => 'ROLE_AGENT_UPDATE_TICKET_STATUS',
  2581.             'ticket->tag'                    => 'ROLE_AGENT_ADD_TAG',
  2582.             'ticket->note'                   => 'ROLE_AGENT_ADD_NOTE',
  2583.             'ticket->assign_agent'           => 'ROLE_AGENT_ASSIGN_TICKET',
  2584.             'ticket->assign_group'           => 'ROLE_AGENT_ASSIGN_TICKET_GROUP',
  2585.             'ticket->assign_team'            => 'ROLE_AGENT_ASSIGN_TICKET_GROUP',
  2586.             'ticket->mail_agent'             => 'ROLE_AGENT',
  2587.             'ticket->mail_group'             => 'ROLE_AGENT_MANAGE_GROUP',
  2588.             'ticket->mail_team'              => 'ROLE_AGENT_MANAGE_SUB_GROUP',
  2589.             'ticket->mail_customer'          => 'ROLE_AGENT',
  2590.             'ticket->mail_last_collaborator' => 'ROLE_AGENT',
  2591.             'ticket->mail_all_collaborators' => 'ROLE_AGENT',
  2592.             'ticket->delete_ticket'          => 'ROLE_AGENT_DELETE_TICKET',
  2593.             'ticket->mark_spam'              => 'ROLE_AGENT_UPDATE_TICKET_STATUS',
  2594.             'ticket->label'                  => 'ROLE_ADMIN',
  2595.             'task->reply'                    => 'ROLE_AGENT',
  2596.             'task->mail_agent'               => 'ROLE_AGENT',
  2597.             'task->mail_members'             => 'ROLE_AGENT',
  2598.             'task->mail_last_member'         => 'ROLE_AGENT',
  2599.             'customer->mail_customer'        => 'ROLE_AGENT',
  2600.             'agent->mail_agent'              => 'ROLE_AGENT',
  2601.             'agent->task_transfer'           => 'ROLE_AGENT_EDIT_TASK',
  2602.             'agent->assign_agent'            => 'ROLE_AGENT_ASSIGN_TICKET',
  2603.             'agent->assign_group'            => 'ROLE_AGENT_ASSIGN_TICKET_GROUP',
  2604.             'agent->assign_team'             => 'ROLE_AGENT_ASSIGN_TICKET_GROUP',
  2605.         ];
  2607.         $resultArray = [];
  2609.         foreach ($actionRoleArray as $action => $role) {
  2610.             if ($role == 'ROLE_AGENT' || $this->container->get('user.service')->checkPermission($role) || $force) {
  2611.                 $actionPath = explode('->', $action);
  2612.                 $resultArray[$actionPath[0]][$actionPath[1]] = $actionArray[$actionPath[0]][$actionPath[1]];
  2613.             }
  2614.         }
  2616.         $repo = $this->container->get('doctrine.orm.entity_manager')->getRepository('WebkulAppBundle:ECommerceChannel');
  2618.         $ecomArray= [];
  2619.         $ecomChannels = $repo->getActiveChannelsByCompany($this->container->get('user.service')->getCurrentCompany());
  2621.         foreach ($ecomChannels as $channel) {
  2622.             $ecomArray['add_order_to_' . $channel['id']] = ('Add order to: ') . $channel['title'];
  2623.         }
  2625.         $resultArray['ticket'] = array_merge($resultArray['ticket'], $ecomArray);
  2627.         return $resultArray;
  2628.     }
  2629. }