vendor/uvdesk/mailbox-component/Services/MailboxService.php line 38

Open in your IDE?
  1. <?php
  3. namespace Webkul\UVDesk\MailboxBundle\Services;
  5. use PhpMimeMailParser\Parser as EmailParser;
  6. use Symfony\Component\Yaml\Yaml;
  7. use Doctrine\ORM\EntityManagerInterface;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\HttpFoundation\Response;
  10. use Symfony\Component\HttpFoundation\RequestStack;
  11. use Webkul\UVDesk\CoreFrameworkBundle\Entity\User;
  12. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Ticket;
  13. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Thread;
  14. use Webkul\UVDesk\CoreFrameworkBundle\Entity\Website;
  15. use Webkul\UVDesk\MailboxBundle\Utils\Mailbox\Mailbox;
  16. use Webkul\UVDesk\CoreFrameworkBundle\Utils\HTMLFilter;
  17. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportRole;
  18. use Webkul\UVDesk\CoreFrameworkBundle\Utils\TokenGenerator;
  19. use Webkul\UVDesk\MailboxBundle\Utils\MailboxConfiguration;
  20. use Symfony\Component\DependencyInjection\ContainerInterface;
  21. use Webkul\UVDesk\CoreFrameworkBundle\Workflow\Events as CoreWorkflowEvents;
  22. use Webkul\UVDesk\MailboxBundle\Utils\IMAP;
  23. use Webkul\UVDesk\MailboxBundle\Utils\SMTP;
  24. use Webkul\UVDesk\MailboxBundle\Utils\Imap\Configuration as ImapConfiguration;
  25. use Webkul\UVDesk\CoreFrameworkBundle\SwiftMailer\SwiftMailer as SwiftMailerService;
  26. use Webkul\UVDesk\MailboxBundle\Workflow\Events as MaibloxWorkflowEvents;
  28. class MailboxService
  29. {
  30.     const PATH_TO_CONFIG = '/config/packages/uvdesk_mailbox.yaml';
  32.     private $parser;
  33.     private $container;
  34.     private $requestStack;
  35.     private $entityManager;
  36.     private $mailboxCollection = [];
  38.     public function __construct(ContainerInterface $container, RequestStack $requestStack, EntityManagerInterface $entityManager, SwiftMailerService $swiftMailer)
  39.     {
  40.         $this->container = $container;
  41.         $this->requestStack = $requestStack;
  42.         $this->entityManager = $entityManager;
  43.         $this->swiftMailer = $swiftMailer;
  44.     }
  46.     public function getPathToConfigurationFile()
  47.     {
  48.         return $this->container->get('kernel')->getProjectDir() . self::PATH_TO_CONFIG;
  49.     }
  51.     public function createConfiguration($params)
  52.     {
  53.         $configuration = new MailboxConfigurations\MailboxConfiguration($params);
  55.         return $configuration ?? null;
  56.     }
  58.     public function parseMailboxConfigurations(bool $ignoreInvalidAttributes = false) 
  59.     {
  60.         $path = $this->getPathToConfigurationFile();
  62.         if (! file_exists($path)) {
  63.             throw new \Exception("File '$path' not found.");
  64.         }
  66.         // Read configurations from package config.
  67.         $mailboxConfiguration = new MailboxConfiguration();
  69.         foreach (Yaml::parse(file_get_contents($path))['uvdesk_mailbox']['mailboxes'] ?? [] as $id => $params) {
  70.             // Swiftmailer Configuration
  71.             
  72.             $swiftMailerConfigurations = $this->swiftMailer->parseSwiftMailerConfigurations() ?? null;
  74.             if (isset($params['smtp_swift_mailer_server'])) {
  75.                 foreach ($swiftMailerConfigurations as $configuration) {
  76.                     if ($configuration->getId() == $params['smtp_swift_mailer_server']['mailer_id']) {
  77.                         $swiftMailerConfiguration = $configuration;
  78.                         break;
  79.                     }
  80.                 }
  81.             }
  83.             // IMAP Configuration
  84.             $imapConfiguration = null;
  86.             if (! empty($params['imap_server'])) {
  87.                 $imapConfiguration = IMAP\Configuration::guessTransportDefinition($params['imap_server']);
  88.     
  89.                 if ($imapConfiguration instanceof IMAP\Transport\AppTransportConfigurationInterface) {
  90.                     $imapConfiguration
  91.                         ->setClient($params['imap_server']['client'])
  92.                         ->setUsername($params['imap_server']['username'])
  93.                     ;
  94.                 } else if ($imapConfiguration instanceof IMAP\Transport\SimpleTransportConfigurationInterface) {
  95.                     $imapConfiguration
  96.                         ->setUsername($params['imap_server']['username'])
  97.                     ;
  98.                 } else {
  99.                     $imapConfiguration
  100.                         ->setUsername($params['imap_server']['username'])
  101.                         ->setPassword($params['imap_server']['password'])
  102.                     ;
  103.                 }
  104.             }
  106.             // SMTP Configuration
  107.             $smtpConfiguration = null; 
  109.             if (
  110.                 ! empty($params['smtp_server']) 
  111.                 && !isset($params['smtp_server']['mailer_id'])
  112.             ) {
  113.                 $smtpConfiguration = SMTP\Configuration::guessTransportDefinition($params['smtp_server']);
  114.     
  115.                 if ($smtpConfiguration instanceof SMTP\Transport\AppTransportConfigurationInterface) {
  116.                     $smtpConfiguration
  117.                         ->setClient($params['smtp_server']['client'])
  118.                         ->setUsername($params['smtp_server']['username'])
  119.                     ;
  120.                 } else if ($smtpConfiguration instanceof SMTP\Transport\ResolvedTransportConfigurationInterface) {
  121.                     $smtpConfiguration
  122.                         ->setUsername($params['smtp_server']['username'])
  123.                         ->setPassword($params['smtp_server']['password'])
  124.                     ;
  125.                 }  else {
  126.                     $smtpConfiguration
  127.                         ->setHost($params['smtp_server']['host'])
  128.                         ->setPort($params['smtp_server']['port'])
  129.                         ->setUsername($params['smtp_server']['username'])
  130.                         ->setPassword($params['smtp_server']['password'])
  131.                     ;
  133.                     if (! empty($params['smtp_server']['sender_address'])) {
  134.                         $smtpConfiguration
  135.                             ->setSenderAddress($params['smtp_server']['sender_address'])
  136.                         ;
  137.                     }
  138.                 }
  139.             }
  141.             // Mailbox Configuration
  142.             ($mailbox = new Mailbox($id))
  143.                 ->setName($params['name'])
  144.                 ->setIsEnabled($params['enabled']);
  146.             if (! empty($imapConfiguration)) {
  147.                 $mailbox
  148.                     ->setImapConfiguration($imapConfiguration)
  149.                 ;
  150.             }
  152.             if (! empty($smtpConfiguration)) {
  153.                 $mailbox
  154.                     ->setSmtpConfiguration($smtpConfiguration)
  155.                 ;
  156.             }
  157.             
  158.             if (! empty($swiftMailerConfiguration)) {
  159.                 $mailbox->setSwiftMailerConfiguration($swiftMailerConfiguration);
  160.             } else if (! empty($params['smtp_server']['mailer_id']) && true === $ignoreInvalidAttributes) {
  161.                 $mailbox->setSwiftMailerConfiguration($swiftmailerService->createConfiguration('smtp', $params['smtp_server']['mailer_id']));
  162.             }
  164.             $mailboxConfiguration->addMailbox($mailbox);
  165.         }
  167.         return $mailboxConfiguration;
  168.     }
  170.     private function getParser()
  171.     {
  172.         if (empty($this->parser)) {
  173.             $this->parser = new EmailParser();
  174.         }
  176.         return $this->parser;
  177.     }
  179.     private function getLoadedEmailContentParser($emailContents = null, $cacheContent = true): ?EmailParser
  180.     {
  181.         if (empty($emailContents)) {
  182.             return $this->emailParser ?? null;
  183.         }
  185.         $emailParser = new EmailParser();
  186.         $emailParser
  187.             ->setText($emailContents)
  188.         ;
  190.         if ($cacheContent) {
  191.             $this->emailParser = $emailParser;
  192.         }
  194.         return $emailParser;
  195.     }
  197.     private function getRegisteredMailboxes()
  198.     {
  199.         if (empty($this->mailboxCollection)) {
  200.             $this->mailboxCollection = array_map(function ($mailboxId) {
  201.                 return $this->container->getParameter("uvdesk.mailboxes.$mailboxId");
  202.             }, $this->container->getParameter('uvdesk.mailboxes'));
  203.         }
  205.         return $this->mailboxCollection;
  206.     }
  208.     public function getRegisteredMailboxesById()
  209.     {
  210.         // Fetch existing content in file
  211.         $filePath = $this->getPathToConfigurationFile();
  212.         $file_content = file_get_contents($filePath);
  214.         // Convert yaml file content into array and merge existing mailbox and new mailbox
  215.         $file_content_array = Yaml::parse($file_content, 6);
  217.         if ($file_content_array['uvdesk_mailbox']['mailboxes']) {
  218.             foreach ($file_content_array['uvdesk_mailbox']['mailboxes'] as $key => $value) {
  219.                 $value['mailbox_id'] = $key;
  220.                 $mailboxCollection[] = $value;
  221.             }
  222.         }
  223.         
  224.         return $mailboxCollection ?? [];
  225.     }
  227.     public function getEmailAddresses($collection)
  228.     {
  229.         $formattedCollection = array_map(function ($emailAddress) {
  230.             if (filter_var($emailAddress['address'], FILTER_VALIDATE_EMAIL)) {
  231.                 return $emailAddress['address'];
  232.             }
  234.             return null;
  235.         }, (array) $collection);
  237.         $filteredCollection = array_values(array_filter($formattedCollection));
  239.         return count($filteredCollection) == 1 ? $filteredCollection[0] : $filteredCollection;
  240.     }
  242.     public function parseAddress($type)
  243.     {
  244.         $addresses = mailparse_rfc822_parse_addresses($this->getParser()->getHeader($type));
  246.         return $addresses ?: false;
  247.     }
  249.     public function getEmailAddress($addresses)
  250.     {
  251.         foreach ((array) $addresses as $address) {
  252.             if (filter_var($address['address'], FILTER_VALIDATE_EMAIL)) {
  253.                 return $address['address'];
  254.             }
  255.         }
  257.         return null;
  258.     }
  260.     public function getMailboxByEmail($email)
  261.     {
  262.         foreach ($this->getRegisteredMailboxes() as $registeredMailbox) {
  263.             if (strtolower($email) === strtolower($registeredMailbox['imap_server']['username'])) {
  264.                 return $registeredMailbox;
  265.             }
  266.         }
  268.         throw new \Exception("No mailbox found for email '$email'");
  269.     }
  270.     
  271.     public function getMailboxByToEmail($email)
  272.     {
  273.         foreach ($this->getRegisteredMailboxes() as $registeredMailbox) {
  274.             if (strtolower($email) === strtolower($registeredMailbox['imap_server']['username'])) {
  275.                 return true;
  276.             }
  277.         }
  279.         return false;
  280.     }
  282.     private function searchTicketSubjectReference($senderEmail, $messageSubject) {
  283.         
  284.         // Search Criteria: Find ticket based on subject
  285.         if (
  286.             ! empty($senderEmail)
  287.             && ! empty($messageSubject)
  288.         ) {
  289.             $threadRepository = $this->entityManager->getRepository(Thread::class);
  290.             $ticket = $threadRepository->findTicketBySubject($senderEmail, $messageSubject);
  292.             if ($ticket  != null) {
  293.                 return $ticket;
  294.             }
  295.         }
  297.         return null;
  298.     }
  300.     private function searchExistingTickets(array $criterias = [])
  301.     {
  302.         if (empty($criterias)) {
  303.             return null;
  304.         }
  306.         $ticketRepository = $this->entityManager->getRepository(Ticket::class);
  307.         $threadRepository = $this->entityManager->getRepository(Thread::class);
  309.         foreach ($criterias as $criteria => $criteriaValue) {
  310.             if (empty($criteriaValue)) {
  311.                 continue;
  312.             }
  314.             switch ($criteria) {
  315.                 case 'messageId':
  316.                     // Search Criteria 1: Find ticket by unique message id
  317.                     $ticket = $ticketRepository->findOneByReferenceIds($criteriaValue);
  319.                     if (! empty($ticket)) {
  320.                         return $ticket;
  321.                     } else {
  322.                         $thread = $threadRepository->findOneByMessageId($criteriaValue);
  323.         
  324.                         if (! empty($thread)) {
  325.                             return $thread->getTicket();
  326.                         }
  327.                     }
  328.                     
  329.                     break;
  330.                 case 'outlookConversationId':
  331.                     // Search Criteria 1: Find ticket by unique message id
  332.                     $ticket = $ticketRepository->findOneByOutlookConversationId($criteriaValue);
  334.                     if (! empty($ticket)) {
  335.                         return $ticket;
  336.                     }
  337.                     
  338.                     break;
  339.                 case 'inReplyTo':
  340.                     // Search Criteria 2: Find ticket based on in-reply-to reference id
  341.                     $ticket = $this->entityManager->getRepository(Thread::class)->findThreadByRefrenceId($criteriaValue);
  343.                     if (! empty($ticket)) {
  344.                         return $ticket;
  345.                     } else {
  346.                         $thread = $threadRepository->findOneByMessageId($criteriaValue);
  347.         
  348.                         if (! empty($thread)) {
  349.                             return $thread->getTicket();
  350.                         }
  351.                     }
  352.                     break;
  353.                 case 'referenceIds':
  354.                     // Search Criteria 3: Find ticket based on reference id
  355.                     // Break references into ind. message id collection, and iteratively 
  356.                     // search for existing threads for these message ids.
  357.                     $referenceIds = explode(' ', $criteriaValue);
  359.                     foreach ($referenceIds as $messageId) {
  360.                         $thread = $threadRepository->findOneByMessageId($messageId);
  362.                         if (! empty($thread)) {
  363.                             return $thread->getTicket();
  364.                         }
  365.                     }
  366.                     break;
  367.                 default:
  368.                     break;
  369.             }
  370.         }
  372.         return null;
  373.     }
  374.     
  375.     public function processMail($rawEmail)
  376.     {
  377.         $mailData = [];
  378.         $parser = $this->getParser();
  379.         $parser->setText($rawEmail);
  381.         $from = $this->parseAddress('from') ?: $this->parseAddress('sender');
  382.         $addresses = [
  383.             'from'         => $this->getEmailAddress($from),
  384.             'to'           => empty($this->parseAddress('X-Forwarded-To')) ? $this->parseAddress('to') : $this->parseAddress('X-Forwarded-To'),
  385.             'cc'           => $this->parseAddress('cc'),
  386.             'delivered-to' => $this->parseAddress('delivered-to'),
  387.         ];
  389.         if (empty($addresses['from'])) {
  390.             return [
  391.                 'message' => "No 'from' email address was found while processing contents of email.", 
  392.                 'content' => [], 
  393.             ];
  394.         } else {
  395.             if (! empty($addresses['delivered-to'])) {
  396.                 $addresses['to'] = array_map(function($address) {
  397.                     return $address['address'];
  398.                 }, $addresses['delivered-to']);
  399.             } else if (! empty($addresses['to'])) {
  400.                 $addresses['to'] = array_map(function($address) {
  401.                     return $address['address'];
  402.                 }, $addresses['to']);
  403.             } else if (! empty($addresses['cc'])) {
  404.                 $addresses['to'] = array_map(function($address) {
  405.                     return $address['address'];
  406.                 }, $addresses['cc']);
  407.             }
  408.             
  409.             // Skip email processing if no to-emails are specified
  410.             if (empty($addresses['to'])) {
  411.                 return [
  412.                     'message' => "No 'to' email addresses were found in the email.", 
  413.                     'content' => [
  414.                         'from' => ! empty($addresses['from']) ? $addresses['from'] : null, 
  415.                     ], 
  416.                 ];
  417.             }
  419.             // Skip email processing if email is an auto-forwarded message to prevent infinite loop.
  420.             if ($parser->getHeader('precedence') || $parser->getHeader('x-autoreply') || $parser->getHeader('x-autorespond') || 'auto-replied' == $parser->getHeader('auto-submitted')) {
  421.                 return [
  422.                     'message' => "Received an auto-forwarded email which can lead to possible infinite loop of email exchanges. Skipping email from further processing.", 
  423.                     'content' => [
  424.                         'from' => ! empty($addresses['from']) ? $addresses['from'] : null, 
  425.                     ], 
  426.                 ];
  427.             }
  429.             // Check for self-referencing. Skip email processing if a mailbox is configured by the sender's address.
  430.             try {
  431.                 $this->getMailboxByEmail($addresses['from']);
  433.                 return [
  434.                     'message' => "Received a self-referencing email where the sender email address matches one of the configured mailbox address. Skipping email from further processing.", 
  435.                     'content' => [
  436.                         'from' => !empty($addresses['from']) ? $addresses['from'] : null, 
  437.                     ], 
  438.                 ];
  439.             } catch (\Exception $e) {
  440.                 // An exception being thrown means no mailboxes were found from the recipient's address. Continue processing.
  441.             }
  442.         }
  444.         $mailData['replyTo'] = '';
  445.         
  446.         foreach ($addresses['to'] as $mailboxEmail){
  447.             if ($this->getMailboxByToEmail(strtolower($mailboxEmail))) {
  448.                 $mailData['replyTo'] = $mailboxEmail;
  449.             }
  450.         }
  452.         // Process Mail - References
  453.         $addresses['to'][0] = isset($mailData['replyTo']) ? strtolower($mailData['replyTo']) : strtolower($addresses['to'][0]);
  454.         $mailData['replyTo'] = $addresses['to'];
  455.         $mailData['messageId'] = $parser->getHeader('message-id') ?: null;
  456.         $mailData['inReplyTo'] = htmlspecialchars_decode($parser->getHeader('in-reply-to'));
  457.         $mailData['referenceIds'] = htmlspecialchars_decode($parser->getHeader('references'));
  458.         $mailData['cc'] = array_filter(explode(',', $parser->getHeader('cc'))) ?: [];
  459.         $mailData['bcc'] = array_filter(explode(',', $parser->getHeader('bcc'))) ?: [];
  461.         // Process Mail - User Details
  462.         $mailData['source'] = 'email';
  463.         $mailData['createdBy'] = 'customer';
  464.         $mailData['role'] = 'ROLE_CUSTOMER';
  465.         $mailData['from'] = $addresses['from'];
  466.         $mailData['name'] = trim(current(explode('@', $from[0]['display'])));
  468.         // Process Mail - Content
  469.         try {
  470.             $htmlFilter = new HTMLFilter();
  471.             $mailData['subject'] = $parser->getHeader('subject');
  472.             $mailData['message'] = autolink($htmlFilter->addClassEmailReplyQuote($parser->getMessageBody('htmlEmbedded')));
  473.             $mailData['attachments'] = $parser->getAttachments();
  474.         } catch(\Exception $e) {
  475.             return [
  476.                 'error'   => true,
  477.                 'message' => $e->getMessage(),
  478.             ];
  479.         }
  480.         
  481.         if (! $mailData['message']) {
  482.             $mailData['message'] = autolink($htmlFilter->addClassEmailReplyQuote($parser->getMessageBody('text')));
  483.         }
  485.         $website = $this->entityManager->getRepository(Website::class)->findOneByCode('knowledgebase');
  486.         
  487.         if (! empty($mailData['from']) && $this->container->get('ticket.service')->isEmailBlocked($mailData['from'], $website)) {
  488.             return [
  489.                 'message' => "Received email where the sender email address is present in the block list. Skipping this email from further processing.", 
  490.                 'content' => [
  491.                     'from' => !empty($mailData['from']) ? $mailData['from'] : null, 
  492.                 ], 
  493.             ];
  494.         }
  496.         // Search for any existing tickets
  497.         $ticket = $this->searchExistingTickets([
  498.             'messageId'    => $mailData['messageId'],
  499.             'inReplyTo'    => $mailData['inReplyTo'],
  500.             'referenceIds' => $mailData['referenceIds'],
  501.             'from'         => $mailData['from'],
  502.             'subject'      => $mailData['subject'],
  503.         ]);
  505.         if (empty($ticket)) {
  506.             $mailData['threadType'] = 'create';
  507.             $mailData['referenceIds'] = $mailData['messageId'];
  509.             // @Todo For same subject with same customer check
  510.             // $ticketSubjectReferenceExist = $this->searchTicketSubjectReference($mailData['from'], $mailData['subject']);
  512.             // if (!empty($ticketSubjectReferenceExist)) {
  513.             //     return;
  514.             // }
  516.             $thread = $this->container->get('ticket.service')->createTicket($mailData);
  518.             // Trigger ticket created event
  519.             $event = new CoreWorkflowEvents\Ticket\Create();
  520.             $event
  521.                 ->setTicket($thread->getTicket())
  522.             ;
  524.             $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  525.         } else if (false === $ticket->getIsTrashed() && strtolower($ticket->getStatus()->getCode()) != 'spam' && !empty($mailData['inReplyTo'])) {
  526.             $mailData['threadType'] = 'reply';
  527.             $thread = $this->entityManager->getRepository(Thread::class)->findOneByMessageId($mailData['messageId']);
  528.             $ticketRef = $this->entityManager->getRepository(Ticket::class)->findById($ticket->getId());
  529.             $referenceIds = explode(' ', $ticketRef[0]->getReferenceIds());
  531.             if (!empty($thread)) {
  532.                 // Thread with the same message id exists skip process.
  533.                 return [
  534.                     'message' => "The contents of this email has already been processed.", 
  535.                     'content' => [
  536.                         'from'   => ! empty($mailData['from']) ? $mailData['from'] : null,
  537.                         'thread' => $thread->getId(),
  538.                         'ticket' => $ticket->getId(),
  539.                     ], 
  540.                 ];
  541.             }
  543.             if (in_array($mailData['messageId'], $referenceIds)) {
  544.                 // Thread with the same message id exists skip process.
  545.                 return [
  546.                     'message' => "The contents of this email has already been processed.", 
  547.                     'content' => [
  548.                         'from' => !empty($mailData['from']) ? $mailData['from'] : null, 
  549.                     ], 
  550.                 ];
  551.             }
  553.             if (
  554.                 $ticket->getCustomer() 
  555.                 && $ticket->getCustomer()->getEmail() == $mailData['from']
  556.             ) {
  557.                 // Reply from customer
  558.                 $user = $ticket->getCustomer();
  560.                 $mailData['user'] = $user;
  561.                 $userDetails = $user->getCustomerInstance()->getPartialDetails();
  562.             } else if ($this->entityManager->getRepository(Ticket::class)->isTicketCollaborator($ticket, $mailData['from'])) {
  563.                 // Reply from collaborator
  564.                 $user = $this->entityManager->getRepository(User::class)->findOneByEmail($mailData['from']);
  566.                 $mailData['user'] = $user;
  567.                 $mailData['createdBy'] = 'collaborator';
  568.                 $userDetails = $user->getCustomerInstance()->getPartialDetails();
  569.             } else {
  570.                 $user = $this->entityManager->getRepository(User::class)->findOneByEmail($mailData['from']);
  571.                 
  572.                 if (
  573.                     ! empty($user) 
  574.                     && null != $user->getAgentInstance()
  575.                 ) {
  576.                     $mailData['user'] = $user;
  577.                     $mailData['createdBy'] = 'agent';
  578.                     $userDetails = $user->getAgentInstance()->getPartialDetails();
  579.                 } else {
  580.                     // Add user as a ticket collaborator
  581.                     if (empty($user)) {
  582.                         // Create a new user instance with customer support role
  583.                         $role = $this->entityManager->getRepository(SupportRole::class)->findOneByCode('ROLE_CUSTOMER');
  585.                         $user = $this->container->get('user.service')->createUserInstance($mailData['from'], $mailData['name'], $role, [
  586.                             'source' => 'email',
  587.                             'active' => true
  588.                         ]);
  589.                     }
  591.                     $mailData['user'] = $user;
  592.                     $userDetails = $user->getCustomerInstance()->getPartialDetails();
  594.                     if (false == $this->entityManager->getRepository(Ticket::class)->isTicketCollaborator($ticket, $mailData['from'])) {
  595.                         $ticket->addCollaborator($user);
  597.                         $this->entityManager->persist($ticket);
  598.                         $this->entityManager->flush();
  600.                         $ticket->lastCollaborator = $user;
  601.                                
  602.                         $event = new CoreWorkflowEvents\Ticket\Collaborator();
  603.                         $event
  604.                             ->setTicket($ticket)
  605.                         ;
  607.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  608.                     }
  609.                 }
  610.             }
  612.             $mailData['fullname'] = $userDetails['name'];
  613.             
  614.             $thread = $this->container->get('ticket.service')->createThread($ticket, $mailData);
  615.             
  616.             if ($thread->getThreadType() == 'reply') {
  617.                 if ($thread->getCreatedBy() == 'customer') {
  618.                     $event = new CoreWorkflowEvents\Ticket\CustomerReply();
  619.                     $event
  620.                         ->setTicket($ticket)
  621.                     ;
  622.                 }  else if ($thread->getCreatedBy() == 'collaborator') {
  623.                     $event = new CoreWorkflowEvents\Ticket\CollaboratorReply();
  624.                     $event
  625.                         ->setTicket($ticket)
  626.                     ;
  627.                 } else {
  628.                     $event = new CoreWorkflowEvents\Ticket\AgentReply();
  629.                     $event
  630.                         ->setTicket($ticket)
  631.                     ;
  632.                 }
  633.             }
  635.             // Trigger thread reply event
  636.             $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  637.         } else if (false === $ticket->getIsTrashed() && strtolower($ticket->getStatus()->getCode()) != 'spam' && empty($mailData['inReplyTo'])) {
  638.             return [
  639.                 'message' => "The contents of this email has already been processed.", 
  640.                 'content' => [
  641.                     'from'   => ! empty($mailData['from']) ? $mailData['from'] : null, 
  642.                     'thread' => ! empty($thread) ? $thread->getId() : null, 
  643.                     'ticket' => ! empty($ticket) ? $ticket->getId() : null, 
  644.                 ], 
  645.             ];
  646.         }
  648.         return [
  649.             'message' => "Inbound email processed successfully.", 
  650.             'content' => [
  651.                 'from'   => ! empty($mailData['from']) ? $mailData['from'] : null, 
  652.                 'thread' => ! empty($thread) ? $thread->getId() : null, 
  653.                 'ticket' => ! empty($ticket) ? $ticket->getId() : null, 
  654.             ], 
  655.         ];
  656.     }
  658.     public function processOutlookMail(array $outlookEmail)
  659.     {
  660.         $mailData = [];
  661.         $senderName = null;
  662.         $senderAddress = null;
  664.         if (! empty($outlookEmail['from']['emailAddress']['address'])) {
  665.             $senderName = $outlookEmail['from']['emailAddress']['name'];
  666.             $senderAddress = $outlookEmail['from']['emailAddress']['address'];
  667.         } else if (! empty($outlookEmail['sender']['emailAddress']['address'])) {
  668.             $senderName = $outlookEmail['sender']['emailAddress']['name'];
  669.             $senderAddress = $outlookEmail['sender']['emailAddress']['address'];
  670.         } else {
  671.             return [
  672.                 'message' => "No 'from' email address was found while processing contents of email.", 
  673.                 'content' => [], 
  674.             ];
  675.         }
  677.         $toRecipients = array_map(function ($recipient) { return $recipient['emailAddress']['address']; }, $outlookEmail['toRecipients']);
  678.         $ccRecipients = array_map(function ($recipient) { return $recipient['emailAddress']['address']; }, $outlookEmail['ccRecipients'] ?? []);
  679.         $bccRecipients = array_map(function ($recipient) { return $recipient['emailAddress']['address']; }, $outlookEmail['bccRecipients'] ?? []);
  681.         $addresses = [
  682.             'from' => $senderAddress, 
  683.             'to'   => $toRecipients, 
  684.             'cc'   => $ccRecipients, 
  685.         ];
  686.         
  687.         // Skip email processing if no to-emails are specified
  688.         if (empty($addresses['to'])) {
  689.             return [
  690.                 'message' => "No 'to' email addresses were found in the email.", 
  691.                 'content' => [
  692.                     'from' => $senderAddress ?? null, 
  693.                 ], 
  694.             ];
  695.         }
  697.         // Check for self-referencing. Skip email processing if a mailbox is configured by the sender's address.
  698.         try {
  699.             $this->getMailboxByEmail($senderAddress);
  701.             return [
  702.                 'message' => "Received a self-referencing email where the sender email address matches one of the configured mailbox address. Skipping email from further processing.", 
  703.                 'content' => [
  704.                     'from' => $senderAddress ?? null, 
  705.                 ], 
  706.             ];
  707.         } catch (\Exception $e) {
  708.             // An exception being thrown means no mailboxes were found from the recipient's address. Continue processing.
  709.         }
  711.         // Process Mail - References
  712.         // $addresses['to'][0] = isset($mailData['replyTo']) ? strtolower($mailData['replyTo']) : strtolower($addresses['to'][0]);
  713.         $mailData['replyTo'] = $addresses['to'];
  715.         $mailData['messageId'] = $outlookEmail['internetMessageId'];
  716.         $mailData['outlookConversationId'] = $outlookEmail['conversationId'];
  717.         $mailData['inReplyTo'] = $outlookEmail['conversationId'];
  718.         // $mailData['inReplyTo'] = htmlspecialchars_decode($parser->getHeader('in-reply-to'));
  719.         $mailData['referenceIds'] = '';
  720.         // $mailData['referenceIds'] = htmlspecialchars_decode($parser->getHeader('references'));
  721.         $mailData['cc'] = $ccRecipients;
  722.         $mailData['bcc'] = $bccRecipients;
  724.         // Process Mail - User Details
  725.         $mailData['source'] = 'email';
  726.         $mailData['createdBy'] = 'customer';
  727.         $mailData['role'] = 'ROLE_CUSTOMER';
  728.         $mailData['from'] = $senderAddress;
  729.         $mailData['name'] = trim($senderName);
  731.         // Process Mail - Content
  732.         $htmlFilter = new HTMLFilter();
  733.         $mailData['subject'] = $outlookEmail['subject'];
  734.         $mailData['message'] = autolink($htmlFilter->addClassEmailReplyQuote($outlookEmail['body']['content']));
  736.         $mailData['attachments'] = [];
  737.         $mailData['attachmentContent'] = isset($outlookEmail['outlookAttachments']) ? $outlookEmail['outlookAttachments'] : [];
  739.         $website = $this->entityManager->getRepository(Website::class)->findOneByCode('knowledgebase');
  740.         
  741.         if (
  742.             ! empty($mailData['from'])
  743.             && $this->container->get('ticket.service')->isEmailBlocked($mailData['from'], $website)
  744.         ) {
  745.             return [
  746.                 'message' => "Received email where the sender email address is present in the block list. Skipping this email from further processing.", 
  747.                 'content' => [
  748.                     'from' => !empty($mailData['from']) ? $mailData['from'] : null, 
  749.                 ], 
  750.             ];
  751.         }
  753.         // return [
  754.         //     'outlookConversationId' => $mailData['outlookConversationId'],
  755.         //     'message' => "No 'to' email addresses were found in the email.", 
  756.         //     'content' => [
  757.         //         'outlookConversationId' => $mailData['outlookConversationId'],
  758.         //     ], 
  759.         // ];
  761.         // Search for any existing tickets
  762.         $ticket = $this->searchExistingTickets([
  763.             'messageId'             => $mailData['messageId'],
  764.             'inReplyTo'             => $mailData['inReplyTo'],
  765.             'referenceIds'          => $mailData['referenceIds'],
  766.             'from'                  => $mailData['from'],
  767.             'subject'               => $mailData['subject'], 
  768.             'outlookConversationId' => $mailData['outlookConversationId'],
  769.         ]);
  771.         if (empty($ticket)) {
  772.             $mailData['threadType'] = 'create';
  773.             $mailData['referenceIds'] = $mailData['messageId'];
  775.             // @Todo For same subject with same customer check
  776.             // $ticketSubjectReferenceExist = $this->searchTicketSubjectReference($mailData['from'], $mailData['subject']);
  778.             // if(!empty($ticketSubjectReferenceExist)) {
  779.             //     return;
  780.             // }
  782.             $thread = $this->container->get('ticket.service')->createTicket($mailData);
  784.             // Trigger ticket created event
  785.             $event = new CoreWorkflowEvents\Ticket\Create();
  786.             $event
  787.                 ->setTicket($thread->getTicket())
  788.             ;
  790.             $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  791.         } else if (
  792.             false === $ticket->getIsTrashed()
  793.             && strtolower($ticket->getStatus()->getCode()) != 'spam'
  794.             && ! empty($mailData['inReplyTo'])
  795.         ) {
  796.             $mailData['threadType'] = 'reply';
  797.             $thread = $this->entityManager->getRepository(Thread::class)->findOneByMessageId($mailData['messageId']);
  798.             $ticketRef = $this->entityManager->getRepository(Ticket::class)->findById($ticket->getId());
  799.             $referenceIds = explode(' ', $ticketRef[0]->getReferenceIds());
  801.             if (! empty($thread)) {
  802.                 // Thread with the same message id exists skip process.
  803.                 return [
  804.                     'message' => "The contents of this email has already been processed 1.", 
  805.                     'content' => [
  806.                         'from'   => ! empty($mailData['from']) ? $mailData['from'] : null, 
  807.                         'thread' => $thread->getId(), 
  808.                         'ticket' => $ticket->getId(), 
  809.                     ], 
  810.                 ];
  811.             }
  813.             if (in_array($mailData['messageId'], $referenceIds)) {
  814.                 // Thread with the same message id exists skip process.
  815.                 return [
  816.                     'message' => "The contents of this email has already been processed 2.", 
  817.                     'content' => [
  818.                         'from' => !empty($mailData['from']) ? $mailData['from'] : null, 
  819.                     ], 
  820.                 ];
  821.             }
  823.             if ($ticket->getCustomer() && $ticket->getCustomer()->getEmail() == $mailData['from']) {
  824.                 // Reply from customer
  825.                 $user = $ticket->getCustomer();
  827.                 $mailData['user'] = $user;
  828.                 $userDetails = $user->getCustomerInstance()->getPartialDetails();
  829.             } else if ($this->entityManager->getRepository(Ticket::class)->isTicketCollaborator($ticket, $mailData['from'])){
  830.                 // Reply from collaborator
  831.                 $user = $this->entityManager->getRepository(User::class)->findOneByEmail($mailData['from']);
  833.                 $mailData['user'] = $user;
  834.                 $mailData['createdBy'] = 'collaborator';
  835.                 $userDetails = $user->getCustomerInstance()->getPartialDetails();
  836.             } else {
  837.                 $user = $this->entityManager->getRepository(User::class)->findOneByEmail($mailData['from']);
  838.                 if (! empty($user) && null != $user->getAgentInstance()) {
  839.                     $mailData['user'] = $user;
  840.                     $mailData['createdBy'] = 'agent';
  841.                     $userDetails = $user->getAgentInstance()->getPartialDetails();
  842.                 } else {
  843.                     // Add user as a ticket collaborator
  844.                     if (empty($user)) {
  845.                         // Create a new user instance with customer support role
  846.                         $role = $this->entityManager->getRepository(SupportRole::class)->findOneByCode('ROLE_CUSTOMER');
  848.                         $user = $this->container->get('user.service')->createUserInstance($mailData['from'], $mailData['name'], $role, [
  849.                             'source' => 'email',
  850.                             'active' => true
  851.                         ]);
  852.                     }
  854.                     $mailData['user'] = $user;
  855.                     $userDetails = $user->getCustomerInstance()->getPartialDetails();
  857.                     if (false == $this->entityManager->getRepository(Ticket::class)->isTicketCollaborator($ticket, $mailData['from'])) {
  858.                         $ticket->addCollaborator($user);
  860.                         $this->entityManager->persist($ticket);
  861.                         $this->entityManager->flush();
  863.                         $ticket->lastCollaborator = $user;
  864.                         
  865.                         $event = new CoreWorkflowEvents\Ticket\Collaborator();
  866.                         $event
  867.                             ->setTicket($ticket)
  868.                         ;
  870.                         $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  871.                     }
  872.                 }
  873.             }
  875.             $mailData['fullname'] = $userDetails['name'];
  876.             
  877.             $thread = $this->container->get('ticket.service')->createThread($ticket, $mailData);
  878.             
  879.             if ($thread->getThreadType() == 'reply') {
  880.                 if ($thread->getCreatedBy() == 'customer') {
  881.                     $event = new CoreWorkflowEvents\Ticket\CustomerReply();
  882.                     $event
  883.                         ->setTicket($ticket)
  884.                     ;
  885.                 }  else if ($thread->getCreatedBy() == 'collaborator') {
  886.                     $event = new CoreWorkflowEvents\Ticket\CollaboratorReply();
  887.                     $event
  888.                         ->setTicket($ticket)
  889.                     ;
  890.                 } else {
  891.                     $event = new CoreWorkflowEvents\Ticket\AgentReply();
  892.                     $event
  893.                         ->setTicket($ticket)
  894.                     ;
  895.                 }
  896.             }
  898.             // Trigger thread reply event
  899.             $this->container->get('event_dispatcher')->dispatch($event, 'uvdesk.automation.workflow.execute');
  900.         } else if (false === $ticket->getIsTrashed() && strtolower($ticket->getStatus()->getCode()) != 'spam' && empty($mailData['inReplyTo'])) {
  901.             return [
  902.                 'message' => "The contents of this email has already been processed 3.", 
  903.                 'content' => [
  904.                     'from'   => ! empty($mailData['from']) ? $mailData['from'] : null, 
  905.                     'thread' => ! empty($thread) ? $thread->getId() : null, 
  906.                     'ticket' => ! empty($ticket) ? $ticket->getId() : null, 
  907.                 ], 
  908.             ];
  909.         }
  911.         return [
  912.             'message' => "Inbound email processed successfully.", 
  913.             'content' => [
  914.                 'from'   => ! empty($mailData['from']) ? $mailData['from'] : null, 
  915.                 'thread' => ! empty($thread) ? $thread->getId() : null, 
  916.                 'ticket' => ! empty($ticket) ? $ticket->getId() : null, 
  917.             ],
  918.         ];
  919.     }
  920. }