コード例 #1
0
 protected static function setConfigForKey($key, $value)
 {
     if ($key == 'bounceImapPassword') {
         $value = ZurmoPasswordSecurityUtil::encrypt($value);
     }
     ZurmoConfigurationUtil::setByModuleName(static::CONFIG_MODULE_NAME, $key, $value);
 }
コード例 #2
0
 /**
  * @covers ZurmoSendGridMailer::sendTestEmail
  * @covers ZurmoSendGridMailer::sendEmail
  */
 public function testSendEmail()
 {
     $sendGridEmailAccount = new SendGridEmailAccount();
     $sendGridEmailAccount->apiUsername = static::$apiUsername;
     $sendGridEmailAccount->apiPassword = ZurmoPasswordSecurityUtil::encrypt(static::$apiPassword);
     $from = array('name' => 'Test User', 'address' => '*****@*****.**');
     $emailMessage = EmailMessageHelper::processAndCreateTestEmailMessage($from, static::$testEmailAddress);
     $mailer = new ZurmoSendGridMailer($emailMessage, $sendGridEmailAccount);
     $emailMessage = $mailer->sendTestEmail(true);
     $this->assertEquals('EmailMessage', get_class($emailMessage));
     $this->assertEquals(EmailFolder::TYPE_SENT, $emailMessage->folder->type);
 }
コード例 #3
0
 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);
 }
コード例 #4
0
 public function testMakeFormAndSetConfigurationFromForm()
 {
     $form = BounceConfigurationFormAdapter::makeFormFromGlobalConfiguration();
     $this->assertNull($form->imapHost);
     $this->assertNull($form->imapPort);
     $this->assertNull($form->imapUsername);
     $this->assertNull($form->imapPassword);
     $this->assertNull($form->imapSSL);
     $this->assertNull($form->imapFolder);
     $this->assertNull($form->returnPath);
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapHost', 'bounce.com');
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapPort', '420');
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapSSL', '1');
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapUsername', 'bouncy');
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapPassword', ZurmoPasswordSecurityUtil::encrypt('bounces'));
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceImapFolder', 'BOUNCES');
     ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', 'bounceReturnPath', '*****@*****.**');
     $form = BounceConfigurationFormAdapter::makeFormFromGlobalConfiguration();
     $this->assertEquals('bounce.com', $form->imapHost);
     $this->assertEquals('420', $form->imapPort);
     $this->assertEquals('bouncy', $form->imapUsername);
     $this->assertEquals('bounces', $form->imapPassword);
     $this->assertEquals('1', $form->imapSSL);
     $this->assertEquals('BOUNCES', $form->imapFolder);
     $this->assertEquals('*****@*****.**', $form->returnPath);
     $form = BounceConfigurationFormAdapter::makeFormFromGlobalConfiguration();
     $form->imapHost = 'example.com';
     $form->imapPort = '111';
     $form->imapSSL = '0';
     $form->imapUsername = '******';
     $form->imapPassword = '******';
     $form->imapFolder = 'folder';
     $form->returnPath = 'path';
     BounceConfigurationFormAdapter::setConfigurationFromForm($form);
     $form = BounceConfigurationFormAdapter::makeFormFromGlobalConfiguration();
     $this->assertEquals('example.com', $form->imapHost);
     $this->assertEquals('111', $form->imapPort);
     $this->assertEquals('user', $form->imapUsername);
     $this->assertEquals('password', $form->imapPassword);
     $this->assertEquals('0', $form->imapSSL);
     $this->assertEquals('folder', $form->imapFolder);
     $this->assertEquals('path', $form->returnPath);
 }
コード例 #5
0
 /**
  * @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();
 }
コード例 #6
0
 /**
  * Send Test Message
  * @param SendGridWebApiConfigurationForm $configurationForm
  * @param string $fromNameToSendMessagesFrom
  * @param string $fromAddressToSendMessagesFrom
  */
 public static function sendTestMessage($configurationForm, $fromNameToSendMessagesFrom = null, $fromAddressToSendMessagesFrom = null)
 {
     if ($configurationForm->aTestToAddress != null) {
         $sendGridEmailAccount = new SendGridEmailAccount();
         $sendGridEmailAccount->apiUsername = $configurationForm->username;
         $sendGridEmailAccount->apiPassword = ZurmoPasswordSecurityUtil::encrypt($configurationForm->password);
         $isUser = false;
         if ($fromNameToSendMessagesFrom != null && $fromAddressToSendMessagesFrom != null) {
             $isUser = true;
             $from = array('name' => $fromNameToSendMessagesFrom, 'address' => $fromAddressToSendMessagesFrom);
         } else {
             $user = BaseControlUserConfigUtil::getUserToRunAs();
             $userToSendMessagesFrom = User::getById((int) $user->id);
             $from = array('name' => Yii::app()->emailHelper->resolveFromNameForSystemUser($userToSendMessagesFrom), 'address' => Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom));
         }
         $emailMessage = EmailMessageHelper::processAndCreateTestEmailMessage($from, $configurationForm->aTestToAddress);
         $mailer = new ZurmoSendGridMailer($emailMessage, $sendGridEmailAccount);
         $emailMessage = $mailer->sendTestEmail($isUser);
         $messageContent = EmailHelper::prepareMessageContent($emailMessage);
     } else {
         $messageContent = Zurmo::t('EmailMessagesModule', 'A test email address must be entered before you can send a test email.') . "\n";
     }
     return $messageContent;
 }
