/**
* (@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);
}
/**
* {@inheritdoc}
*/
public function select(EmailFolder $folder, OroEntityManager $em)
{
/** @var UserEmailOrigin $origin */
$origin = $folder->getOrigin();
$config = new ImapConfig($origin->getImapHost(), $origin->getImapPort(), $origin->getImapEncryption(), $origin->getUser(), $this->encryptor->decryptData($origin->getPassword()), $this->imapEmailGoogleOauth2Manager->getAccessTokenWithCheckingExpiration($origin));
return new ImapEmailFlagManager($this->connectorFactory->createImapConnector($config), $em);
}
/**
* {@inheritdoc}
*/
public function select(EmailFolder $folder, OroEntityManager $em)
{
/** @var ImapEmailOrigin $origin */
$origin = $folder->getOrigin();
$config = new ImapConfig($origin->getHost(), $origin->getPort(), $origin->getSsl(), $origin->getUser(), $this->encryptor->decryptData($origin->getPassword()));
return new ImapEmailFlagManager($this->connectorFactory->createImapConnector($config), $em);
}
/**
* @param EmailFolder $emailFolder
*
* @return $this
*/
public function setEmailFolder($emailFolder)
{
$this->emailFolder = $emailFolder;
if ($this->hasParentFolderModel()) {
$this->emailFolder->setParentFolder($this->getParentFolderModel()->getEmailFolder());
}
return $this;
}
/**
* {@inheritDoc}
*/
public function load(ObjectManager $manager)
{
$outboxFolder = new EmailFolder();
$outboxFolder->setType(EmailFolder::SENT)->setName(EmailFolder::SENT)->setFullName(EmailFolder::SENT);
$origin = new InternalEmailOrigin();
$origin->setName(InternalEmailOrigin::BAP)->addFolder($outboxFolder);
$manager->persist($origin);
$manager->flush();
}
public function testEmailGetterAndSetter()
{
$email = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\Email');
$entity = new EmailFolder();
$entity->addEmail($email);
$emails = $entity->getEmails();
$this->assertInstanceOf('Doctrine\\Common\\Collections\\ArrayCollection', $emails);
$this->assertCount(1, $emails);
$this->assertTrue($email === $emails[0]);
}
public function testFolderGetterAndSetter()
{
$subFolder = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailFolder');
$subFolder2 = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailFolder');
$entity = new EmailFolder();
$entity->addSubFolder($subFolder);
$entity->addSubFolder($subFolder2);
$subFolders = $entity->getSubFolders();
$this->assertInstanceOf('Doctrine\\Common\\Collections\\ArrayCollection', $subFolders);
$this->assertCount(2, $subFolders);
$this->assertTrue($subFolder === $subFolders[0]);
$this->assertTrue($subFolder2 === $subFolders[1]);
}
/**
* {@inheritdoc}
*/
public function loadEmailBody(EmailFolder $folder, Email $email, EntityManager $em)
{
/** @var UserEmailOrigin $origin */
$origin = $folder->getOrigin();
$config = new ImapConfig($origin->getImapHost(), $origin->getImapPort(), $origin->getImapEncryption(), $origin->getUser(), $this->encryptor->decryptData($origin->getPassword()), $this->imapEmailGoogleOauth2Manager->getAccessTokenWithCheckingExpiration($origin));
$manager = new ImapEmailManager($this->connectorFactory->createImapConnector($config));
$manager->selectFolder($folder->getFullName());
$repo = $em->getRepository('OroImapBundle:ImapEmail');
$query = $repo->createQueryBuilder('e')->select('e.uid')->innerJoin('e.imapFolder', 'if')->where('e.email = ?1 AND if.folder = ?2')->setParameter(1, $email)->setParameter(2, $folder)->getQuery();
$loadedEmail = $manager->findEmail($query->getSingleScalarResult());
if (null === $loadedEmail) {
throw new EmailBodyNotFoundException($email);
}
$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(), $attachment->getContentId());
}
return $builder->getEmailBody();
}
public function testOutdatedAt()
{
$entity = new EmailFolder();
$this->assertFalse($entity->isOutdated());
$date = new \DateTime();
$entity->setOutdatedAt($date);
$this->assertEquals($date, $entity->getOutdatedAt());
$this->assertTrue($entity->isOutdated());
$entity->setOutdatedAt(null);
$this->assertFalse($entity->isOutdated());
}
/**
* {@inheritdoc}
*/
public function load(ObjectManager $manager)
{
$userManager = $this->container->get('oro_user.manager');
$organization = $manager->getRepository('OroOrganizationBundle:Organization')->getFirst();
$role = $manager->getRepository('OroUserBundle:Role')->findOneBy(['role' => 'ROLE_ADMINISTRATOR']);
$user = $userManager->createUser();
$user->setUsername('simple_user')->setPlainPassword('simple_password')->setEmail('*****@*****.**')->setOrganization($organization)->addOrganization($organization)->setEnabled(true)->addRole($role);
$folder = new EmailFolder();
$folder->setName('sent');
$folder->setFullName('sent');
$folder->setType('sent');
$origin = new InternalEmailOrigin();
$origin->setName('simple_user_origin_name');
$origin->setActive(true);
$origin->addFolder($folder);
$origin->setOwner($user);
$origin->setOrganization($organization);
$user->addEmailOrigin($origin);
$userManager->updateUser($user);
$user2 = $userManager->createUser();
$user2->setUsername('simple_user2')->setPlainPassword('simple_password2')->setFirstName('Elley')->setLastName('Towards')->setEmail('*****@*****.**')->setOrganization($organization)->addOrganization($organization)->setEnabled(true);
$folder2 = new EmailFolder();
$folder2->setName('sent');
$folder2->setFullName('sent');
$folder2->setType('sent');
$origin2 = new InternalEmailOrigin();
$origin2->setName('simple_user_origin_name_2');
$origin2->setActive(true);
$origin2->addFolder($folder2);
$origin2->setOwner($user2);
$origin2->setOrganization($organization);
$user2->addEmailOrigin($origin);
$userManager->updateUser($user2);
$this->setReference($user->getUsername(), $user);
$this->setReference($user2->getUsername(), $user2);
}
protected function getTestOrigin()
{
$outboxFolder = new EmailFolder();
$outboxFolder->setType(FolderType::SENT)->setName(FolderType::SENT)->setFullName(FolderType::SENT);
$origin = new InternalEmailOrigin();
$origin->setName('BAP_User_1')->addFolder($outboxFolder)->setOwner($this->getTestUser())->setOrganization($this->getTestOrganization());
return $origin;
}
/**
* Cleans doctrine's UOF to prevent:
* - "eating" too much memory
* - storing too many object which cause slowness of sync process
* Tracks time when last batch was saved.
* Calculates time between batch saves.
*
* @param bool $isFolderSyncComplete
* @param null|EmailFolder $folder
*/
protected function cleanUp($isFolderSyncComplete = false, $folder = null)
{
$this->emailEntityBuilder->getBatch()->clear();
/**
* Clear entity manager.
*/
$map = $this->entitiesToClear();
foreach ($map as $entityClass) {
$this->em->clear($entityClass);
}
/**
* In case folder sync completed and batch save time exceeded limit - throws exception.
*/
if ($isFolderSyncComplete && $folder != null && $this->dbBatchSaveTime > 0 && $this->dbBatchSaveTime > self::DB_BATCH_TIME) {
throw new SyncFolderTimeoutException($folder->getOrigin()->getId(), $folder->getFullName());
} elseif ($isFolderSyncComplete) {
/**
* In case folder sync completed without batch save time exceed - reset dbBatchSaveTime.
*/
$this->dbBatchSaveTime = -1;
} else {
/**
* After batch save - calculate time difference between batches
*/
if ($this->dbBatchSaveTimestamp !== 0) {
$this->dbBatchSaveTime = time() - $this->dbBatchSaveTimestamp;
$this->logger->info(sprintf('Batch save time: "%d" seconds.', $this->dbBatchSaveTime));
}
}
$this->dbBatchSaveTimestamp = time();
}
/**
* Add folder
*
* @param EmailFolder $folder
*
* @return EmailOrigin
*/
public function addFolder(EmailFolder $folder)
{
$this->folders[] = $folder;
$folder->setOrigin($this);
return $this;
}
/**
* Saves emails into the database
*
* @param Email[] $emails
* @param EmailFolder $folder
*/
protected function saveEmails(array $emails, EmailFolder $folder)
{
$this->emailEntityBuilder->removeEmails();
$uids = array_map(function ($el) {
/** @var Email $el */
return $el->getId()->getUid();
}, $emails);
$repo = $this->em->getRepository('OroImapBundle:ImapEmail');
$query = $repo->createQueryBuilder('e')->select('e.uid')->innerJoin('e.email', 'se')->innerJoin('se.folder', 'sf')->where('sf.id = :folderId AND e.uid IN (:uids)')->setParameter('folderId', $folder->getId())->setParameter('uids', $uids)->getQuery();
$existingUids = array_map(function ($el) {
return $el['uid'];
}, $query->getResult());
foreach ($emails as $src) {
if (!in_array($src->getId()->getUid(), $existingUids)) {
$this->log->notice(sprintf('Persisting "%s" email (UID: %d) ...', $src->getSubject(), $src->getId()->getUid()));
$email = $this->emailEntityBuilder->email($src->getSubject(), $src->getFrom(), $src->getToRecipients(), $src->getSentAt(), $src->getReceivedAt(), $src->getInternalDate(), $src->getImportance(), $src->getCcRecipients(), $src->getBccRecipients());
$email->setFolder($folder);
$imapEmail = new ImapEmail();
$imapEmail->setUid($src->getId()->getUid())->setEmail($email);
$this->em->persist($imapEmail);
$this->log->notice(sprintf('The "%s" email was persisted.', $src->getSubject()));
} else {
$this->log->notice(sprintf('Skip "%s" (UID: %d) email, because it is already synchronised.', $src->getSubject(), $src->getId()->getUid()));
}
}
$this->emailEntityBuilder->getBatch()->persist($this->em);
$this->em->flush();
}
/**
* @expectedException \Oro\Bundle\EmailBundle\Exception\EmailBodyNotFoundException
* @expectedExceptionMessage Cannot find a body for "test email" email.
*/
public function testEnsureEmailBodyCachedNotFound()
{
$email = new Email();
ReflectionUtil::setId($email, 123);
$email->setSubject('test email');
$emailBody = new EmailBody();
$emailUser = new EmailUser();
$origin = new TestEmailOrigin();
$folder = new EmailFolder();
$folder->setOrigin($origin);
$emailUser->setFolder($folder);
$email->addEmailUser($emailUser);
$exception = new EmailBodyNotFoundException($email);
$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')->will($this->throwException($exception));
$this->em->expects($this->never())->method('persist');
$this->em->expects($this->never())->method('flush');
$this->logger->expects($this->once())->method('notice')->with('Load email body failed. Email id: 123. Error: Cannot find a body for "test email" email.', ['exception' => $exception]);
$this->logger->expects($this->never())->method('warning');
$this->manager->ensureEmailBodyCached($email);
$this->assertSame($emailBody, $email->getEmailBody());
}
/**
* Performs synchronization of folders
*
* @param EmailOrigin $origin
*
* @return ImapEmailFolder[] The list of folders for which emails need to be synchronized
*/
protected function syncFolders(EmailOrigin $origin)
{
$folders = [];
$existingImapFolders = $this->getExistingImapFolders($origin);
$srcFolders = $this->getFolders();
foreach ($srcFolders as $srcFolder) {
$folderFullName = $srcFolder->getGlobalName();
$uidValidity = $this->getUidValidity($srcFolder);
// check if the current folder already exist and has no changes,
// if so, remove it from the list of existing folders
$imapFolder = null;
foreach ($existingImapFolders as $key => $existingImapFolder) {
if ($existingImapFolder->getUidValidity() === $uidValidity && $existingImapFolder->getFolder()->getFullName() === $folderFullName) {
$imapFolder = $existingImapFolder;
unset($existingImapFolders[$key]);
break;
}
}
// check if new folder need to be created
if (!$imapFolder) {
$this->logger->notice(sprintf('Persisting "%s" folder ...', $folderFullName));
$folder = new EmailFolder();
$folder->setFullName($folderFullName)->setName($srcFolder->getLocalName())->setType($srcFolder->guessFolderType());
$origin->addFolder($folder);
$this->em->persist($folder);
$imapFolder = new ImapEmailFolder();
$imapFolder->setFolder($folder);
$imapFolder->setUidValidity($uidValidity);
$this->em->persist($imapFolder);
$this->logger->notice(sprintf('The "%s" folder was persisted.', $folderFullName));
}
// save folder to the list of folders to be synchronized
$folders[] = $imapFolder;
}
// mark the rest of existing folders as outdated
foreach ($existingImapFolders as $imapFolder) {
$this->logger->notice(sprintf('Mark "%s" folder as outdated.', $imapFolder->getFolder()->getFullName()));
$imapFolder->getFolder()->setOutdatedAt(new \DateTime('now', new \DateTimeZone('UTC')));
$this->em->persist($imapFolder->getFolder());
}
$this->em->persist($origin);
$this->em->flush();
return $folders;
}
public function testSync()
{
$email = new Email();
$email->setSubject('Test email');
$emailBody = new EmailBody();
$emailUser = new EmailUser();
$origin = new TestEmailOrigin();
$folder = new EmailFolder();
$folder->setOrigin($origin);
$emailUser->setOrigin($origin);
$emailUser->addFolder($folder);
$email->addEmailUser($emailUser);
$repo = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Repository\\EmailRepository')->disableOriginalConstructor()->getMock();
$this->doctrine->expects($this->once())->method('getRepository')->willReturn($repo);
$runCount = 0;
$repo->expects($this->exactly(2))->method('getEmailsWithoutBody')->willReturnCallback(function () use(&$runCount, $email) {
$runCount++;
return $runCount === 1 ? [$email] : [];
});
$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->em->expects($this->once())->method('clear');
$this->logger->expects($this->exactly(2))->method('notice');
$this->logger->expects($this->never())->method('warning');
$this->synchronizer->sync();
$this->assertSame($emailBody, $email->getEmailBody());
}
/**
* @param EmailFolder $folder
* @param Email $email
* @param array $existingUids
*
* @return bool
*/
protected function allowSaveEmail(EmailFolder $folder, Email $email, array $existingUids)
{
if ($folder->getSynchronizedAt() > $email->getSentAt()) {
$this->logger->info(sprintf('Skip "%s" (UID: %d) email, because it was sent earlier than the last synchronization was done', $email->getSubject(), $email->getId()->getUid()));
return false;
}
if (in_array($email->getId()->getUid(), $existingUids)) {
$this->logger->info(sprintf('Skip "%s" (UID: %d) email, because it is already synchronised.', $email->getSubject(), $email->getId()->getUid()));
return false;
}
return true;
}
/**
* @param EmailFolder $folder
* @param array $messages
* @return EmailUser[]
*/
public function getEmailUsersByFolderAndMessageIds(EmailFolder $folder, array $messages)
{
return $this->createQueryBuilder('eu')->leftJoin('eu.email', 'email')->andWhere('email.messageId IN (:messageIds)')->andWhere('eu.origin IN (:origin)')->setParameter('messageIds', $messages)->setParameter('origin', $folder->getOrigin())->getQuery()->getResult();
}
/**
* @param Folder $srcFolder
*
* @return EmailFolderModel
*/
protected function createEmailFolderModel(Folder $srcFolder, $uidValidity)
{
$folder = new EmailFolder();
$folder->setFullName($srcFolder->getGlobalName())->setName($srcFolder->getLocalName())->setType($srcFolder->guessFolderType())->setOrigin($this->origin);
$emailFolderModel = new EmailFolderModel();
$emailFolderModel->setUidValidity($uidValidity);
$emailFolderModel->setEmailFolder($folder);
return $emailFolderModel;
}
public function __construct($id = null)
{
parent::__construct();
$this->id = $id;
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testPersist()
{
$origin = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailOrigin')->getMock();
$origin->expects($this->any())->method('getId')->will($this->returnValue(1));
$folder = new EmailFolder();
$folder->setName('Exist');
$folder->setFullName('Exist');
$folder->setOrigin($origin);
$this->batch->addFolder($folder);
$newFolder = new EmailFolder();
$newFolder->setName('New');
$newFolder->setFullName('New');
$newFolder->setOrigin($origin);
$this->batch->addFolder($newFolder);
$dbFolder = new EmailFolder();
$dbFolder->setName('DbExist');
$dbFolder->setFullName('DbExist');
$dbFolder->setOrigin($origin);
$addr = $this->addrManager->newEmailAddress()->setEmail('Exist');
$this->batch->addAddress($addr);
$newAddr = $this->addrManager->newEmailAddress()->setEmail('New');
$this->batch->addAddress($newAddr);
$dbAddr = $this->addrManager->newEmailAddress()->setEmail('DbExist');
$email1 = new Email();
$email1->setXMessageId('email1');
$email1->setMessageId('email1');
$email1->setFromEmailAddress($addr);
$emailUser1 = new EmailUser();
$emailUser1->addFolder($folder);
$emailUser1->setOrigin($origin);
$email1->addEmailUser($emailUser1);
$this->addEmailRecipient($email1, $addr);
$this->addEmailRecipient($email1, $newAddr);
$this->batch->addEmailUser($emailUser1);
$email2 = new Email();
$email2->setXMessageId('email2');
$email2->setMessageId('email2');
$email2->setFromEmailAddress($newAddr);
$emailUser2 = new EmailUser();
$emailUser2->addFolder($newFolder);
$emailUser2->setOrigin($origin);
$email2->addEmailUser($emailUser2);
$this->addEmailRecipient($email2, $addr);
$this->addEmailRecipient($email2, $newAddr);
$this->batch->addEmailUser($emailUser2);
$email3 = new Email();
$email3->setXMessageId('email3');
$email3->setMessageId('some_email');
$email3->setFromEmailAddress($newAddr);
$emailUser3 = new EmailUser();
$emailUser3->addFolder($folder);
$email3->addEmailUser($emailUser3);
$this->addEmailRecipient($email3, $addr);
$this->addEmailRecipient($email3, $newAddr);
$this->batch->addEmailUser($emailUser3);
$email4 = new Email();
$email4->setXMessageId('email4');
$email4->setMessageId('some_email');
$email4->setFromEmailAddress($newAddr);
$emailUser4 = new EmailUser();
$emailUser4->addFolder($folder);
$email4->addEmailUser($emailUser4);
$this->addEmailRecipient($email4, $addr);
$this->addEmailRecipient($email4, $newAddr);
$this->batch->addEmailUser($emailUser4);
$existingEmail = new Email();
$existingEmail->setXMessageId('existing_email');
$existingEmail->setMessageId('some_email');
$existingEmail->setFromEmailAddress($newAddr);
$emailUser5 = new EmailUser();
$emailUser5->addFolder($dbFolder);
$existingEmail->addEmailUser($emailUser5);
$this->addEmailRecipient($existingEmail, $addr);
$this->addEmailRecipient($existingEmail, $newAddr);
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$folderRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$addrRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$emailRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$em->expects($this->exactly(3))->method('getRepository')->will($this->returnValueMap(array(array('OroEmailBundle:EmailFolder', $folderRepo), array('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailAddressProxy', $addrRepo), array('OroEmailBundle:Email', $emailRepo))));
$folderRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbFolder) {
return $c['fullName'] === 'Exist' ? $dbFolder : null;
}));
$addrRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbAddr) {
return $c['email'] === 'Exist' ? $dbAddr : null;
}));
$emailRepo->expects($this->once())->method('findBy')->with(array('messageId' => array('email1', 'email2', 'some_email')))->will($this->returnValue([$existingEmail]));
$owner = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailOwnerInterface');
$this->ownerProvider->expects($this->any())->method('findEmailOwner')->will($this->returnValue($owner));
$this->batch->persist($em);
$this->assertCount(1, $email1->getEmailUsers());
$this->assertCount(1, $email2->getEmailUsers());
$this->assertTrue($origin === $emailUser1->getOrigin());
$this->assertTrue($origin === $emailUser2->getOrigin());
$this->assertSame($newFolder, $emailUser2->getFolders()->first());
$this->assertSame($dbFolder, $emailUser1->getFolders()->first());
$this->assertTrue($dbAddr === $email1->getFromEmailAddress());
$this->assertNull($email1->getFromEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2->getFromEmailAddress());
$this->assertTrue($owner === $email2->getFromEmailAddress()->getOwner());
$email1Recipients = $email1->getRecipients();
$this->assertTrue($dbAddr === $email1Recipients[0]->getEmailAddress());
$this->assertNull($email1Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email1Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email1Recipients[1]->getEmailAddress()->getOwner());
$email2Recipients = $email2->getRecipients();
$this->assertTrue($dbAddr === $email2Recipients[0]->getEmailAddress());
$this->assertNull($email2Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email2Recipients[1]->getEmailAddress()->getOwner());
$changes = $this->batch->getChanges();
$this->assertCount(3, $changes);
$this->assertSame($folder, $changes[0]['old']);
$this->assertSame($dbFolder, $changes[0]['new']);
$this->assertSame($email3, $changes[1]['old']);
$this->assertSame($existingEmail, $changes[1]['new']);
$this->assertSame($email4, $changes[2]['old']);
$this->assertSame($existingEmail, $changes[2]['new']);
}
/**
* Create EmailFolder entity object
*
* @param string $type The folder type. Can be inbox, sent, trash, drafts or other
* @param string $fullName The full name of a folder
* @param string $name The folder name
* @return EmailFolder
*/
protected function folder($type, $fullName, $name)
{
$result = $this->batch->getFolder($type, $fullName);
if ($result === null) {
$result = new EmailFolder();
$result->setType($type)->setFullName($fullName)->setName($name);
$this->batch->addFolder($result);
}
return $result;
}
/**
* @dataProvider supportedMethods
*/
public function testProcessValidData($method)
{
$this->request->setMethod($method);
$this->model->setFrom('*****@*****.**')->setTo(array('*****@*****.**'))->setSubject('testSubject')->setBody('testBody');
$this->form->expects($this->once())->method('setData')->with($this->model);
$this->form->expects($this->once())->method('submit')->with($this->request);
$this->form->expects($this->once())->method('isValid')->will($this->returnValue(true));
$message = new \Swift_Message();
$this->mailer->expects($this->once())->method('createMessage')->will($this->returnValue($message));
$this->mailer->expects($this->once())->method('send')->will($this->returnValue(1));
$origin = new InternalEmailOrigin();
$folder = new EmailFolder();
$folder->setType(EmailFolder::SENT);
$origin->addFolder($folder);
$emailOriginRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$emailOriginRepo->expects($this->once())->method('findOneBy')->with(array('name' => InternalEmailOrigin::BAP))->will($this->returnValue($origin));
$this->em->expects($this->once())->method('getRepository')->with('OroEmailBundle:InternalEmailOrigin')->will($this->returnValue($emailOriginRepo));
$this->emailEntityBuilder->expects($this->once())->method('setOrigin')->with($this->identicalTo($origin));
$email = new EmailEntity();
$this->emailEntityBuilder->expects($this->once())->method('email')->with('testSubject', '*****@*****.**', array('*****@*****.**'))->will($this->returnValue($email));
$body = new EmailBody();
$this->emailEntityBuilder->expects($this->once())->method('body')->with('testBody', false, true)->will($this->returnValue($body));
$batch = $this->getMock('Oro\\Bundle\\EmailBundle\\Builder\\EmailEntityBatchInterface');
$this->emailEntityBuilder->expects($this->once())->method('getBatch')->will($this->returnValue($batch));
$batch->expects($this->once())->method('persist')->with($this->identicalTo($this->em));
$this->em->expects($this->once())->method('flush');
$this->assertTrue($this->handler->process($this->model));
$this->assertNotNull($message);
$this->assertEquals(array('*****@*****.**' => null), $message->getFrom());
$this->assertEquals(array('*****@*****.**' => null), $message->getTo());
$this->assertEquals('testSubject', $message->getSubject());
$this->assertEquals('testBody', $message->getBody());
$this->assertTrue($folder === $email->getFolder());
$this->assertTrue($body === $email->getEmailBody());
}
/**
* @param string $folderName
* @param string $folderFullName
* @param int $uidValidity
* @param int|null $id
*
* @return ImapEmailFolder
*/
protected function createImapFolder($folderName, $folderFullName, $uidValidity, $id = null)
{
$folder = new EmailFolder();
$folder->setName($folderName)->setFullName($folderFullName);
$imapFolder = new ImapEmailFolder();
$imapFolder->setFolder($folder)->setUidValidity($uidValidity);
if ($id !== null) {
ReflectionUtil::setId($imapFolder, $id);
}
return $imapFolder;
}
/**
* Register EmailFolder object
*
* @param EmailFolder $obj
* @throws \LogicException
*/
public function addFolder(EmailFolder $obj)
{
$key = strtolower(sprintf('%s_%s', $obj->getType(), $obj->getFullName()));
if (isset($this->folders[$key])) {
throw new \LogicException(sprintf('The folder "%s" (type: %s) already exists in the batch.', $obj->getFullName(), $obj->getType()));
}
$this->folders[$key] = $obj;
}
/**
* Get email ids and create iterator
*
* @param EmailOrigin $origin
* @param ImapEmailFolder $imapFolder
* @param EmailFolder $folder
*
* @return ImapEmailIterator
*/
protected function getEmailIterator(EmailOrigin $origin, ImapEmailFolder $imapFolder, EmailFolder $folder)
{
if ($origin->getMailbox()) {
// build search query for emails sync
$sqb = $this->manager->getSearchQueryBuilder();
if ($origin->getSynchronizedAt() && $folder->getSynchronizedAt()) {
if ($folder->getType() === FolderType::SENT) {
$sqb->sent($folder->getSynchronizedAt());
} else {
$sqb->received($folder->getSynchronizedAt());
}
}
$searchQuery = $sqb->get();
$this->logger->info(sprintf('Loading emails from "%s" folder ...', $folder->getFullName()));
$this->logger->info(sprintf('Query: "%s".', $searchQuery->convertToSearchString()));
$emails = $this->manager->getEmails($searchQuery);
} else {
$lastUid = $this->em->getRepository('OroImapBundle:ImapEmail')->findLastUidByFolder($imapFolder);
$this->logger->info(sprintf('Previous max email UID "%s"', $lastUid));
$emails = $this->manager->getEmailsUidBased(sprintf('%s:*', ++$lastUid));
}
return $emails;
}
/**
* @param User $emailOwner
* @param OrganizationInterface $organization
*
* @return InternalEmailOrigin
*/
protected function createUserInternalOrigin(User $emailOwner, OrganizationInterface $organization = null)
{
$organization = $organization ? $organization : $emailOwner->getOrganization();
$originName = InternalEmailOrigin::BAP . '_User_' . $emailOwner->getId();
$outboxFolder = new EmailFolder();
$outboxFolder->setType(FolderType::SENT)->setName(FolderType::SENT)->setFullName(FolderType::SENT);
$origin = new InternalEmailOrigin();
$origin->setName($originName)->addFolder($outboxFolder)->setOwner($emailOwner)->setOrganization($organization);
$emailOwner->addEmailOrigin($origin);
$this->getEntityManager()->persist($origin);
$this->getEntityManager()->persist($emailOwner);
return $origin;
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testPersist()
{
$origin = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailOrigin')->getMock();
$origin->expects($this->any())->method('getId')->will($this->returnValue(1));
$this->batch->addOrigin($origin);
$folder = new EmailFolder();
$folder->setName('Exist');
$folder->setFullName('Exist');
$folder->setOrigin($origin);
$this->batch->addFolder($folder);
$newFolder = new EmailFolder();
$newFolder->setName('New');
$newFolder->setFullName('New');
$newFolder->setOrigin($origin);
$this->batch->addFolder($newFolder);
$dbFolder = new EmailFolder();
$dbFolder->setName('DbExist');
$dbFolder->setFullName('DbExist');
$dbFolder->setOrigin($origin);
$addr = $this->addrManager->newEmailAddress()->setEmail('Exist');
$this->batch->addAddress($addr);
$newAddr = $this->addrManager->newEmailAddress()->setEmail('New');
$this->batch->addAddress($newAddr);
$dbAddr = $this->addrManager->newEmailAddress()->setEmail('DbExist');
$email1 = new Email();
$email1->setFolder($folder);
$email1->setFromEmailAddress($addr);
$email1Recip1 = new EmailRecipient();
$email1Recip1->setEmailAddress($addr);
$email1Recip2 = new EmailRecipient();
$email1Recip2->setEmailAddress($newAddr);
$email1->addRecipient($email1Recip1);
$email1->addRecipient($email1Recip2);
$this->batch->addEmail($email1);
$email2 = new Email();
$email2->setFolder($newFolder);
$email2->setFromEmailAddress($newAddr);
$email2Recip1 = new EmailRecipient();
$email2Recip1->setEmailAddress($addr);
$email2Recip2 = new EmailRecipient();
$email2Recip2->setEmailAddress($newAddr);
$email2->addRecipient($email2Recip1);
$email2->addRecipient($email2Recip2);
$this->batch->addEmail($email2);
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$folderRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$addrRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$em->expects($this->exactly(2))->method('getRepository')->will($this->returnValueMap(array(array('OroEmailBundle:EmailFolder', $folderRepo), array('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailAddressProxy', $addrRepo))));
$folderRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbFolder) {
return $c['fullName'] === 'Exist' ? $dbFolder : null;
}));
$addrRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbAddr) {
return $c['email'] === 'Exist' ? $dbAddr : null;
}));
$em->expects($this->exactly(4))->method('persist')->with($this->logicalOr($this->identicalTo($newFolder), $this->identicalTo($newAddr), $this->identicalTo($email1), $this->identicalTo($email2)));
$owner = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailOwnerInterface');
$this->ownerProvider->expects($this->any())->method('findEmailOwner')->will($this->returnValue($owner));
$this->batch->persist($em);
$this->assertTrue($origin === $email1->getFolder()->getOrigin());
$this->assertTrue($origin === $email2->getFolder()->getOrigin());
$this->assertTrue($dbFolder === $email1->getFolder());
$this->assertTrue($newFolder === $email2->getFolder());
$this->assertTrue($dbAddr === $email1->getFromEmailAddress());
$this->assertNull($email1->getFromEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2->getFromEmailAddress());
$this->assertTrue($owner === $email2->getFromEmailAddress()->getOwner());
$email1Recipients = $email1->getRecipients();
$this->assertTrue($dbAddr === $email1Recipients[0]->getEmailAddress());
$this->assertNull($email1Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email1Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email1Recipients[1]->getEmailAddress()->getOwner());
$email2Recipients = $email2->getRecipients();
$this->assertTrue($dbAddr === $email2Recipients[0]->getEmailAddress());
$this->assertNull($email2Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email2Recipients[1]->getEmailAddress()->getOwner());
}