public function testEnsureEmailBodyCachedForAlreadyCached()
 {
     $email = new Email();
     $email->setEmailBody(new EmailBody());
     $this->emailBodySynchronizer->expects($this->never())->method('syncOneEmailBody');
     $this->manager->ensureEmailBodyCached($email);
 }

 /**
  * @dataProvider replaceDataProvider
  * @param       $bodyTemplate
  * @param array $attachments
  */
 public function testReplace($bodyTemplate, array $attachments)
 {
     $email = new Email();
     $emailBody = new EmailBody();
     $replacements = [];
     $contentIds = [];
     foreach ($attachments as $attachmentData) {
         $attachment = new EmailAttachment();
         $emailAttachmentContent = new EmailAttachmentContent();
         $emailAttachmentContent->setContent($attachmentData['content'])->setContentTransferEncoding($attachmentData['transfer_encoding']);
         $attachment->setEmbeddedContentId($attachmentData['content_id'])->setContentType($attachmentData['type'])->setContent($emailAttachmentContent);
         $emailBody->addAttachment($attachment);
         $cid = 'cid:' . $attachmentData['content_id'];
         $contentIds[] = $cid;
         if ($attachmentData['replace']) {
             $replacements[] = sprintf('data:%s;base64,%s', $attachmentData['type'], $attachmentData['content']);
         } else {
             $replacements[] = $cid;
         }
     }
     $emailBody->setBodyContent(vsprintf($bodyTemplate, $contentIds));
     $email->setEmailBody($emailBody);
     $event = new EmailBodyLoaded($email);
     $this->listener->replace($event);
     $this->assertEquals($email, $event->getEmail());
     $this->assertEquals(vsprintf($bodyTemplate, $replacements), $event->getEmail()->getEmailBody()->getBodyContent());
 }

 /**
  * Check that email body is cached.
  * If do not, load it using appropriate email extension add it to a cache.
  *
  * @param Email $email
  *
  * @throws LoadEmailBodyException if a body of the given email cannot be loaded
  */
 public function ensureEmailBodyCached(Email $email)
 {
     if ($email->getEmailBody() === null) {
         // body loader can load email from any folder
         // todo: refactor to use correct emailuser and origin
         // to use active origin and get correct folder from this origin
         $emailUser = $email->getEmailUsers()->first();
         $folder = $emailUser->getFolders()->first();
         $origin = $emailUser->getOrigin();
         if (!$origin) {
             throw new LoadEmailBodyFailedException($email);
         }
         $loader = $this->selector->select($origin);
         try {
             $emailBody = $loader->loadEmailBody($folder, $email, $this->em);
         } catch (LoadEmailBodyException $loadEx) {
             $this->logger->notice(sprintf('Load email body failed. Email id: %d. Error: %s', $email->getId(), $loadEx->getMessage()), ['exception' => $loadEx]);
             throw $loadEx;
         } catch (\Exception $ex) {
             $this->logger->warning(sprintf('Load email body failed. Email id: %d. Error: %s.', $email->getId(), $ex->getMessage()), ['exception' => $ex]);
             throw new LoadEmailBodyFailedException($email, $ex);
         }
         $email->setEmailBody($emailBody);
         $this->em->persist($email);
         $this->em->flush();
         $event = new EmailBodyAdded($email);
         $this->eventDispatcher->dispatch(EmailBodyAdded::NAME, $event);
     }
     $this->eventDispatcher->dispatch(EmailBodyLoaded::NAME, new EmailBodyLoaded($email));
 }

 /**
  * Returns the context for the given email
  *
  * @param Email $email
  *
  * @return array
  */
 public function getEmailContext(Email $email)
 {
     $criteria = Criteria::create();
     $criteria->andWhere(Criteria::expr()->eq('id', $email->getId()));
     $qb = $this->activityManager->getActivityTargetsQueryBuilder($this->class, $criteria);
     if (null === $qb) {
         return [];
     }
     $result = $qb->getQuery()->getResult();
     if (empty($result)) {
         return $result;
     }
     $currentUser = $this->securityFacade->getLoggedUser();
     $currentUserClass = ClassUtils::getClass($currentUser);
     $currentUserId = $currentUser->getId();
     $result = array_values(array_filter($result, function ($item) use($currentUserClass, $currentUserId) {
         return !($item['entity'] === $currentUserClass && $item['id'] == $currentUserId);
     }));
     foreach ($result as &$item) {
         $route = $this->configManager->getEntityMetadata($item['entity'])->getRoute();
         $item['entityId'] = $email->getId();
         $item['targetId'] = $item['id'];
         $item['targetClassName'] = $this->entityClassNameHelper->getUrlSafeClassName($item['entity']);
         $item['icon'] = $this->configManager->getProvider('entity')->getConfig($item['entity'])->get('icon');
         $item['link'] = $route ? $this->router->generate($route, ['id' => $item['id']]) : null;
         unset($item['id'], $item['entity']);
     }
     return $result;
 }

 /**
  * (@inherit)
  */
 public function setFlags(EmailFolder $folder, Email $email, $flags)
 {
     $repoImapEmail = $this->em->getRepository('OroImapBundle:ImapEmail');
     $uid = $repoImapEmail->getUid($folder->getId(), $email->getId());
     $this->connector->selectFolder($folder->getFullName());
     $this->connector->setFlags($uid, $flags);
 }

 /**
  * Check that email body is cached.
  * If do not, load it using appropriate email extension add it to a cache.
  *
  * @param Email $email
  *
  * @throws LoadEmailBodyException if a body of the given email cannot be loaded
  */
 public function ensureEmailBodyCached(Email $email)
 {
     if ($email->getEmailBody() !== null) {
         // The email body is already cached
         return;
     }
     // body loader can load email from any folder
     $folder = $email->getEmailUsers()->first()->getFolder();
     $origin = $folder->getOrigin();
     $loader = $this->selector->select($origin);
     try {
         $emailBody = $loader->loadEmailBody($folder, $email, $this->em);
     } catch (LoadEmailBodyException $loadEx) {
         $this->logger->notice(sprintf('Load email body failed. Email id: %d. Error: %s', $email->getId(), $loadEx->getMessage()), ['exception' => $loadEx]);
         throw $loadEx;
     } catch (\Exception $ex) {
         $this->logger->warning(sprintf('Load email body failed. Email id: %d. Error: %s.', $email->getId(), $ex->getMessage()), ['exception' => $ex]);
         throw new LoadEmailBodyFailedException($email, $ex);
     }
     $email->setEmailBody($emailBody);
     $this->em->persist($email);
     $this->em->flush();
     $event = new EmailBodyAdded($email);
     $this->eventDispatcher->dispatch(EmailBodyAdded::NAME, $event);
 }

 public function testGetDate()
 {
     $email = new Email();
     $date = new \DateTime('now', new \DateTimeZone('UTC'));
     $email->setSentAt($date);
     $this->assertSame($date, $this->provider->getDate($email));
 }

 /**
  * Check that email body is cached.
  * If do not, load it using appropriate email extension add it to a cache.
  *
  * @param Email $email
  */
 public function ensureEmailBodyCached(Email $email)
 {
     if ($email->getEmailBody() === null) {
         $this->emailBodySynchronizer->syncOneEmailBody($email);
         $this->em->flush();
     }
     $this->eventDispatcher->dispatch(EmailBodyLoaded::NAME, new EmailBodyLoaded($email));
 }

 public function testBeforeSave()
 {
     $entity = new Email();
     $entity->beforeSave();
     $createdAt = new \DateTime('now', new \DateTimeZone('UTC'));
     $this->assertEquals(Email::NORMAL_IMPORTANCE, $entity->getImportance());
     $this->assertGreaterThanOrEqual($createdAt, $entity->getCreated());
 }

 /**
  * @param Email  $email
  * @param \Exception $previous
  */
 public function __construct(Email $email, \Exception $previous = null)
 {
     $message = sprintf('Cannot load a body for "%s" email.', $email->getSubject());
     if ($previous) {
         $message .= sprintf(' Reason: %s.', $previous->getMessage());
     }
     parent::__construct($message, 0, $previous);
 }

 /**
  * @param array $targets
  * @param Email $email
  */
 protected function addRecipientOwners(&$targets, Email $email)
 {
     $recipients = $email->getRecipients();
     foreach ($recipients as $recipient) {
         $owner = $recipient->getEmailAddress()->getOwner();
         if ($owner) {
             $this->addTarget($targets, $owner);
         }
     }
 }

 /**
  * @param Email $email
  *
  * @return bool|string
  */
 protected function getFromNameLink(Email $email)
 {
     $path = false;
     if ($email->getFromEmailAddress() && $email->getFromEmailAddress()->getOwner()) {
         $className = $email->getFromEmailAddress()->getOwner()->getClass();
         $routeName = $this->configManager->getEntityMetadata($className)->getRoute('view', false);
         $path = $this->router->generate($routeName, ['id' => $email->getFromEmailAddress()->getOwner()->getId()]);
     }
     return $path;
 }

 /**
  * {@inheritDoc}
  */
 public function load(ObjectManager $manager)
 {
     $fromEmail = new EmailAddressProxy();
     $fromEmail->setEmail(uniqid() . '@gmail.com');
     $email = new Email();
     $email->setSubject(uniqid())->setFromName(uniqid())->setReceivedAt(new \DateTime())->setSentAt(new \DateTime())->setInternalDate(new \DateTime())->setFromEmailAddress($fromEmail)->setMessageId(uniqid());
     $manager->persist($fromEmail);
     $manager->persist($email);
     $manager->flush();
 }

 /**
  * Check that email body is cached.
  * If do not, load it using appropriate email extension add it to a cache.
  *
  * @param Email $email
  */
 public function ensureEmailBodyCached(Email $email)
 {
     if ($email->getEmailBody() !== null) {
         // The email body is already cached
         return;
     }
     $emailBody = $this->selector->select($email->getFolder()->getOrigin())->loadEmailBody($email, $this->em);
     $email->setEmailBody($emailBody);
     $this->em->persist($email);
     $this->em->flush();
 }

 /**
  * Add recipients to the specified Email object
  *
  * @param Email $obj The Email object recipients is added to
  * @param string $type The recipient type. Can be to, cc or bcc
  * @param string $email The email address, for example: [email protected] or "John Smith" <[email protected]>
  */
 protected function addRecipients(Email $obj, $type, $email)
 {
     if (!empty($email)) {
         if (is_string($email)) {
             $obj->addRecipient($this->recipient($type, $email));
         } elseif (is_array($email) || $email instanceof \Traversable) {
             foreach ($email as $e) {
                 $obj->addRecipient($this->recipient($type, $e));
             }
         }
     }
 }

 /**
  * Updates email references' threadId
  *
  * @param EntityManager $entityManager
  * @param Email $entity
  */
 protected function updateRefs(EntityManager $entityManager, Email $entity)
 {
     if ($entity->getThread()) {
         /** @var Email $email */
         foreach ($this->emailThreadProvider->getEmailReferences($this->em, $entity) as $email) {
             if (!$email->getThread()) {
                 $email->setThread($entity->getThread());
                 $entityManager->persist($email);
             }
         }
     }
 }

 /**
  * Check that email body is cached.
  * If do not, load it using appropriate email extension add it to a cache.
  *
  * @param Email $email
  */
 public function ensureEmailBodyCached(Email $email)
 {
     if ($email->getEmailBody() !== null) {
         // The email body is already cached
         return;
     }
     // body loader can load email from any folder
     $folder = $email->getFolders()->first();
     $origin = $folder->getOrigin();
     $emailBody = $this->selector->select($origin)->loadEmailBody($folder, $email, $this->em);
     $email->setEmailBody($emailBody);
     $this->em->persist($email);
     $this->em->flush();
 }

 /**
  * @param object $getOwnerResult
  * @param object $getUserResult
  * @param int    $getToCalls
  *
  * @dataProvider createReplyEmailModelProvider
  */
 public function testCreateReplyAllEmailModel($getOwnerResult, $getUserResult, $getToCalls)
 {
     $this->fromEmailAddress = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailAddress');
     $this->fromCcEmailAddress = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailAddress');
     $this->fromEmailAddress->expects($this->once())->method('getOwner')->willReturn($getOwnerResult);
     $this->helper->expects($this->any())->method('getUser')->willReturn($getUserResult);
     $getUserResult->expects($this->any())->method('getEmails')->willReturn([]);
     $this->email->expects($this->once())->method('getFromEmailAddress')->willReturn($this->fromEmailAddress);
     $this->email->expects($this->any())->method('getId');
     $emailAddress = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailAddress');
     $emailAddress->expects($this->exactly($getToCalls))->method('getEmail')->willReturn(null);
     $emailRecipient = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailRecipient');
     $emailRecipient->expects($this->exactly($getToCalls))->method('getEmailAddress')->willReturn($emailAddress);
     $to = new ArrayCollection();
     $to->add($emailRecipient);
     $this->email->expects($this->exactly($getToCalls))->method('getTo')->willReturn($to);
     $emailCcRecipient = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailRecipient');
     $emailCcRecipient->expects($this->once())->method('getEmailAddress')->willReturn($this->fromCcEmailAddress);
     $cc = new ArrayCollection();
     $cc->add($emailCcRecipient);
     $this->email->expects($this->exactly($getToCalls))->method('getCc')->willReturn($cc);
     $this->helper->expects($this->once())->method('prependWith');
     $this->helper->expects($this->once())->method('getEmailBody');
     $this->activityListProvider->expects($this->once())->method('getTargetEntities')->willReturn([]);
     $result = $this->emailModelBuilder->createReplyAllEmailModel($this->email);
     $this->assertInstanceOf('Oro\\Bundle\\EmailBundle\\Form\\Model\\Email', $result);
 }

 /**
  * @param Email       $email
  * @param object|null $owner
  */
 protected function addEmailRecipient(Email $email, $owner = null)
 {
     $emailAddr = new EmailAddress();
     $emailAddr->setOwner($owner);
     $recipient = new EmailRecipient();
     $recipient->setEmailAddress($emailAddr);
     $email->addRecipient($recipient);
 }

 /**
  * @param boolean $atLeastOneGranted
  * @dataProvider voteProvider
  */
 public function testVote($atLeastOneGranted)
 {
     $token = $this->getMock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface');
     $email = new Email();
     $emailUser1 = new EmailUser();
     $emailUser2 = new EmailUser();
     $emailUser3 = new EmailUser();
     $email->addEmailUser($emailUser1);
     $email->addEmailUser($emailUser2);
     $email->addEmailUser($emailUser3);
     $attributes = ['VIEW'];
     if ($atLeastOneGranted) {
         $this->securityFacade->expects($this->once())->method('isGranted')->with('VIEW', ${'emailUser' . mt_rand(1, 3)})->willReturn(true);
     }
     $result = $atLeastOneGranted ? EmailVoter::ACCESS_GRANTED : EmailVoter::ACCESS_DENIED;
     $this->assertEquals($result, $this->emailVoter->vote($token, $email, $attributes));
 }