コード例 #7
0
 /**
  * Set api settings into the database.
  */
 public function setApiSettings()
 {
     foreach ($this->settingsToLoad as $keyName) {
         if ($keyName == 'apiPassword') {
             $password = ZurmoPasswordSecurityUtil::encrypt($this->{$keyName});
             ZurmoConfigurationUtil::setByModuleName('SendGridModule', $keyName, $password);
         } else {
             ZurmoConfigurationUtil::setByModuleName('SendGridModule', $keyName, $this->{$keyName});
         }
     }
 }
コード例 #8
0
ファイル: EmailHelper.php プロジェクト: sandeep1027/zurmo_
 /**
  * Set outbound settings into the database.
  */
 public function setOutboundSettings()
 {
     foreach ($this->settingsToLoad as $keyName) {
         if ($keyName == 'outboundPassword') {
             $password = ZurmoPasswordSecurityUtil::encrypt($this->{$keyName});
             ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', $keyName, $password);
         } else {
             ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', $keyName, $this->{$keyName});
         }
     }
 }
コード例 #9
0
 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'));
 }
コード例 #11
0
ファイル: ZurmoImap.php プロジェクト: youprofit/Zurmo
 /**
  * Set inbound settings into the database.
  */
 public function setInboundSettings()
 {
     foreach ($this->settingsToLoad as $keyName) {
         $attributeName = $this->resolveAttributeNameFromSettingsKey($keyName);
         if ($keyName == $this->resolvePasswordKeyName()) {
             $password = ZurmoPasswordSecurityUtil::encrypt($this->{$attributeName});
             ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', $keyName, $password);
         } else {
             ZurmoConfigurationUtil::setByModuleName('EmailMessagesModule', $keyName, $this->{$attributeName});
         }
     }
 }
