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

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