public static function setUpBeforeClass()
{
parent::setUpBeforeClass();
SecurityTestHelper::createSuperAdmin();
self::$emailHelperSendEmailThroughTransport = Yii::app()->emailHelper->sendEmailThroughTransport;
static::$userpsg = UserTestHelper::createBasicUser('userpsg');
static::$usercstmsmtp = UserTestHelper::createBasicUser('usercstmsmtp');
static::$basicuser = UserTestHelper::createBasicUser('basicuser');
static::$bothSGandCstmUser = UserTestHelper::createBasicUser('bothSGandCstmUser');
$someoneSuper = UserTestHelper::createBasicUser('someoneSuper');
$group = Group::getByName('Super Administrators');
$group->users->add($someoneSuper);
$saved = $group->save();
assert($saved);
// Not Coding Standard
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
if (EmailMessageTestHelper::isSetEmailAccountsTestConfiguration()) {
EmailMessageTestHelper::createEmailAccountForMailerFactory(static::$usercstmsmtp);
EmailMessageTestHelper::createEmailAccountForMailerFactory(static::$bothSGandCstmUser);
}
SendGrid::register_autoloader();
Smtpapi::register_autoloader();
if (SendGridTestHelper::isSetSendGridAccountTestConfiguration()) {
SendGridTestHelper::createSendGridEmailAccount(static::$userpsg);
SendGridTestHelper::createSendGridEmailAccount(static::$bothSGandCstmUser);
Yii::app()->sendGridEmailHelper->apiUsername = Yii::app()->params['emailTestAccounts']['sendGridGlobalSettings']['apiUsername'];
Yii::app()->sendGridEmailHelper->apiPassword = Yii::app()->params['emailTestAccounts']['sendGridGlobalSettings']['apiPassword'];
Yii::app()->sendGridEmailHelper->setApiSettings();
Yii::app()->sendGridEmailHelper->init();
}
// Delete item from jobQueue, that is created when new user is created
Yii::app()->jobQueue->deleteAll();
}
/**
* Testing that each model type can render properly and does not throw an exception
*/
public function testRenderSummaryContentWithEmailMessage()
{
$super = User::getByUsername('super');
$billy = User::getByUsername('billy');
$this->assertEquals(0, EmailMessage::getCount());
$emailMessage = new EmailMessage();
$emailMessage->owner = BaseControlUserConfigUtil::getUserToRunAs();
$emailMessage->subject = 'My First Email';
//Set sender, and recipient, and content
$emailContent = new EmailMessageContent();
$emailContent->textContent = 'My First Message';
$emailContent->htmlContent = 'Some fake HTML content';
$emailMessage->content = $emailContent;
//Sending from the system, does not have a 'person'.
$sender = new EmailMessageSender();
$sender->fromAddress = '*****@*****.**';
$sender->fromName = 'Zurmo System';
$sender->personsOrAccounts->add($super);
$emailMessage->sender = $sender;
//Recipient is billy.
$recipient = new EmailMessageRecipient();
$recipient->toAddress = '*****@*****.**';
$recipient->toName = 'Billy James';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$recipient->personsOrAccounts->add($billy);
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
$saved = $emailMessage->save();
$this->assertTrue($saved);
$content = ActivitiesUtil::renderSummaryContent($emailMessage, 'someUrl', LatestActivitiesConfigurationForm::OWNED_BY_FILTER_ALL, 'HomeModule');
$content = ActivitiesUtil::renderSummaryContent($emailMessage, 'someUrl', LatestActivitiesConfigurationForm::OWNED_BY_FILTER_USER, 'HomeModule');
$content = ActivitiesUtil::renderSummaryContent($emailMessage, 'someUrl', LatestActivitiesConfigurationForm::OWNED_BY_FILTER_ALL, 'UserModule');
$content = ActivitiesUtil::renderSummaryContent($emailMessage, 'someUrl', LatestActivitiesConfigurationForm::OWNED_BY_FILTER_USER, 'UserModule');
}
public static function createDraftSendGridSystemEmail($subject, User $owner)
{
$emailMessage = new EmailMessage();
$emailMessage->owner = $owner;
$emailMessage->subject = $subject;
//Set sender, and recipient, and content
$emailContent = new EmailMessageContent();
$emailContent->textContent = 'My First Message';
$emailContent->htmlContent = 'Some fake HTML content';
$emailMessage->content = $emailContent;
//Sending from the system, does not have a 'person'.
$sender = new EmailMessageSender();
$sender->fromAddress = '*****@*****.**';
$sender->fromName = 'Zurmo System';
$emailMessage->sender = $sender;
//Recipient is billy.
$recipient = new EmailMessageRecipient();
$recipient->toAddress = '*****@*****.**';
$recipient->toName = 'Billy James';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
//Save, at this point the email should be in the draft folder
$saved = $emailMessage->save();
if (!$saved) {
throw new NotSupportedException();
}
return $emailMessage;
}
/**
* Given post data and an email message, populate the sender and account on the email message if possible.
* Also add message recipients and any attachments.
* @param array $postData
* @param EmailMessage $emailMessage
* @param User $userToSendMessagesFrom
* @return boolean
*/
public static function resolveEmailMessageFromPostData(array &$postData, CreateEmailMessageForm $emailMessageForm, User $userToSendMessagesFrom)
{
$postVariableName = get_class($emailMessageForm);
Yii::app()->emailHelper->loadOutboundSettingsFromUserEmailAccount($userToSendMessagesFrom);
$toRecipients = explode(",", $postData[$postVariableName]['recipientsData']['to']);
// Not Coding Standard
static::attachRecipientsToMessage($toRecipients, $emailMessageForm->getModel(), EmailMessageRecipient::TYPE_TO);
if (ArrayUtil::getArrayValue($postData[$postVariableName]['recipientsData'], 'cc') != null) {
$ccRecipients = explode(",", $postData[$postVariableName]['recipientsData']['cc']);
// Not Coding Standard
static::attachRecipientsToMessage($ccRecipients, $emailMessageForm->getModel(), EmailMessageRecipient::TYPE_CC);
}
if (ArrayUtil::getArrayValue($postData[$postVariableName]['recipientsData'], 'bcc') != null) {
$bccRecipients = explode(",", $postData[$postVariableName]['recipientsData']['bcc']);
// Not Coding Standard
static::attachRecipientsToMessage($bccRecipients, $emailMessageForm->getModel(), EmailMessageRecipient::TYPE_BCC);
}
if (isset($postData['filesIds'])) {
static::attachFilesToMessage($postData['filesIds'], $emailMessageForm->getModel());
}
$emailAccount = EmailAccount::getByUserAndName($userToSendMessagesFrom);
$sender = new EmailMessageSender();
$sender->fromName = Yii::app()->emailHelper->fromName;
$sender->fromAddress = Yii::app()->emailHelper->fromAddress;
$sender->personOrAccount = $userToSendMessagesFrom;
$emailMessageForm->sender = $sender;
$emailMessageForm->account = $emailAccount;
$emailMessageForm->content->textContent = EmailMessageUtil::resolveTextContent(ArrayUtil::getArrayValue($postData[$postVariableName]['content'], 'htmlContent'), null);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessageForm->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX);
return $emailMessageForm;
}
public function testRun()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$outboxFolder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX);
$sentFolder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_SENT);
$emailMessage = EmailMessageTestHelper::createDraftSystemEmail('My Email Message', $super);
$emailMessage->folder = $outboxFolder;
$saved = $emailMessage->save();
$this->assertTrue($saved);
$emailMessageId = $emailMessage->id;
$emailMessage->forget();
unset($emailMessage);
$emailMessage2 = EmailMessageTestHelper::createDraftSystemEmail('My Email Message', $super);
$emailMessage2->folder = $outboxFolder;
$saved = $emailMessage2->save();
$this->assertTrue($saved);
$emailMessage2Id = $emailMessage2->id;
$emailMessage2->forget();
unset($emailMessage2);
$this->assertEquals(2, EmailMessage::getCount());
$job = new ProcessOutboundEmailJob();
$this->assertTrue($job->run());
$emailMessages = EmailMessage::getAll();
$this->assertEquals(2, count($emailMessages));
$emailMessage = EmailMessage::getById($emailMessageId);
$this->assertEquals($sentFolder, $emailMessage->folder);
$emailMessage2 = EmailMessage::getById($emailMessage2Id);
$this->assertEquals($sentFolder, $emailMessage2->folder);
}
public static function setUpBeforeClass()
{
parent::setUpBeforeClass();
SecurityTestHelper::createSuperAdmin();
AllPermissionsOptimizationUtil::rebuild();
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
}
public function testRun()
{
$quote = DatabaseCompatibilityUtil::getQuote();
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_SENT);
//Create 2 sent notifications, and set one with a date over a week ago (8 days ago) for the modifiedDateTime
$emailMessage = EmailMessageTestHelper::createDraftSystemEmail('My Email Message', $super);
$emailMessage->folder = $folder;
$saved = $emailMessage->save();
$this->assertTrue($saved);
$modifiedDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime(time() - 60 * 60 * 24 * 8);
$sql = "Update item set modifieddatetime = '" . $modifiedDateTime . "' where id = " . $emailMessage->getClassId('Item');
ZurmoRedBean::exec($sql);
$emailMessage2 = EmailMessageTestHelper::createDraftSystemEmail('My Email Message 2', $super);
$emailMessage2->folder = $folder;
$saved = $emailMessage2->save();
$this->assertTrue($saved);
$this->assertEquals(2, EmailMessage::getCount());
$job = new ClearSentNotificationsEmailJob();
$this->assertTrue($job->run());
$emailMessages = EmailMessage::getAll();
$this->assertEquals(1, count($emailMessages));
$this->assertEquals($emailMessage2->id, $emailMessages[0]->id);
}
/**
* A notification email is different than a regular outbound email because it is owned by a super user
* that is different than the user logged in. So the sender does not have a 'person'
*/
public function testCreateEmailMessageThatIsANotification()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$billy = User::getByUsername('billy');
$this->assertEquals(0, EmailMessage::getCount());
$emailMessage = new EmailMessage();
$emailMessage->owner = BaseControlUserConfigUtil::getUserToRunAs();
$emailMessage->subject = 'My First Email';
//Set sender, and recipient, and content
$emailContent = new EmailMessageContent();
$emailContent->textContent = 'My First Message';
$emailContent->htmlContent = 'Some fake HTML content';
$emailMessage->content = $emailContent;
//Sending from the system, does not have a 'person'.
$sender = new EmailMessageSender();
$sender->fromAddress = '*****@*****.**';
$sender->fromName = 'Zurmo System';
$emailMessage->sender = $sender;
//Recipient is billy.
$recipient = new EmailMessageRecipient();
$recipient->toAddress = '*****@*****.**';
$recipient->toName = 'Billy James';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$recipient->personsOrAccounts->add($billy);
$emailMessage->recipients->add($recipient);
//At this point the message is in no folder
$this->assertTrue($emailMessage->folder->id < 0);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
//Save, at this point the email should be in the draft folder
$saved = $emailMessage->save();
$this->assertTrue($saved);
$this->assertTrue($emailMessage->folder->id > 0);
$this->assertEquals(0, EmailMessageSendError::getCount());
$emailMessageSendError = new EmailMessageSendError();
$data = array();
$data['message'] = 'error message';
$emailMessageSendError->serializedData = serialize($data);
$emailMessage->folder = EmailFolder::getByBoxAndType($emailMessage->folder->emailBox, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->error = $emailMessageSendError;
$saved = $emailMessage->save();
$this->assertTrue($saved);
$this->assertEquals(1, EmailMessageSendError::getCount());
//Now swap the error with a new one
$emailMessageId = $emailMessage->id;
$emailMessage->forget();
$emailMessage = EmailMessage::getById($emailMessageId);
$emailMessageSendError = new EmailMessageSendError();
$data = array();
$data['message'] = 'error message 2';
$emailMessageSendError->serializedData = serialize($data);
$emailMessage->error = $emailMessageSendError;
$saved = $emailMessage->save();
$this->assertTrue($saved);
$this->assertEquals(1, EmailMessageSendError::getCount());
}
public function resolveSearchAttributeDataForAllLatestActivities($searchAttributeData)
{
assert('is_array($searchAttributeData)');
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$searchAttributeData = parent::resolveSearchAttributeDataForAllLatestActivities($searchAttributeData);
$clausesCount = count($searchAttributeData['clauses']);
$searchAttributeData['clauses'][$clausesCount + 1] = array('attributeName' => 'folder', 'relatedModelData' => array('attributeName' => 'emailBox', 'operatorType' => 'doesNotEqual', 'value' => $box->id));
if ($searchAttributeData['structure'] != null) {
$searchAttributeData['structure'] .= ' and ';
}
$searchAttributeData['structure'] .= $clausesCount + 1;
return $searchAttributeData;
}
/**
*
* (non-PHPdoc)
* @see BaseJob::run()
*/
public function run()
{
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$oneWeekAgoTimeStamp = DateTimeUtil::convertTimestampToDbFormatDateTime(time() - 60 * 60 * 24 * 7);
$searchAttributeData = array();
$searchAttributeData['clauses'] = array(1 => array('attributeName' => 'modifiedDateTime', 'operatorType' => 'lessThan', 'value' => $oneWeekAgoTimeStamp), 2 => array('attributeName' => 'folder', 'relatedAttributeName' => 'type', 'operatorType' => 'equals', 'value' => EmailFolder::TYPE_SENT), 3 => array('attributeName' => 'folder', 'relatedAttributeName' => 'emailBox', 'operatorType' => 'equals', 'value' => $box->id));
$searchAttributeData['structure'] = '1 and 2 and 3';
$joinTablesAdapter = new RedBeanModelJoinTablesQueryAdapter('EmailMessage');
$where = RedBeanModelDataProvider::makeWhere('EmailMessage', $searchAttributeData, $joinTablesAdapter);
$emailMessageModels = EmailMessage::getSubset($joinTablesAdapter, null, self::$pageSize, $where, null);
foreach ($emailMessageModels as $emailMessage) {
$emailMessage->delete();
}
return true;
}
/**
* @throws MissingRecipientsForEmailMessageException
*/
public function process()
{
$emailTemplate = EmailTemplate::getById((int) $this->emailMessageForm->emailTemplateId);
$emailMessage = new EmailMessage();
$emailMessage->owner = $this->triggeredByUser;
$emailMessage->subject = $this->resolveEmailTemplateSubjectForModelData($emailTemplate);
$emailContent = new EmailMessageContent();
$emailContent->textContent = $this->resolveEmailTemplateTextContentForModelData($emailTemplate);
$emailContent->htmlContent = $this->resolveEmailTemplateHtmlContentForModelData($emailTemplate);
$emailMessage->content = $emailContent;
$emailMessage->sender = $this->resolveSender();
$this->resolveRecipients($emailMessage);
if ($emailMessage->recipients->count() == 0) {
throw new MissingRecipientsForEmailMessageException();
}
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
Yii::app()->emailHelper->send($emailMessage);
}
public function testExportRelationAttributes()
{
$report = new Report();
$report->setType(Report::TYPE_ROWS_AND_COLUMNS);
$report->setModuleClassName('EmailMessagesModule');
$report->setFiltersStructure('');
$emailMessage = new EmailMessage();
$emailMessage->owner = Yii::app()->user->userModel;
$emailMessage->subject = 'A test email';
$emailContent = new EmailMessageContent();
$emailContent->textContent = 'A test text message from Zurmo.';
$emailContent->htmlContent = 'A test text message from Zurmo.';
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = '*****@*****.**';
$sender->fromName = 'super';
$sender->personsOrAccounts->add(Yii::app()->user->userModel);
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = '*****@*****.**';
$recipient->toName = 'Test Recipient';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_SENT);
$this->assertTrue($emailMessage->save());
$displayAttribute1 = new DisplayAttributeForReportForm('EmailMessagesModule', 'EmailMessage', Report::TYPE_ROWS_AND_COLUMNS);
$displayAttribute1->setModelAliasUsingTableAliasName('relatedModel');
$displayAttribute1->attributeIndexOrDerivedType = 'sender___User__personsOrAccounts__Inferred___firstName';
$report->addDisplayAttribute($displayAttribute1);
$displayAttribute2 = new DisplayAttributeForReportForm('EmailMessagesModule', 'EmailMessage', Report::TYPE_ROWS_AND_COLUMNS);
$displayAttribute2->setModelAliasUsingTableAliasName('relatedModel');
$displayAttribute2->attributeIndexOrDerivedType = 'sender___Contact__personsOrAccounts__Inferred___firstName';
$report->addDisplayAttribute($displayAttribute2);
$dataProvider = new RowsAndColumnsReportDataProvider($report);
$adapter = ReportToExportAdapterFactory::createReportToExportAdapter($report, $dataProvider);
$compareHeaderData = array('Sender >> Users >> First Name', 'Sender >> Contacts >> First Name');
$compareRowData = array(array('Clark', ''));
$this->assertEquals($compareHeaderData, $adapter->getHeaderData());
$this->assertEquals($compareRowData, $adapter->getData());
}
/**
*
* (non-PHPdoc)
* @see BaseJob::run()
*/
public function run()
{
$messageContent = null;
$userToSendMessagesFrom = BaseControlUserConfigUtil::getUserToRunAs();
$emailMessage = new EmailMessage();
$emailMessage->owner = Yii::app()->user->userModel;
$emailMessage->subject = Zurmo::t('EmailMessagesModule', 'A test email from Zurmo', LabelUtil::getTranslationParamsForAllModules());
$emailContent = new EmailMessageContent();
$emailContent->textContent = Zurmo::t('EmailMessagesModule', 'A test text message from Zurmo.', LabelUtil::getTranslationParamsForAllModules());
$emailContent->htmlContent = Zurmo::t('EmailMessagesModule', 'A test text message from Zurmo.', LabelUtil::getTranslationParamsForAllModules());
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom);
$sender->fromName = Yii::app()->emailHelper->resolveFromNameForSystemUser($userToSendMessagesFrom);
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = Yii::app()->emailHelper->defaultTestToAddress;
$recipient->toName = 'Test Recipient';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
$validatedAndSaved = $emailMessage->save();
if (!$validatedAndSaved) {
throw new NotSupportedException();
}
Yii::app()->emailHelper->sendImmediately($emailMessage);
if (!$emailMessage->hasSendError()) {
$messageContent .= Zurmo::t('EmailMessagesModule', 'Message successfully sent') . "\n";
return true;
} else {
$messageContent .= Zurmo::t('EmailMessagesModule', 'Message failed to send') . "\n";
$messageContent .= $emailMessage->error . "\n";
$this->errorMessage = $messageContent;
return false;
}
}
/**
* @depends testSendRealEmail
*/
public function testTooManySendAttemptsResultingInFailure()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
if (EmailMessageTestHelper::isSetEmailAccountsTestConfiguration()) {
//add a message in the outbox_error folder.
$emailMessage = EmailMessageTestHelper::createDraftSystemEmail('a test email 2', $this->user);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->sendAttempts = 5;
$emailMessage->save();
$this->assertEquals(1, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(7, Yii::app()->emailHelper->getSentCount());
Yii::app()->emailHelper->sendQueued();
$this->assertEquals(0, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(7, Yii::app()->emailHelper->getSentCount());
$this->assertTrue($emailMessage->folder->isSame(EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_FAILURE)));
} else {
$this->markTestSkipped();
}
}
/**
* @param Conversation $conversation
* @param $person
*/
public static function sendEmailInviteToParticipant(Conversation $conversation, $person)
{
assert('$conversation->id > 0');
assert('$person instanceof User || $person instanceof Contact');
if ($person->primaryEmail->emailAddress !== null) {
$userToSendMessagesFrom = $conversation->owner;
$emailMessage = new EmailMessage();
$emailMessage->owner = Yii::app()->user->userModel;
$emailMessage->subject = Zurmo::t('ConversationsModule', 'You have been invited to participate in a conversation');
$emailContent = new EmailMessageContent();
$emailContent->textContent = EmailNotificationUtil::resolveNotificationTextTemplate(static::getParticipantInviteEmailTextContent($conversation));
$emailContent->htmlContent = EmailNotificationUtil::resolveNotificationHtmlTemplate(static::getParticipantInviteEmailHtmlContent($conversation));
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom);
$sender->fromName = strval($userToSendMessagesFrom);
$sender->personsOrAccounts->add($userToSendMessagesFrom);
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = $person->primaryEmail->emailAddress;
$recipient->toName = strval($person);
$recipient->type = EmailMessageRecipient::TYPE_TO;
$recipient->personsOrAccounts->add($person);
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
try {
Yii::app()->emailHelper->send($emailMessage);
} catch (CException $e) {
//Not sure what to do yet when catching an exception here. Currently ignoring gracefully.
}
}
}
protected static function resolveEmailMessage(EmailTemplate $emailTemplate, Contact $contact = null, $htmlContent, $emailAddress = null)
{
// TODO: @Shoaibi: Critical: Refactor this and AutoresponderAndCampaignItemsUtil
$emailMessage = new EmailMessage();
$emailMessage->subject = $emailTemplate->subject;
$emailContent = new EmailMessageContent();
$emailContent->textContent = $emailTemplate->textContent;
// we do not need to do : EmailTemplateSerializedDataToHtmlUtil::resolveHtmlByEmailTemplateModel($emailTemplate);
// check __set of EmailTemplate.
$emailContent->htmlContent = $htmlContent;
$emailMessage->content = $emailContent;
$emailMessage->sender = static::resolveSender();
static::resolveRecipient($emailMessage, $contact, $emailAddress);
$box = EmailBox::resolveAndGetByName(EmailBox::USER_DEFAULT_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
Yii::app()->emailHelper->sendImmediately($emailMessage);
$emailMessage->owner = $emailTemplate->owner;
$explicitReadWriteModelPermissions = ExplicitReadWriteModelPermissionsUtil::makeBySecurableItem($emailTemplate);
ExplicitReadWriteModelPermissionsUtil::resolveExplicitReadWriteModelPermissions($emailMessage, $explicitReadWriteModelPermissions);
if (!$emailMessage->save()) {
throw new FailedToSaveModelException("Unable to save EmailMessage");
}
}
protected static function resolveEmailMessage($textContent, $htmlContent, Item $itemOwnerModel, Contact $contact, MarketingList $marketingList, $itemId, $itemClass)
{
$emailMessage = new EmailMessage();
$emailMessage->subject = $itemOwnerModel->subject;
$emailContent = new EmailMessageContent();
$emailContent->textContent = $textContent;
$emailContent->htmlContent = $htmlContent;
$emailMessage->content = $emailContent;
$emailMessage->sender = static::resolveSender($marketingList, $itemOwnerModel);
static::resolveRecipient($emailMessage, $contact);
static::resolveAttachments($emailMessage, $itemOwnerModel);
static::resolveHeaders($emailMessage, $itemId, $itemClass, $contact->getClassId('Person'));
if ($emailMessage->recipients->count() == 0) {
throw new MissingRecipientsForEmailMessageException();
}
$boxName = static::resolveEmailBoxName(get_class($itemOwnerModel));
$box = EmailBox::resolveAndGetByName($boxName);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
Yii::app()->emailHelper->send($emailMessage);
$emailMessage->owner = $marketingList->owner;
$explicitReadWriteModelPermissions = ExplicitReadWriteModelPermissionsUtil::makeBySecurableItem($marketingList);
ExplicitReadWriteModelPermissionsUtil::resolveExplicitReadWriteModelPermissions($emailMessage, $explicitReadWriteModelPermissions);
if (!$emailMessage->save()) {
throw new FailedToSaveModelException("Unable to save EmailMessage");
}
return $emailMessage;
}
/**
* Send task email
* @param Notification $notification
* @param TaskNotificationRules $rule
* @param string $action
*/
protected static function sendTaskEmail(Notification $notification, TaskNotificationRules $rule, $action)
{
assert('is_string($action)');
if ($notification->owner->primaryEmail->emailAddress !== null && !UserConfigurationFormAdapter::resolveAndGetValue($notification->owner, 'turnOffEmailNotifications')) {
$emailMessage = static::makeEmailMessage($notification, $rule, $action);
$emailMessage->content = static::makeEmailContent($notification);
$emailMessage->sender = static::makeSender();
$emailMessage->recipients->add(static::makeRecipient($notification));
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
try {
Yii::app()->emailHelper->send($emailMessage);
} catch (CException $e) {
//Not sure what to do yet when catching an exception here. Currently ignoring gracefully.
}
}
}
/**
* @param User $senderPerson
* @param array $recipients
* @param string $subject
* @param EmailMessageContent $content
*/
public static function resolveAndSendEmail($senderPerson, $recipients, $subject, $content)
{
assert('$senderPerson instanceof User');
assert('is_array($recipients)');
assert('is_string($subject)');
assert('$content instanceof EmailMessageContent');
if (count($recipients) == 0) {
return;
}
$userToSendMessagesFrom = $senderPerson;
$emailMessage = new EmailMessage();
$emailMessage->owner = $senderPerson;
$emailMessage->subject = $subject;
$emailMessage->content = $content;
$sender = new EmailMessageSender();
$sender->fromAddress = Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom);
$sender->fromName = strval($userToSendMessagesFrom);
$sender->personsOrAccounts->add($userToSendMessagesFrom);
$emailMessage->sender = $sender;
foreach ($recipients as $recipientPerson) {
$recipient = new EmailMessageRecipient();
$recipient->toAddress = $recipientPerson->primaryEmail->emailAddress;
$recipient->toName = strval($recipientPerson);
$recipient->type = EmailMessageRecipient::TYPE_TO;
$recipient->personsOrAccounts->add($recipientPerson);
$emailMessage->recipients->add($recipient);
}
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
Yii::app()->emailHelper->send($emailMessage);
}
protected static function sendEmail(Notification $notification, $sendImmediately, NotificationRules $rules)
{
$notificationSettingName = static::resolveNotificationSettingNameFromType($notification->type);
if ($rules->allowSendingEmail() && UserNotificationUtil::isEnabledByUserAndNotificationNameAndType($notification->owner, $notificationSettingName, 'email')) {
if ($notification->owner->primaryEmail->emailAddress != null) {
$emailMessage = static::makeEmailMessage();
$emailMessage->subject = static::getEmailSubject($notification, $rules);
$emailMessage->content = static::makeEmailContent($notification);
$emailMessage->sender = static::makeSender();
$emailMessage->recipients->add(static::makeRecipient($notification));
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
if (!$emailMessage->save()) {
throw new FailedToSaveModelException();
}
try {
if ($sendImmediately) {
Yii::app()->emailHelper->sendImmediately($emailMessage);
} else {
Yii::app()->emailHelper->send($emailMessage);
}
} catch (CException $e) {
//Not sure what to do yet when catching an exception here. Currently ignoring gracefully.
}
}
}
}
protected static function resolveEmailMessage($textContent, $htmlContent, Autoresponder $autoresponder, Contact $contact)
{
$marketingList = $autoresponder->marketingList;
$emailMessage = new EmailMessage();
$emailMessage->owner = $marketingList->owner;
$emailMessage->subject = $autoresponder->subject;
$emailContent = new EmailMessageContent();
$emailContent->textContent = $textContent;
$emailContent->htmlContent = $htmlContent;
$emailMessage->content = $emailContent;
$emailMessage->sender = static::resolveSender($marketingList);
static::resolveRecipient($emailMessage, $contact);
if ($emailMessage->recipients->count() == 0) {
throw new MissingRecipientsForEmailMessageException();
}
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
Yii::app()->emailHelper->send($emailMessage);
return $emailMessage;
}
/**
* @depends testIsSent
*/
public function testHasFailedToSend()
{
$marketingList = MarketingListTestHelper::createMarketingListByName('marketingList 09');
$campaign = CampaignTestHelper::createCampaign('campaign 08', 'subject 08', 'text 08', 'html 08', null, null, null, null, null, null, $marketingList);
$this->assertNotNull($campaign);
$contact = ContactTestHelper::createContactByNameForOwner('campaignContact 09', Yii::app()->user->userModel);
MarketingListMemberTestHelper::createMarketingListMember(0, $marketingList, $contact);
$email = new Email();
$email->emailAddress = '*****@*****.**';
$contact->primaryEmail = $email;
$this->assertTrue($contact->save());
$campaignItem = CampaignItemTestHelper::createCampaignItem(0, $campaign, $contact);
$this->assertNotNull($campaignItem);
$this->assertFalse($campaignItem->hasFailedToSend());
$this->processDueItem($campaignItem);
$this->assertFalse($campaignItem->hasFailedToSend());
// Folder is outbox at the end of processDueItem and hence it fails
$box = EmailBox::resolveAndGetByName(EmailBox::CAMPAIGNS_NAME);
$campaignItem->emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_FAILURE);
$this->assertTrue($campaignItem->unrestrictedSave());
$this->assertTrue($campaignItem->hasFailedToSend());
}
/**
* Execute the action.
* @param array command line parameters specific for this command
*/
public function actionSend($username, $toAddress, $subject = 'A test email from Zurmo', $textContent = 'A test text message from Zurmo.', $htmlContent = 'A test html message from Zurmo.', $host = null, $port = null, $outboundUsername = null, $outboundPassword = null, $outboundSecurity = null)
{
if (!isset($username)) {
$this->usageError('A username must be specified.');
}
if (!isset($toAddress)) {
$this->usageError('You must specify a to address.');
}
try {
Yii::app()->user->userModel = User::getByUsername($username);
} catch (NotFoundException $e) {
$this->usageError('The specified username does not exist.');
}
if ($host != null) {
Yii::app()->emailHelper->outboundHost = $host;
}
if ($port != null) {
Yii::app()->emailHelper->outboundPort = $port;
}
if ($outboundUsername != null) {
Yii::app()->emailHelper->outboundUsername = $outboundUsername;
}
if ($outboundUsername != null) {
Yii::app()->emailHelper->outboundPassword = $outboundPassword;
}
if ($outboundSecurity != null && $outboundSecurity != '' && $outboundSecurity != 'false') {
Yii::app()->emailHelper->outboundSecurity = $outboundSecurity;
} else {
Yii::app()->emailHelper->outboundSecurity = null;
}
echo "\n";
echo 'Using type:' . Yii::app()->emailHelper->outboundType . "\n";
echo 'Using host:' . Yii::app()->emailHelper->outboundHost . "\n";
echo 'Using port:' . Yii::app()->emailHelper->outboundPort . "\n";
echo 'Using username:'******'Using password:'******'Using outbound security:' . Yii::app()->emailHelper->outboundSecurity . "\n\n";
} else {
echo 'Using outbound security: none' . "\n\n";
}
echo 'Sending Email Message' . "\n";
$emailMessage = new EmailMessage();
$emailMessage->owner = BaseJobControlUserConfigUtil::getUserToRunAs();
$emailMessage->subject = $subject;
$emailContent = new EmailMessageContent();
$emailContent->textContent = $textContent;
$emailContent->htmlContent = $htmlContent;
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = Yii::app()->emailHelper->resolveFromAddressByUser(Yii::app()->user->userModel);
$sender->fromName = strval(Yii::app()->user->userModel);
$sender->personOrAccount = Yii::app()->user->userModel;
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = $toAddress;
$recipient->toName = 'Test Recipient';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
$validated = $emailMessage->validate();
if (!$validated) {
$this->addErrorsAsUsageErrors($emailMessage->getErrors());
}
Yii::app()->emailHelper->sendImmediately($emailMessage);
if (!$emailMessage->hasSendError()) {
echo Zurmo::t('Commands', 'Message successfully sent') . "\n";
} else {
echo Zurmo::t('Commands', 'Message failed to send') . "\n";
echo $emailMessage->error . "\n";
}
$saved = $emailMessage->save();
if (!$saved) {
throw new NotSupportedException();
}
}
protected static function sendEmail(Notification $notification)
{
if ($notification->owner->primaryEmail->emailAddress !== null && !UserConfigurationFormAdapter::resolveAndGetValue($notification->owner, 'turnOffEmailNotifications')) {
$userToSendMessagesFrom = BaseControlUserConfigUtil::getUserToRunAs();
$emailMessage = new EmailMessage();
$emailMessage->owner = Yii::app()->user->userModel;
$emailMessage->subject = strval($notification);
$emailContent = new EmailMessageContent();
$emailContent->textContent = EmailNotificationUtil::resolveNotificationTextTemplate($notification->notificationMessage->textContent);
$emailContent->htmlContent = EmailNotificationUtil::resolveNotificationHtmlTemplate($notification->notificationMessage->htmlContent);
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom);
$sender->fromName = strval($userToSendMessagesFrom);
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = $notification->owner->primaryEmail->emailAddress;
$recipient->toName = strval($notification->owner);
$recipient->type = EmailMessageRecipient::TYPE_TO;
$recipient->personsOrAccounts->add($notification->owner);
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
if (!$emailMessage->save()) {
throw new FailedToSaveModelException();
}
try {
Yii::app()->emailHelper->sendImmediately($emailMessage);
} catch (CException $e) {
//Not sure what to do yet when catching an exception here. Currently ignoring gracefully.
}
}
}
/**
* @depends testSend
*/
public function testSendQueued()
{
ZurmoConfigurationUtil::setByModuleName('SendGridModule', 'enableSendgrid', true);
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
//add a message in the outbox_error folder.
$emailMessage = SendGridTestHelper::createDraftSendGridSystemEmail('a test email 2', $super);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->save();
$this->assertEquals(2, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(0, Yii::app()->emailHelper->getSentCount());
Yii::app()->emailHelper->sendQueued();
$this->assertEquals(0, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(2, Yii::app()->emailHelper->getSentCount());
//add a message in the outbox folder.
$emailMessage = SendGridTestHelper::createDraftSendGridSystemEmail('a test email 3', $super);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX);
$emailMessage->save();
//add a message in the outbox_error folder.
$emailMessage = SendGridTestHelper::createDraftSendGridSystemEmail('a test email 4', $super);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->save();
//add a message in the outbox_error folder.
$emailMessage = SendGridTestHelper::createDraftSendGridSystemEmail('a test email 5', $super);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->save();
$this->assertEquals(3, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(2, Yii::app()->emailHelper->getSentCount());
Yii::app()->emailHelper->sendQueued(1);
$this->assertEquals(2, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(3, Yii::app()->emailHelper->getSentCount());
Yii::app()->emailHelper->sendQueued(2);
$this->assertEquals(0, Yii::app()->emailHelper->getQueuedCount());
$this->assertEquals(5, Yii::app()->emailHelper->getSentCount());
}
/**
* @depends testGetByNameNotificationsBoxDoesNotExist
*/
public function testNotificationsBoxResolvesCorrectly()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$boxes = EmailBox::getAll();
$this->assertEquals(0, count($boxes));
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$this->assertEquals(EmailBox::NOTIFICATIONS_NAME, $box->name);
$this->assertEquals(8, $box->folders->count());
$this->assertFalse($box->isDeletable());
$this->assertTrue($box->id > 0);
//After it saves, it should create a Sent folder and an Outbox folder
$box = EmailBox::getByName(EmailBox::NOTIFICATIONS_NAME);
$this->assertEquals(8, $box->folders->count());
$folder1 = $box->folders->offsetGet(0);
$folder2 = $box->folders->offsetGet(1);
$folder3 = $box->folders->offsetGet(2);
$folder4 = $box->folders->offsetGet(3);
$folder5 = $box->folders->offsetGet(4);
$folder6 = $box->folders->offsetGet(5);
$folder7 = $box->folders->offsetGet(6);
$folder8 = $box->folders->offsetGet(7);
$this->assertTrue($folder1->name == EmailFolder::getDefaultInboxName() || $folder1->name == EmailFolder::getDefaultSentName() || $folder1->name == EmailFolder::getDefaultOutboxName() || $folder1->name == EmailFolder::getDefaultDraftName() || $folder1->name == EmailFolder::getDefaultOutboxErrorName() || $folder1->name == EmailFolder::getDefaultOutboxFailureName() || $folder1->name == EmailFolder::getDefaultArchivedName() || $folder1->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder2->name == EmailFolder::getDefaultInboxName() || $folder2->name == EmailFolder::getDefaultSentName() || $folder2->name == EmailFolder::getDefaultOutboxName() || $folder2->name == EmailFolder::getDefaultDraftName() || $folder2->name == EmailFolder::getDefaultOutboxErrorName() || $folder2->name == EmailFolder::getDefaultOutboxFailureName() || $folder2->name == EmailFolder::getDefaultArchivedName() || $folder2->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder3->name == EmailFolder::getDefaultInboxName() || $folder3->name == EmailFolder::getDefaultSentName() || $folder3->name == EmailFolder::getDefaultOutboxName() || $folder3->name == EmailFolder::getDefaultDraftName() || $folder3->name == EmailFolder::getDefaultOutboxErrorName() || $folder3->name == EmailFolder::getDefaultOutboxFailureName() || $folder3->name == EmailFolder::getDefaultArchivedName() || $folder3->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder4->name == EmailFolder::getDefaultInboxName() || $folder4->name == EmailFolder::getDefaultSentName() || $folder4->name == EmailFolder::getDefaultOutboxName() || $folder4->name == EmailFolder::getDefaultDraftName() || $folder4->name == EmailFolder::getDefaultOutboxErrorName() || $folder4->name == EmailFolder::getDefaultOutboxFailureName() || $folder4->name == EmailFolder::getDefaultArchivedName() || $folder4->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder5->name == EmailFolder::getDefaultInboxName() || $folder5->name == EmailFolder::getDefaultSentName() || $folder5->name == EmailFolder::getDefaultOutboxName() || $folder5->name == EmailFolder::getDefaultDraftName() || $folder5->name == EmailFolder::getDefaultOutboxErrorName() || $folder5->name == EmailFolder::getDefaultOutboxFailureName() || $folder5->name == EmailFolder::getDefaultArchivedName() || $folder5->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder6->name == EmailFolder::getDefaultInboxName() || $folder6->name == EmailFolder::getDefaultSentName() || $folder6->name == EmailFolder::getDefaultOutboxName() || $folder6->name == EmailFolder::getDefaultDraftName() || $folder6->name == EmailFolder::getDefaultOutboxErrorName() || $folder6->name == EmailFolder::getDefaultOutboxFailureName() || $folder6->name == EmailFolder::getDefaultArchivedName() || $folder6->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder7->name == EmailFolder::getDefaultInboxName() || $folder7->name == EmailFolder::getDefaultSentName() || $folder7->name == EmailFolder::getDefaultOutboxName() || $folder7->name == EmailFolder::getDefaultDraftName() || $folder7->name == EmailFolder::getDefaultOutboxErrorName() || $folder7->name == EmailFolder::getDefaultOutboxFailureName() || $folder7->name == EmailFolder::getDefaultArchivedName() || $folder7->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertTrue($folder8->name == EmailFolder::getDefaultInboxName() || $folder8->name == EmailFolder::getDefaultSentName() || $folder8->name == EmailFolder::getDefaultOutboxName() || $folder8->name == EmailFolder::getDefaultDraftName() || $folder8->name == EmailFolder::getDefaultOutboxErrorName() || $folder8->name == EmailFolder::getDefaultOutboxFailureName() || $folder8->name == EmailFolder::getDefaultArchivedName() || $folder8->name == EmailFolder::getDefaultArchivedUnmatchedName());
$this->assertNotEquals($folder1->name, $folder2->name);
$this->assertNotEquals($folder1->name, $folder3->name);
$this->assertNotEquals($folder1->name, $folder4->name);
$this->assertNotEquals($folder1->name, $folder5->name);
$this->assertNotEquals($folder1->name, $folder6->name);
$this->assertNotEquals($folder1->name, $folder7->name);
$this->assertNotEquals($folder1->name, $folder8->name);
$this->assertNotEquals($folder2->name, $folder3->name);
$this->assertNotEquals($folder2->name, $folder4->name);
$this->assertNotEquals($folder2->name, $folder5->name);
$this->assertNotEquals($folder2->name, $folder6->name);
$this->assertNotEquals($folder2->name, $folder7->name);
$this->assertNotEquals($folder2->name, $folder8->name);
$this->assertNotEquals($folder3->name, $folder4->name);
$this->assertNotEquals($folder3->name, $folder5->name);
$this->assertNotEquals($folder3->name, $folder6->name);
$this->assertNotEquals($folder3->name, $folder7->name);
$this->assertNotEquals($folder3->name, $folder8->name);
$this->assertNotEquals($folder4->name, $folder5->name);
$this->assertNotEquals($folder4->name, $folder6->name);
$this->assertNotEquals($folder4->name, $folder7->name);
$this->assertNotEquals($folder4->name, $folder8->name);
$this->assertNotEquals($folder5->name, $folder6->name);
$this->assertNotEquals($folder5->name, $folder7->name);
$this->assertNotEquals($folder5->name, $folder8->name);
$this->assertNotEquals($folder6->name, $folder7->name);
$this->assertNotEquals($folder6->name, $folder8->name);
$this->assertNotEquals($folder7->name, $folder8->name);
$boxes = EmailBox::getAll();
$this->assertEquals(1, count($boxes));
$this->assertTrue($boxes[0]->user->id < 0);
}
/**
* Save email message
* This method should be protected, but we made it public for unit testing, so don't call it outside this class.
* @param ImapMessage $message
* @throws NotSupportedException
* @return boolean
*/
public function saveEmailMessage(ImapMessage $message)
{
// Get owner for message
try {
$emailOwner = EmailArchivingUtil::resolveOwnerOfEmailMessage($message);
} catch (CException $e) {
// User not found, so inform user about issue and continue with next email.
$this->resolveMessageSubjectAndContentAndSendSystemMessage('OwnerNotExist', $message);
return false;
}
$emailSenderOrRecipientEmailFoundInSystem = false;
$userCanAccessContacts = RightsUtil::canUserAccessModule('ContactsModule', $emailOwner);
$userCanAccessLeads = RightsUtil::canUserAccessModule('LeadsModule', $emailOwner);
$userCanAccessAccounts = RightsUtil::canUserAccessModule('AccountsModule', $emailOwner);
$senderInfo = EmailArchivingUtil::resolveEmailSenderFromEmailMessage($message);
if (!$senderInfo) {
$this->resolveMessageSubjectAndContentAndSendSystemMessage('SenderNotExtracted', $message);
return false;
} else {
$sender = EmailArchivingUtil::createEmailMessageSender($senderInfo, $userCanAccessContacts, $userCanAccessLeads, $userCanAccessAccounts);
if ($sender->personsOrAccounts->count() > 0) {
$emailSenderOrRecipientEmailFoundInSystem = true;
}
}
try {
$recipientsInfo = EmailArchivingUtil::resolveEmailRecipientsFromEmailMessage($message);
} catch (NotSupportedException $exception) {
$this->resolveMessageSubjectAndContentAndSendSystemMessage('RecipientNotExtracted', $message);
return false;
}
$emailMessage = new EmailMessage();
$emailMessage->owner = $emailOwner;
$emailMessage->subject = $message->subject;
$emailContent = new EmailMessageContent();
$emailContent->textContent = $message->textBody;
$emailContent->htmlContent = $message->htmlBody;
$emailMessage->content = $emailContent;
$emailMessage->sender = $sender;
$emailRecipientFoundInSystem = false;
foreach ($recipientsInfo as $recipientInfo) {
$recipient = EmailArchivingUtil::createEmailMessageRecipient($recipientInfo, $userCanAccessContacts, $userCanAccessLeads, $userCanAccessAccounts);
$emailMessage->recipients->add($recipient);
// Check if at least one recipient email can't be found in Contacts, Leads, Account and User emails
// so we will save email message in EmailFolder::TYPE_ARCHIVED_UNMATCHED folder, and user will
// be able to match emails with items(Contacts, Accounts...) emails in systems
if ($recipient->personsOrAccounts->count() > 0) {
$emailRecipientFoundInSystem = true;
}
}
// Override $emailSenderOrRecipientEmailFoundInSystem only if there are no errors
if ($emailSenderOrRecipientEmailFoundInSystem == true) {
$emailSenderOrRecipientEmailFoundInSystem = $emailRecipientFoundInSystem;
}
if ($emailOwner instanceof User) {
$box = EmailBoxUtil::getDefaultEmailBoxByUser($emailOwner);
} else {
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
}
if (!$emailSenderOrRecipientEmailFoundInSystem) {
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_ARCHIVED_UNMATCHED);
$notificationMessage = new NotificationMessage();
$notificationMessage->textContent = Zurmo::t('EmailMessagesModule', 'At least one archived email message does ' . 'not match any records in the system. ' . 'To manually match them use this link: {url}.', array('{url}' => Yii::app()->createUrl('emailMessages/default/matchingList')));
$notificationMessage->htmlContent = Zurmo::t('EmailMessagesModule', 'At least one archived email message does ' . 'not match any records in the system. ' . '<a href="{url}" target="_blank">Click here</a> to manually match them.', array('{url}' => Yii::app()->createUrl('emailMessages/default/matchingList')));
if ($emailOwner instanceof User) {
$rules = new EmailMessageArchivingEmailAddressNotMatchingNotificationRules();
$rules->addUser($emailOwner);
NotificationsUtil::submit($notificationMessage, $rules);
}
} else {
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_ARCHIVED);
}
if (!empty($message->attachments)) {
foreach ($message->attachments as $attachment) {
if (!$attachment['is_attachment']) {
continue;
}
$file = EmailArchivingUtil::createEmailAttachment($attachment);
if ($file instanceof FileModel) {
$emailMessage->files->add($file);
}
}
}
$emailMessage->sentDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime(time());
$validated = $emailMessage->validate();
if (!$validated) {
// Email message couldn't be validated(some related models can't be validated). Email user.
$this->resolveMessageSubjectAndContentAndSendSystemMessage('EmailMessageNotValidated', $message);
return false;
}
EmailArchivingUtil::resolveSanitizeFromImapToUtf8($emailMessage);
$saved = $emailMessage->save();
try {
if (!$saved) {
throw new NotSupportedException();
}
if (isset($message->uid)) {
$this->imapManager->deleteMessage($message->uid);
$this->getMessageLogger()->addDebugMessage('Deleted Message id: ' . $message->uid);
}
} catch (NotSupportedException $e) {
// Email message couldn't be saved. Email user.
$this->resolveMessageSubjectAndContentAndSendSystemMessage('EmailMessageNotSaved', $message);
return false;
}
return true;
}
/**
* Create new model
* @param $data
* @return ApiResult
* @throws ApiException
*/
protected function processCreate($data)
{
try {
$model = new EmailMessage();
$emailMessage = $this->getImapMessageFromEmailData($data);
if (isset($data['sentFrom'])) {
unset($data['sentFrom']);
}
if (isset($data['recipients'])) {
unset($data['recipients']);
}
if (isset($data['attachments'])) {
unset($data['attachments']);
}
if (isset($data['owner']['id'])) {
try {
$emailOwner = User::getById((int) $data['owner']['id']);
} catch (CException $e) {
$message = Zurmo::t('ZurmoModule', 'Owner not found.');
throw new ApiException($message);
}
} else {
$emailOwner = Yii::app()->user->userModel;
}
$emailSenderOrRecipientEmailFoundInSystem = false;
$userCanAccessContacts = RightsUtil::canUserAccessModule('ContactsModule', $emailOwner);
$userCanAccessLeads = RightsUtil::canUserAccessModule('LeadsModule', $emailOwner);
$userCanAccessAccounts = RightsUtil::canUserAccessModule('AccountsModule', $emailOwner);
if (!empty($emailMessage->fromEmail)) {
$senderInfo['email'] = $emailMessage->fromEmail;
$senderInfo['name'] = $emailMessage->fromName;
$sender = EmailArchivingUtil::createEmailMessageSender($senderInfo, $userCanAccessContacts, $userCanAccessLeads, $userCanAccessAccounts);
if ($sender->personsOrAccounts->count() > 0) {
$emailSenderOrRecipientEmailFoundInSystem = true;
}
} else {
$message = Zurmo::t('ZurmoModule', 'Sender not found.');
throw new ApiException($message);
}
try {
$recipientsInfo = EmailArchivingUtil::resolveEmailRecipientsFromEmailMessage($emailMessage);
} catch (NotSupportedException $exception) {
$message = Zurmo::t('ZurmoModule', 'No recipients found.');
throw new ApiException($message);
}
$emailRecipientFoundInSystem = false;
foreach ($recipientsInfo as $recipientInfo) {
$recipient = EmailArchivingUtil::createEmailMessageRecipient($recipientInfo, $userCanAccessContacts, $userCanAccessLeads, $userCanAccessAccounts);
$model->recipients->add($recipient);
// Check if at least one recipient email can't be found in Contacts, Leads, Account and User emails
// so we will save email message in EmailFolder::TYPE_ARCHIVED_UNMATCHED folder, and user will
// be able to match emails with items(Contacts, Accounts...) emails in systems
if ($recipient->personsOrAccounts->count() > 0) {
$emailRecipientFoundInSystem = true;
}
}
if ($emailSenderOrRecipientEmailFoundInSystem == true) {
$emailSenderOrRecipientEmailFoundInSystem = $emailRecipientFoundInSystem;
}
if ($emailOwner instanceof User) {
$box = EmailBoxUtil::getDefaultEmailBoxByUser($emailOwner);
} else {
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
}
if (!$emailSenderOrRecipientEmailFoundInSystem) {
$model->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_ARCHIVED_UNMATCHED);
$this->sendArchivedUnmatchedNotificationToEmailOwner($emailOwner);
} else {
$model->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_ARCHIVED);
}
$model->sender = $sender;
if (isset($data['textContent']) || isset($data['htmlContent'])) {
$emailContent = new EmailMessageContent();
if (isset($data['textContent'])) {
$emailContent->textContent = $data['textContent'];
} else {
$emailContent->textContent = '';
}
if (isset($data['htmlContent'])) {
$emailContent->htmlContent = $data['htmlContent'];
} else {
$emailContent->htmlContent = '';
}
$model->content = $emailContent;
unset($data['textContent']);
unset($data['htmlContent']);
} else {
$message = Zurmo::t('ZurmoModule', 'No email content found.');
throw new ApiException($message);
}
if (!empty($emailMessage->attachments)) {
foreach ($emailMessage->attachments as $attachment) {
if (isset($attachment['filename']) && isset($attachment['attachment'])) {
$file = EmailArchivingUtil::createEmailAttachment($attachment, true);
if ($file instanceof FileModel) {
$model->files->add($file);
}
}
}
}
if (!isset($data['sentDateTime'])) {
$model->sentDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime(time());
}
$this->setModelScenarioFromData($model, $data);
$model = $this->attemptToSaveModelFromData($model, $data, null, false);
$id = $model->id;
$model->forget();
if (!count($model->getErrors())) {
$data = array('id' => $id);
$result = new ApiResult(ApiResponse::STATUS_SUCCESS, $data, null, null);
} else {
$errors = $model->getErrors();
$message = Zurmo::t('ZurmoModule', 'Model was not created.');
$result = new ApiResult(ApiResponse::STATUS_FAILURE, null, $message, $errors);
}
} catch (Exception $e) {
$message = $e->getMessage();
throw new ApiException($message);
}
return $result;
}
/**
* Send a test email.
* $from('name' => 'fromName', 'address' => 'fromAddress')
* @param EmailHelper $emailHelper
* @param Array $from
* @param string $toAddress
*/
public static function sendTestEmail(EmailHelper $emailHelper, array $from, $toAddress)
{
assert('is_string($from["name"])');
assert('is_string($from["address"])');
$emailMessage = new EmailMessage();
$emailMessage->owner = Yii::app()->user->userModel;
$emailMessage->subject = Zurmo::t('EmailMessagesModule', 'A test email from Zurmo', LabelUtil::getTranslationParamsForAllModules());
$emailContent = new EmailMessageContent();
$emailContent->textContent = EmailNotificationUtil::resolveNotificationTextTemplate(Zurmo::t('EmailMessagesModule', 'A test text message from Zurmo.', LabelUtil::getTranslationParamsForAllModules()));
$emailContent->htmlContent = EmailNotificationUtil::resolveNotificationHtmlTemplate(Zurmo::t('EmailMessagesModule', 'A test text message from Zurmo.', LabelUtil::getTranslationParamsForAllModules()));
$emailMessage->content = $emailContent;
$sender = new EmailMessageSender();
$sender->fromAddress = $from['address'];
$sender->fromName = $from['name'];
$emailMessage->sender = $sender;
$recipient = new EmailMessageRecipient();
$recipient->toAddress = $toAddress;
$recipient->toName = 'Test Recipient';
$recipient->type = EmailMessageRecipient::TYPE_TO;
$emailMessage->recipients->add($recipient);
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$emailMessage->folder = EmailFolder::getByBoxAndType($box, EmailFolder::TYPE_DRAFT);
$validated = $emailMessage->validate();
if ($validated) {
$emailHelper->sendImmediately($emailMessage);
}
return $emailMessage;
}
public function testResolveSearchAttributeDataForAllLatestActivities()
{
$box = EmailBox::resolveAndGetByName(EmailBox::NOTIFICATIONS_NAME);
$rules = new EmailMessageMashableActivityRules();
$searchAttributeData = array();
$searchAttributeData['clauses'] = array();
$searchAttributeData['structure'] = null;
$searchAttributeData = $rules->resolveSearchAttributeDataForAllLatestActivities($searchAttributeData);
$compareData = array('clauses' => array(1 => array('attributeName' => 'folder', 'relatedModelData' => array('attributeName' => 'emailBox', 'operatorType' => 'doesNotEqual', 'value' => $box->id))), 'structure' => '1');
$this->assertEquals($compareData, $searchAttributeData);
}