コード例 #12
0
 /**
  * Given an installSettingsForm, run the install including the schema creation and default data load. This is
  * used by the interactive install and the command line install.
  * @param object $form
  * @param object $messageStreamer
  */
 public static function runInstallation($form, &$messageStreamer)
 {
     Yii::app()->params['isFreshInstall'] = true;
     assert('$form instanceof InstallSettingsForm');
     assert('$messageStreamer instanceof MessageStreamer');
     if (defined('IS_TEST')) {
         $perInstanceFilename = "perInstanceTest.php";
         $debugFilename = "debugTest.php";
     } else {
         @set_time_limit(1200);
         $perInstanceFilename = "perInstance.php";
         $debugFilename = "debug.php";
     }
     $messageStreamer->add(Zurmo::t('InstallModule', 'Connecting to Database.'));
     static::connectToDatabase($form->databaseType, $form->databaseHostname, $form->databaseName, $form->databaseUsername, $form->databasePassword, $form->databasePort);
     ForgetAllCacheUtil::forgetAllCaches();
     $messageStreamer->add(Zurmo::t('InstallModule', 'Dropping existing tables.'));
     ZurmoRedBean::$writer->wipeAll();
     $messageStreamer->add(Zurmo::t('InstallModule', 'Creating super user.'));
     $messageLogger = new MessageLogger($messageStreamer);
     $messageLogger->logDateTimeStamp = false;
     Yii::app()->custom->runBeforeInstallationAutoBuildDatabase($messageLogger);
     $messageStreamer->add(Zurmo::t('InstallModule', 'Starting database schema creation.'));
     $startTime = microtime(true);
     $messageStreamer->add('debugOn:' . BooleanUtil::boolToString(YII_DEBUG));
     $messageStreamer->add('phpLevelCaching:' . BooleanUtil::boolToString(PHP_CACHING_ON));
     $messageStreamer->add('memcacheLevelCaching:' . BooleanUtil::boolToString(MEMCACHE_ON));
     static::autoBuildDatabase($messageLogger, false);
     $endTime = microtime(true);
     $messageStreamer->add(Zurmo::t('InstallModule', 'Total autobuild time: {formattedTime} seconds.', array('{formattedTime}' => number_format($endTime - $startTime, 3))));
     if (SHOW_QUERY_DATA) {
         $messageStreamer->add(FooterView::getTotalAndDuplicateQueryCountContent());
         $messageStreamer->add(PageView::makeNonHtmlDuplicateCountAndQueryContent());
     }
     $messageStreamer->add(Zurmo::t('InstallModule', 'Database schema creation complete.'));
     $messageStreamer->add(Zurmo::t('InstallModule', 'Rebuilding Permissions.'));
     AllPermissionsOptimizationUtil::rebuild();
     $messageStreamer->add(Zurmo::t('InstallModule', 'Rebuilding Read Permissions Subscription tables.'));
     ReadPermissionsSubscriptionUtil::buildTables();
     $messageStreamer->add(Zurmo::t('InstallModule', 'Writing Configuration File.'));
     static::writeConfiguration(INSTANCE_ROOT, $form->databaseType, $form->databaseHostname, $form->databaseName, $form->databaseUsername, $form->databasePassword, $form->databasePort, $form->memcacheHostname, (int) $form->memcachePortNumber, true, Yii::app()->language, $perInstanceFilename, $debugFilename, $form->hostInfo, $form->scriptUrl, $form->submitCrashToSentry);
     static::setZurmoTokenAndWriteToPerInstanceFile(INSTANCE_ROOT);
     ZurmoPasswordSecurityUtil::setPasswordSaltAndWriteToPerInstanceFile(INSTANCE_ROOT);
     static::createSuperUser('super', $form->superUserPassword);
     $messageStreamer->add(Zurmo::t('InstallModule', 'Setting up default data.'));
     DefaultDataUtil::load($messageLogger);
     static::createBaseControlUserConfigUtilUserAccount();
     Yii::app()->custom->runAfterInstallationDefaultDataLoad($messageLogger);
     // Send notification to super admin to delete test.php file in case if this
     // installation is used in production mode.
     $message = new NotificationMessage();
     $message->textContent = Zurmo::t('InstallModule', 'If this website is in production mode, please remove the app/test.php file.');
     $rules = new RemoveApiTestEntryScriptFileNotificationRules();
     NotificationsUtil::submit($message, $rules);
     // If minify is disabled, inform user that they should fix issues and enable minify
     $setIncludePathServiceHelper = new SetIncludePathServiceHelper();
     if (!$setIncludePathServiceHelper->runCheckAndGetIfSuccessful()) {
         $message = new NotificationMessage();
         $message->textContent = Zurmo::t('InstallModule', 'Minify has been disabled due to a system issue. Try to resolve the problem and re-enable Minify.');
         $rules = new EnableMinifyNotificationRules();
         NotificationsUtil::submit($message, $rules);
     }
     $messageStreamer->add(Zurmo::t('InstallModule', 'Installation Complete.'));
     Yii::app()->params['isFreshInstall'] = false;
 }
コード例 #13
0
 protected static function resolveHashForQueryStringArray($queryStringArray)
 {
     $queryString = http_build_query($queryStringArray);
     $encryptedString = ZurmoPasswordSecurityUtil::encrypt($queryString);
     if (!$encryptedString || !static::isValidHash($encryptedString)) {
         throw new NotSupportedException();
     }
     $encryptedString = base64_encode($encryptedString);
     return $encryptedString;
 }
コード例 #14
0
 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;
     }
 }
コード例 #15
0
 protected function resolveValueForUnpacking($packedValue)
 {
     return unserialize(ZurmoPasswordSecurityUtil::decrypt($packedValue));
 }
コード例 #16
0
 /**
  * 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;
 }
コード例 #17
0
 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));
 }
コード例 #18
0
 /**
  * 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();
     }
 }
コード例 #19
0
 /**
  * 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);
 }
コード例 #20
0
 /**
  * Encrypt password beforeSave
  * @return void
  */
 public function afterValidate()
 {
     parent::afterValidate();
     if ($this->apiPassword !== null && $this->apiPassword !== '') {
         $this->apiPassword = ZurmoPasswordSecurityUtil::encrypt($this->apiPassword);
     }
 }
