protected static function getConfigForKey($key)
{
$value = ZurmoConfigurationUtil::getByModuleName(static::CONFIG_MODULE_NAME, $key);
if ($key == 'bounceImapPassword') {
$value = ZurmoPasswordSecurityUtil::decrypt($value);
}
return $value;
}
public function testEncryptAndDecrypt()
{
// No need to encrypt empty string
$encryptedString = ZurmoPasswordSecurityUtil::encrypt('', 'someKey');
$this->assertEquals('', $encryptedString);
// No need to decrypt empty string
$decryptedString = ZurmoPasswordSecurityUtil::decrypt('', 'someKey');
$this->assertEquals('', $decryptedString);
$string = '357';
$salt = "123";
$encryptedString = ZurmoPasswordSecurityUtil::encrypt($string, $salt);
$this->assertTrue($string != $encryptedString);
$decryptedString = ZurmoPasswordSecurityUtil::decrypt($encryptedString, $salt);
$this->assertEquals($string, $decryptedString);
// Ensure that data will not be decrypted with random salt
$decryptedString = ZurmoPasswordSecurityUtil::decrypt($encryptedString, '567');
$this->assertTrue($string != $decryptedString);
}
/**
* @param $hash
* @param bool $validateQueryStringArray
* @param bool $validateForTracking
* @return array
* @throws NotSupportedException
*/
public static function resolveQueryStringArrayForHash($hash, $validateQueryStringArray = true, $validateForTracking = true)
{
$hash = base64_decode($hash);
if (StringUtil::isValidHash($hash)) {
$queryStringArray = array();
$decryptedString = ZurmoPasswordSecurityUtil::decrypt($hash);
if ($decryptedString) {
parse_str($decryptedString, $queryStringArray);
if ($validateQueryStringArray) {
if ($validateForTracking) {
static::validateAndResolveFullyQualifiedQueryStringArrayForTracking($queryStringArray);
} else {
static::validateQueryStringArrayForMarketingListsExternalController($queryStringArray);
}
}
return $queryStringArray;
}
}
throw new NotSupportedException();
}
/**
* Load user's outbound settings from user's email account or the system settings
* @param User $user
* @param string $name EmailAccount name or null for default name
*/
public function loadOutboundSettingsFromUserEmailAccount(User $user, $name = null)
{
$userEmailAccount = EmailAccount::getByUserAndName($user, $name);
if ($userEmailAccount->useCustomOutboundSettings) {
$settingsToLoad = array_merge($this->settingsToLoad, array('fromName', 'fromAddress'));
foreach ($settingsToLoad as $keyName) {
if ($keyName == 'outboundPassword') {
$keyValue = ZurmoPasswordSecurityUtil::decrypt($userEmailAccount->{$keyName});
$this->{$keyName} = $keyValue;
} else {
$this->{$keyName} = $userEmailAccount->{$keyName};
}
}
} else {
$this->loadOutboundSettings();
$this->fromName = strval($user);
$this->fromAddress = $this->resolveFromAddressByUser($user);
}
}
public function actionEmailConfiguration($id, $redirectUrl = null)
{
UserAccessUtil::resolveCanCurrentUserAccessAction(intval($id));
$user = User::getById(intval($id));
UserAccessUtil::resolveCanCurrentUserAccessRootUser($user);
UserAccessUtil::resolveAccessingASystemUser($user);
$title = Zurmo::t('EmailMessagesModule', 'Email Configuration');
$breadCrumbLinks = array(strval($user) => array('default/details', 'id' => $id), $title);
$emailAccount = EmailAccount::resolveAndGetByUserAndName($user);
$userEmailConfigurationForm = new UserEmailConfigurationForm($emailAccount);
$userEmailConfigurationForm->emailSignatureHtmlContent = $user->getEmailSignature()->htmlContent;
$postVariableName = get_class($userEmailConfigurationForm);
if (isset($_POST[$postVariableName])) {
$userEmailConfigurationForm->setAttributes($_POST[$postVariableName]);
if ($userEmailConfigurationForm->validate()) {
$userEmailConfigurationForm->save();
Yii::app()->user->setFlash('notification', Zurmo::t('UsersModule', 'User email configuration saved successfully.'));
if ($redirectUrl != null) {
$this->redirect($redirectUrl);
} else {
$this->redirect(array($this->getId() . '/details', 'id' => $user->id));
}
} else {
$userEmailConfigurationForm->outboundPassword = ZurmoPasswordSecurityUtil::decrypt($userEmailConfigurationForm->outboundPassword);
}
}
$titleBarAndEditView = new UserActionBarAndEmailConfigurationEditView($this->getId(), $this->getModule()->getId(), $user, $userEmailConfigurationForm);
$titleBarAndEditView->setCssClasses(array('AdministrativeArea'));
$view = new UsersPageView($this->resolveZurmoDefaultOrAdminView($titleBarAndEditView, $breadCrumbLinks, 'UserBreadCrumbView'));
echo $view->render();
}
public function testActionConfigurationEditImapModifyBounce()
{
$this->logoutCurrentUserLoginNewUserAndGetByUsername('super');
$this->setGetArray(array('type' => 2));
$this->setPostArray(array('BounceConfigurationForm' => array('imapHost' => 'mail.example.com', 'imapUsername' => '*****@*****.**', 'imapPassword' => 'abcd', 'imapPort' => '143', 'imapSSL' => '0', 'imapFolder' => 'INBOX', 'returnPath' => '*****@*****.**')));
$this->runControllerWithRedirectExceptionAndGetContent('emailMessages/default/configurationEditImap');
$this->assertEquals('Bounce configuration saved successfully.', Yii::app()->user->getFlash('notification'));
$this->assertEquals('mail.example.com', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapHost'));
$this->assertEquals('*****@*****.**', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapUsername'));
$this->assertEquals('abcd', ZurmoPasswordSecurityUtil::decrypt(ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapPassword')));
$this->assertEquals('143', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapPort'));
$this->assertEquals('0', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapSSL'));
$this->assertEquals('INBOX', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceImapFolder'));
$this->assertEquals('*****@*****.**', ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'bounceReturnPath'));
}
/**
* Load inbound settings from the database.
*/
public function loadInboundSettings()
{
foreach ($this->settingsToLoad as $keyName) {
if ($keyName == $this->resolvePasswordKeyName()) {
$encryptedKeyValue = ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', $keyName);
if ($encryptedKeyValue !== '' && $encryptedKeyValue !== null) {
$keyValue = ZurmoPasswordSecurityUtil::decrypt($encryptedKeyValue);
} else {
$keyValue = null;
}
} else {
$keyValue = ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', $keyName);
}
if (null !== $keyValue) {
$attributeName = $this->resolveAttributeNameFromSettingsKey($keyName);
$this->{$attributeName} = $keyValue;
}
}
}
protected function resolveMailerFromEmailAccount(Mailer $mailer, EmailAccount $emailAccount)
{
if ($emailAccount->useCustomOutboundSettings) {
$mailer->host = $emailAccount->outboundHost;
$mailer->port = $emailAccount->outboundPort;
$mailer->username = $emailAccount->outboundUsername;
$mailer->password = ZurmoPasswordSecurityUtil::decrypt($emailAccount->outboundPassword);
$mailer->security = $emailAccount->outboundSecurity;
}
}
/**
* Configure sendgrid options.
* @param int $id
* @param string $redirectUrl
* @return void
*/
protected function processSendGridPostConfiguration($id, $redirectUrl = null)
{
SendGridAccessUtil::resolveCanCurrentUserAccessAction(intval($id));
$user = User::getById(intval($id));
$emailAccount = SendGridEmailAccount::resolveAndGetByUserAndName($user);
$userSendGridConfigurationForm = new UserSendGridConfigurationForm($emailAccount);
$userSendGridConfigurationForm->emailSignatureHtmlContent = $user->getEmailSignature()->htmlContent;
$postVariableName = get_class($userSendGridConfigurationForm);
if (isset($_POST[$postVariableName])) {
$userSendGridConfigurationForm->setAttributes($_POST[$postVariableName]);
if ($userSendGridConfigurationForm->validate()) {
$userSendGridConfigurationForm->save();
Yii::app()->user->setFlash('notification', Zurmo::t('UsersModule', 'User SendGrid API configuration saved successfully.'));
if ($redirectUrl != null) {
$this->redirect($redirectUrl);
} else {
$this->redirect(array($this->getId() . '/details', 'id' => $user->id));
}
} else {
$userSendGridConfigurationForm->apiPassword = ZurmoPasswordSecurityUtil::decrypt($userSendGridConfigurationForm->apiPassword);
}
}
return $userSendGridConfigurationForm;
}
public function testResolveAndGetByUserAndName()
{
//Test a user that not have a Primary Email Address
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$emailAccount = SendGridEmailAccount::resolveAndGetByUserAndName($super);
$this->assertEquals('Default', $emailAccount->name);
$this->assertEquals($super, $emailAccount->user);
$this->assertEquals($super->getFullName(), $emailAccount->fromName);
$this->assertEquals($super->primaryEmail->emailAddress, $emailAccount->fromAddress);
$emailAccountId = $emailAccount->id;
$emailAccount = SendGridEmailAccount::resolveAndGetByUserAndName($super);
$this->assertNotEquals($emailAccountId, $emailAccount->id);
$emailAccount->apiUsername = static::$apiUsername;
$emailAccount->apiPassword = static::$apiPassword;
$emailAccount->save();
$this->assertEquals($emailAccount->getError('fromAddress'), 'From Address cannot be blank.');
$emailAccount->fromAddress = '*****@*****.**';
$this->assertTrue($emailAccount->save());
$emailAccountId = $emailAccount->id;
$emailAccount = SendGridEmailAccount::resolveAndGetByUserAndName($super);
$this->assertEquals($emailAccountId, $emailAccount->id);
$this->assertEquals('Default', $emailAccount->name);
$this->assertEquals($super, $emailAccount->user);
$this->assertEquals($super->getFullName(), $emailAccount->fromName);
$this->assertEquals('*****@*****.**', $emailAccount->fromAddress);
$this->assertEquals(static::$apiUsername, $emailAccount->apiUsername);
$this->assertEquals(static::$apiPassword, ZurmoPasswordSecurityUtil::decrypt($emailAccount->apiPassword));
}
/**
* Send email.
*/
public function sendEmail()
{
$emailMessage = $this->emailMessage;
if ($this->emailAccount == null) {
$apiUser = Yii::app()->sendGridEmailHelper->apiUsername;
$apiPassword = Yii::app()->sendGridEmailHelper->apiPassword;
} else {
$apiUser = $this->emailAccount->apiUsername;
$apiPassword = ZurmoPasswordSecurityUtil::decrypt($this->emailAccount->apiPassword);
}
$itemData = EmailMessageUtil::getCampaignOrAutoresponderDataByEmailMessage($this->emailMessage);
$sendgrid = new SendGrid($apiUser, $apiPassword, array("turn_off_ssl_verification" => true));
$email = new SendGrid\Email();
$email->setFrom($this->fromUserEmailData['address'])->setFromName($this->fromUserEmailData['name'])->setSubject($emailMessage->subject)->setText($emailMessage->content->textContent)->setHtml($emailMessage->content->htmlContent)->addUniqueArg("zurmoToken", md5(ZURMO_TOKEN))->addHeader('X-Sent-Using', 'SendGrid-API')->addHeader('X-Transport', 'web');
//Check if campaign and if yes, associate to email.
if ($itemData != null) {
list($itemId, $itemClass, $personId) = $itemData;
$email->addUniqueArg("itemId", $itemId);
$email->addUniqueArg("itemClass", $itemClass);
$email->addUniqueArg("personId", $personId);
}
foreach ($this->toAddresses as $emailAddress => $name) {
$email->addTo($emailAddress, $name);
}
foreach ($this->ccAddresses as $emailAddress => $name) {
$email->addCc($emailAddress);
}
foreach ($this->bccAddresses as $emailAddress => $name) {
$email->addBcc($emailAddress);
}
//Attachments
$attachmentsData = array();
$tempAttachmentPath = Yii::app()->getRuntimePath() . DIRECTORY_SEPARATOR . 'emailAttachments';
if (!file_exists($tempAttachmentPath)) {
mkdir($tempAttachmentPath);
}
if (!empty($emailMessage->files)) {
foreach ($emailMessage->files as $file) {
$fileName = tempnam($tempAttachmentPath, 'zurmo_');
$fp = fopen($fileName, 'wb');
fwrite($fp, $file->fileContent->content);
fclose($fp);
$email->addAttachment($fileName, $file->name);
$attachmentsData[] = $fileName;
}
}
$emailMessage->sendAttempts = $emailMessage->sendAttempts + 1;
$response = $sendgrid->send($email);
if ($response->message == 'success') {
//Here we need to check if
$emailMessage->error = null;
$emailMessage->folder = EmailFolder::getByBoxAndType($emailMessage->folder->emailBox, EmailFolder::TYPE_SENT);
$emailMessage->sentDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime(time());
} elseif ($response->message == 'error') {
$content = Zurmo::t('EmailMessagesModule', 'Response from Server') . "\n";
foreach ($response->errors as $error) {
$content .= $error;
}
$emailMessageSendError = new EmailMessageSendError();
$data = array();
$data['message'] = $content;
$emailMessageSendError->serializedData = serialize($data);
$emailMessage->folder = EmailFolder::getByBoxAndType($emailMessage->folder->emailBox, EmailFolder::TYPE_OUTBOX_ERROR);
$emailMessage->error = $emailMessageSendError;
}
if (count($attachmentsData) > 0) {
foreach ($attachmentsData as $path) {
unlink($path);
}
}
$saved = $emailMessage->save(false);
if (!$saved) {
throw new FailedToSaveModelException();
}
}
/**
* In the event that the value is not properly encrypted it will just return an empty string
*/
public function testDecryptWithMalformedEncryptedValue()
{
$decryptedString = ZurmoPasswordSecurityUtil::decrypt('aweaweawe', 'someKey');
$this->assertEquals('', $decryptedString);
}
/**
* Attempt to get the email account for a given user. If it does not exist, make a default SendGridEmailAccount
* and return it.
* @param User $user
* @param mixed $name null or String representing the email account name
* @param bool $decrypt
* @return SendGridEmailAccount
*/
public static function resolveAndGetByUserAndName(User $user, $name = null, $decrypt = true)
{
try {
$emailAccount = static::getByUserAndName($user, $name);
if ($decrypt === true) {
$emailAccount->apiPassword = ZurmoPasswordSecurityUtil::decrypt($emailAccount->apiPassword);
}
} catch (NotFoundException $e) {
$emailAccount = new SendGridEmailAccount();
$emailAccount->user = $user;
$emailAccount->name = self::DEFAULT_NAME;
$emailAccount->fromName = $user->getFullName();
if ($user->primaryEmail->id > 0 && $user->primaryEmail->emailAddress != null) {
$emailAccount->fromAddress = $user->primaryEmail->emailAddress;
}
}
return $emailAccount;
}
/**
* Attempt to get the email account for a given user. If it does not exist, make a default EmailAccount
* and return it.
* @param User $user
* @param mixed $name null or String representing the email account name
* @param boolean $decrypt
* @return EmailAccount
*/
public static function resolveAndGetByUserAndName(User $user, $name = null, $decrypt = true)
{
try {
$emailAccount = static::getByUserAndName($user, $name);
if ($decrypt === true) {
$emailAccount->outboundPassword = ZurmoPasswordSecurityUtil::decrypt($emailAccount->outboundPassword);
}
} catch (NotFoundException $e) {
$emailAccount = new EmailAccount();
$emailAccount->user = $user;
$emailAccount->name = self::DEFAULT_NAME;
$emailAccount->fromName = $user->getFullName();
if ($user->primaryEmail->id > 0 && $user->primaryEmail->emailAddress != null) {
$emailAccount->fromAddress = $user->primaryEmail->emailAddress;
}
$emailAccount->useCustomOutboundSettings = EmailMessageUtil::OUTBOUND_GLOBAL_SETTINGS;
$emailAccount->outboundPort = '25';
$emailAccount->outboundType = EmailHelper::OUTBOUND_TYPE_SMTP;
}
return $emailAccount;
}
/**
* Get outbound settings.
* @return array
*/
public function getOutboundSettings()
{
$settings = array();
foreach (static::$settingsToLoad as $keyName) {
if ($keyName == 'outboundPassword') {
$encryptedKeyValue = ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', $keyName);
if ($encryptedKeyValue !== '' && $encryptedKeyValue !== null) {
$keyValue = ZurmoPasswordSecurityUtil::decrypt($encryptedKeyValue);
} else {
$keyValue = null;
}
} elseif ($keyName == 'outboundType') {
$keyValue = ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', 'outboundType');
if ($keyValue == null) {
$keyValue = self::OUTBOUND_TYPE_SMTP;
}
} else {
$keyValue = ZurmoConfigurationUtil::getByModuleName('EmailMessagesModule', $keyName);
}
if (null !== $keyValue) {
$settings[$keyName] = $keyValue;
} else {
$settings[$keyName] = null;
}
}
return $settings;
}
/**
* Loads api settings.
* @return void
*/
protected function loadApiSettings()
{
foreach ($this->settingsToLoad as $keyName) {
if ($keyName == 'apiPassword') {
$encryptedKeyValue = ZurmoConfigurationUtil::getByModuleName('SendGridModule', $keyName);
if ($encryptedKeyValue !== '' && $encryptedKeyValue !== null) {
$keyValue = ZurmoPasswordSecurityUtil::decrypt($encryptedKeyValue);
} else {
$keyValue = null;
}
} else {
$keyValue = ZurmoConfigurationUtil::getByModuleName('SendGridModule', $keyName);
}
if (null !== $keyValue) {
$this->{$keyName} = $keyValue;
}
}
}
protected function resolveValueForUnpacking($packedValue)
{
return unserialize(ZurmoPasswordSecurityUtil::decrypt($packedValue));
}
/**
* Populate settings.
* @param EmailAccount $this->emailAccount
* @return void
*/
protected function populateSettings()
{
if ($this->emailAccount != null && $this->emailAccount->outboundHost != null && $this->emailAccount->outboundPort != null && $this->emailAccount->outboundUsername != null && $this->emailAccount->outboundPassword != null) {
$this->host = $this->emailAccount->outboundHost;
$this->port = $this->emailAccount->outboundPort;
$this->username = $this->emailAccount->outboundUsername;
$this->password = ZurmoPasswordSecurityUtil::decrypt($this->emailAccount->outboundPassword);
$this->security = $this->emailAccount->outboundSecurity;
} else {
$this->mailer = Yii::app()->emailHelper->outboundType;
$this->host = Yii::app()->emailHelper->outboundHost;
$this->port = Yii::app()->emailHelper->outboundPort;
$this->username = Yii::app()->emailHelper->outboundUsername;
$this->password = Yii::app()->emailHelper->outboundPassword;
$this->security = Yii::app()->emailHelper->outboundSecurity;
}
}
