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: john@example.com or "John Smith" <*****@*****.**>
*/
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));
}
public function testCreateForwardEmailModel()
{
$this->helper->expects($this->once())->method('prependWith');
$emailBody = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailBody');
$emailBody->expects($this->exactly(1))->method('getAttachments')->willReturn([]);
$this->email->expects($this->once())->method('getEmailBody')->willReturn($emailBody);
$result = $this->emailModelBuilder->createForwardEmailModel($this->email);
$this->assertInstanceOf('Oro\\Bundle\\EmailBundle\\Form\\Model\\Email', $result);
}
public function inapplicableEmailsProvider()
{
$date = new \DateTime('now', new \DateTimeZone('UTC'));
$oldEmailDate = new \DateTime('now', new \DateTimeZone('UTC'));
$oldEmailDate->sub(\DateInterval::createFromDateString('2 day'));
$applicableSubjectsAndBodies = [['not empty subject', 'This is email body with offer, sale and won words.', $date], [null, 'This email has nothing.', $date], [null, 'This is email body with sale and won words.', $oldEmailDate]];
$data = array_map(function ($subjectAndBody) {
list($subject, $bodyContent, $sentAt) = $subjectAndBody;
$body = new EmailBody();
$body->setBodyContent($bodyContent);
$email = new Email();
$email->setSubject($subject);
$email->setEmailBody($body);
$email->setSentAt($sentAt);
return [$email];
}, $applicableSubjectsAndBodies);
return $data;
}
public function getTestData()
{
$badEmail = new Email();
$badEmailAddress = new EmailAddress();
$badEmailOwner = new TestEmailOwner();
$badEmailAddress->setOwner($badEmailOwner);
$badRecipient = new EmailRecipient();
$badRecipient->setEmailAddress($badEmailAddress);
$badEmail->addRecipient($badRecipient);
$email = new Email();
$emailAddress = new EmailAddress();
$organization = new TestOrganization(3);
$emailOwner = new TestUser(null, null, null, $organization);
$emailAddress->setOwner($emailOwner);
$recipient = new EmailRecipient();
$recipient->setEmailAddress($emailAddress);
$email->addRecipient($recipient);
return ['wrong class' => [new \stdClass(), ['integer' => ['organization' => null]]], 'email without correct user organization' => [$badEmail, ['integer' => ['organization' => 0]]], 'correct email' => [$email, ['integer' => ['organization' => [3]]]]];
}
public function testEnsureEmailBodyCached()
{
$email = new Email();
$emailBody = new EmailBody();
$emailUser = new EmailUser();
$origin = new TestEmailOrigin();
$folder = new EmailFolder();
$folder->setOrigin($origin);
$emailUser->setFolder($folder);
$email->addEmailUser($emailUser);
$loader = $this->getMock('Oro\\Bundle\\EmailBundle\\Provider\\EmailBodyLoaderInterface');
$this->selector->expects($this->once())->method('select')->with($this->identicalTo($origin))->will($this->returnValue($loader));
$loader->expects($this->once())->method('loadEmailBody')->with($this->identicalTo($folder), $this->identicalTo($email), $this->identicalTo($this->em))->will($this->returnValue($emailBody));
$this->em->expects($this->once())->method('persist')->with($this->identicalTo($email));
$this->em->expects($this->once())->method('flush');
$this->logger->expects($this->never())->method('notice');
$this->logger->expects($this->never())->method('warning');
$this->manager->ensureEmailBodyCached($email);
$this->assertSame($emailBody, $email->getEmailBody());
}
/**
* {@inheritdoc}
*/
public function loadEmailBody(Email $email, EntityManager $em)
{
/** @var ImapEmailOrigin $origin */
$origin = $email->getFolder()->getOrigin();
$config = new ImapConfig($origin->getHost(), $origin->getPort(), $origin->getSsl(), $origin->getUser(), $this->encryptor->decryptData($origin->getPassword()));
$manager = new ImapEmailManager($this->connectorFactory->createImapConnector($config));
$manager->selectFolder($email->getFolder()->getFullName());
$repo = $em->getRepository('OroImapBundle:ImapEmail');
$query = $repo->createQueryBuilder('e')->select('e.uid')->where('e.email = ?1')->setParameter(1, $email)->getQuery();
/** @var ImapEmail $imapEmail */
$imapEmail = $query->getSingleResult();
$loadedEmail = $manager->findEmail($imapEmail['uid']);
if ($loadedEmail === null) {
throw new \RuntimeException(sprintf('Cannot find a body for "%s" email.', $email->getSubject()));
}
$builder = new EmailBodyBuilder();
$builder->setEmailBody($loadedEmail->getBody()->getContent(), $loadedEmail->getBody()->getBodyIsText());
foreach ($loadedEmail->getAttachments() as $attachment) {
$builder->addEmailAttachment($attachment->getFileName(), $attachment->getContent(), $attachment->getContentType(), $attachment->getContentTransferEncoding());
}
return $builder->getEmailBody();
}
/**
* @param Email $email
* @param $data
*
* @return mixed
*/
protected function setReplaedEmailId($email, $data)
{
if ($email->getThread()) {
$emails = $email->getThread()->getEmails();
// if there are just two email - add replayedEmailId to use on client side
if (count($emails) === 2) {
$data['replayedEmailId'] = $emails[0]->getId();
}
}
return $data;
}
/**
* @param Email $email
*/
public function __construct(Email $email)
{
parent::__construct(sprintf('Cannot find a body for "%s" email.', $email->getSubject()));
}
/**
* Prepare emails to set status. If need get all from thread
*
* @param Email $entity
* @param bool $checkThread Get threaded emails
*
* @return Email[]
*/
protected function prepareFlaggedEmailEntities(Email $entity, $checkThread)
{
$thread = $entity->getThread();
$emails = [$entity];
if ($checkThread && $thread) {
$emails = $thread->getEmails();
return $emails->toArray();
}
return $emails;
}
/**
* Gets array of EmailUser's by Email or EmailThread of this email depends on $checkThread flag
* for current user and organization or which have mailbox owner.
*
* @param Email $email
* @param User $user
* @param Organization $organization
* @param bool|false $checkThread
*
* @return EmailUser[]
*/
public function getAllEmailUsersByEmail(Email $email, User $user, Organization $organization, $checkThread = false)
{
$parameters = [];
$queryBuilder = $this->createQueryBuilder('eu')->join('eu.email', 'e');
if ($checkThread && ($thread = $email->getThread())) {
$queryBuilder->andWhere('e.thread = :thread');
$parameters['thread'] = $thread;
} else {
$queryBuilder->andWhere('eu.email = :email');
$parameters['email'] = $email;
}
$orx = $queryBuilder->expr()->orX();
$orx->add('eu.mailboxOwner IS NOT NULL')->add('eu.owner = :owner AND eu.organization = :organization');
return $queryBuilder->andWhere($orx)->setParameters(array_merge($parameters, ['owner' => $user, 'organization' => $organization]))->getQuery()->getResult();
}
/**
* Determines whether two emails are the same email message
*
* @param Email $email1
* @param Email $email2
* @return bool
*/
protected function areEmailsEqual(Email $email1, Email $email2)
{
return $email1->getMessageId() === $email2->getMessageId();
}