コード例 #21
0
 /**
  * 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;
 }
コード例 #22
0
 /**
  * Assumes before calling this, the outbound settings have been validated in the form.
  * Todo: When new user interface is complete, this will be re-worked to be on page instead of modal.
  */
 public function actionSendTestMessage()
 {
     $configurationForm = EmailSmtpConfigurationFormAdapter::makeFormFromGlobalConfiguration();
     $postVariableName = get_class($configurationForm);
     if (isset($_POST[$postVariableName]) || isset($_POST['UserEmailConfigurationForm'])) {
         if (isset($_POST[$postVariableName])) {
             $configurationForm->setAttributes($_POST[$postVariableName]);
         } else {
             //Check for sendgrid
             if ($_POST['UserEmailConfigurationForm']['useCustomOutboundSettings'] == EmailMessageUtil::OUTBOUND_PERSONAL_SENDGRID_SETTINGS) {
                 $this->processSendTestMessageForSendGrid();
             } else {
                 $configurationForm->host = $_POST['UserEmailConfigurationForm']['outboundHost'];
                 $configurationForm->port = $_POST['UserEmailConfigurationForm']['outboundPort'];
                 $configurationForm->username = $_POST['UserEmailConfigurationForm']['outboundUsername'];
                 $configurationForm->password = $_POST['UserEmailConfigurationForm']['outboundPassword'];
                 $configurationForm->security = $_POST['UserEmailConfigurationForm']['outboundSecurity'];
                 $configurationForm->aTestToAddress = $_POST['UserEmailConfigurationForm']['aTestToAddress'];
                 $fromNameToSendMessagesFrom = $_POST['UserEmailConfigurationForm']['fromName'];
                 $fromAddressToSendMessagesFrom = $_POST['UserEmailConfigurationForm']['fromAddress'];
             }
         }
         if ($configurationForm->aTestToAddress != null) {
             $emailAccount = new EmailAccount();
             $emailAccount->outboundHost = $configurationForm->host;
             $emailAccount->outboundPort = $configurationForm->port;
             $emailAccount->outboundUsername = $configurationForm->username;
             $emailAccount->outboundPassword = ZurmoPasswordSecurityUtil::encrypt($configurationForm->password);
             $emailAccount->outboundSecurity = $configurationForm->security;
             $isUser = false;
             if (isset($fromNameToSendMessagesFrom) && isset($fromAddressToSendMessagesFrom)) {
                 $isUser = true;
                 $from = array('name' => $fromNameToSendMessagesFrom, 'address' => $fromAddressToSendMessagesFrom);
             } else {
                 $user = BaseControlUserConfigUtil::getUserToRunAs();
                 $userToSendMessagesFrom = User::getById((int) $user->id);
                 $from = array('name' => Yii::app()->emailHelper->resolveFromNameForSystemUser($userToSendMessagesFrom), 'address' => Yii::app()->emailHelper->resolveFromAddressByUser($userToSendMessagesFrom));
             }
             $emailMessage = EmailMessageHelper::processAndCreateEmailMessage($from, $configurationForm->aTestToAddress);
             $mailer = new ZurmoSwiftMailer($emailMessage, $emailAccount);
             $emailMessage = $mailer->sendTestEmail($isUser);
             $messageContent = EmailHelper::prepareMessageContent($emailMessage);
         } else {
             $messageContent = Zurmo::t('EmailMessagesModule', 'A test email address must be entered before you can send a test email.') . "\n";
         }
         Yii::app()->getClientScript()->setToAjaxMode();
         $messageView = new TestConnectionView($messageContent);
         $view = new ModalView($this, $messageView);
         echo $view->render();
     } else {
         throw new NotSupportedException();
     }
 }
コード例 #23
0
ファイル: bootstrap.php プロジェクト: youprofit/Zurmo
 * 02110-1301 USA.
 *
 * You can contact Zurmo, Inc. with a mailing address at 27 North Wacker Drive
 * Suite 370 Chicago, IL 60606. or at email address contact@zurmo.com.
 *
 * The interactive user interfaces in original and modified versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License version 3.
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License version 3,
 * these Appropriate Legal Notices must retain the display of the Zurmo
 * logo and Zurmo copyright notice. If the display of the logo is not reasonably
 * feasible for technical reasons, the Appropriate Legal Notices must display the words
 * "Copyright Zurmo Inc. 2013. All rights reserved".
 ********************************************************************************/
require_once 'testRoots.php';
require_once 'TestConfigFileUtils.php';
TestConfigFileUtils::configureConfigFiles();
$debug = INSTANCE_ROOT . '/protected/config/debugTest.php';
$yiit = COMMON_ROOT . "/../yii/framework/yiit.php";
$config = INSTANCE_ROOT . "/protected/config/test.php";
require_once COMMON_ROOT . "/version.php";
require_once COMMON_ROOT . "/protected/modules/install/utils/InstallUtil.php";
require_once COMMON_ROOT . "/protected/core/utils/ZurmoPasswordSecurityUtil.php";
InstallUtil::setZurmoTokenAndWriteToPerInstanceFile(INSTANCE_ROOT, 'perInstanceTest.php');
ZurmoPasswordSecurityUtil::setPasswordSaltAndWriteToPerInstanceFile(INSTANCE_ROOT, 'perInstanceTest.php');
require_once $debug;
require_once $yiit;
require_once COMMON_ROOT . '/protected/core/components/WebApplication.php';
require_once COMMON_ROOT . '/protected/tests/WebTestApplication.php';
Yii::createApplication('WebTestApplication', $config);
コード例 #24
0
 /**
  * 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;
     }
 }