email.php
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sun, Sep 28, 12:47 AM

email.php
View Options

	<?php
	/**
	* @version $Id: email.php 16597 2017-07-27 08:55:44Z alex $
	* @package In-Portal
	* @copyright Copyright (C) 1997 - 2012 Intechnic. All rights reserved.
	* @license GNU/GPL
	* In-Portal is Open Source software.
	* This means that this software may have been modified pursuant
	* the GNU General Public License, and as distributed it includes
	* or is derivative of works licensed under the GNU General Public License
	* or other free or open source software licenses.
	* See http://www.in-portal.org/license for copyright notices and details.
	*/

	defined('FULL_PATH') or die('restricted access!');

	class kEmail extends kBase {

	/**
	* Reference to class, that could send out e-mail
	*
	* @var kEmailSendingHelper
	* @access protected
	*/
	protected $sender = null;

	/**
	* Parameters of e-mail
	*
	* @var Array
	* @access protected
	* @see kEmail::_getCustomParams() List of possible system parameters supported
	*/
	protected $params = Array ();

	/**
	* Reference to e-mail template object, that would be used as data source
	*
	* @var kDBItem
	*/
	protected $emailTemplate = null;

	/**
	* Sender name
	*
	* @var string
	* @access protected
	*/
	protected $fromName = '';

	/**
	* Sender e-mail
	*
	* @var string
	* @access protected
	*/
	protected $fromEmail = '';

	/**
	* Recipient name
	*
	* @var string
	* @access protected
	*/
	protected $toName = '';

	/**
	* Recipient e-mail
	*
	* @var string
	* @access protected
	*/
	protected $toEmail = '';

	/**
	* ID of recipient user
	*
	* @var int
	*/
	protected $recipientUserId = null;

	/**
	* List of e-mail recipients
	*
	* @var Array
	* @access protected
	*/
	protected $recipients = Array (
	EmailTemplate::RECIPIENT_TYPE_TO => Array (),
	EmailTemplate::RECIPIENT_TYPE_CC => Array (),
	EmailTemplate::RECIPIENT_TYPE_BCC => Array (),
	);

	/**
	* Stores log data.
	*
	* @var array
	*/
	protected $logData = array();

	/**
	* Creates e-mail instance
	*/
	public function __construct()
	{
	parent::__construct();

	$this->sender = $this->Application->recallObject('EmailSender');
	}

	/**
	* Resets state of e-mail
	*
	* @return void
	* @access protected
	*/
	protected function _resetState()
	{
	$this->logData = array();

	$this->fromEmail = $this->fromName = '';
	$this->Application->removeObject('u.email-from');

	$this->recipients = Array (
	EmailTemplate::RECIPIENT_TYPE_TO => Array (),
	EmailTemplate::RECIPIENT_TYPE_CC => Array (),
	EmailTemplate::RECIPIENT_TYPE_BCC => Array (),
	);

	$this->toEmail = $this->toEmail = '';
	$this->Application->removeObject('u.email-to');
	}

	/**
	* Finds e-mail template matching user data
	*
	* @param string $name
	* @param int $type
	* @return bool
	* @throws InvalidArgumentException
	* @access public
	*/
	public function findTemplate($name, $type)
	{
	if ( !$name \|\| !preg_match('/^[A-Z\.]+$/', $name) ) {
	throw new InvalidArgumentException('Invalid e-mail template name "<strong>' . $name . '</strong>". Only <strong>UPPERCASE characters</strong> and <strong>dots</strong> are allowed.');
	}

	if ( $type != EmailTemplate::TEMPLATE_TYPE_ADMIN && $type != EmailTemplate::TEMPLATE_TYPE_FRONTEND ) {
	throw new InvalidArgumentException('Invalid e-mail template type');
	}

	// use "-item" special prevent error, when e-mail sent out from e-mail templates list
	$this->emailTemplate = $this->Application->recallObject('email-template.-item', null, Array ('skip_autoload' => true));

	if ( !$this->emailTemplate->isLoaded() \|\| !$this->_sameTemplate($name, $type) ) {
	// get template parameters by name & type
	$this->emailTemplate->Load(Array ('TemplateName' => $name, 'Type' => $type));
	}

	return $this->_templateUsable();
	}

	/**
	* Detects, that given e-mail template data matches currently used e-mail template
	*
	* @param string $name
	* @param int $type
	* @return bool
	* @access protected
	*/
	protected function _sameTemplate($name, $type)
	{
	return $this->emailTemplate->GetDBField('TemplateName') == $name && $this->emailTemplate->GetDBField('Type') == $type;
	}

	/**
	* Determines if we can use e-mail template we've found based on user data
	*
	* @return bool
	* @access protected
	*/
	protected function _templateUsable()
	{
	if ( !$this->emailTemplate->isLoaded() \|\| $this->emailTemplate->GetDBField('Enabled') == STATUS_DISABLED ) {
	return false;
	}

	if ( $this->emailTemplate->GetDBField('FrontEndOnly') && $this->Application->isAdmin ) {
	return false;
	}

	return true;
	}

	/**
	* Sets e-mail template params
	*
	* @param Array $params
	* @access public
	*/
	public function setParams($params)
	{
	$this->params = $params;
	}

	/**
	* Returns any custom parameters, that are passed when invoked e-mail template sending
	*
	* @return Array
	* @access protected
	*/
	protected function _getCustomParams()
	{
	$ret = $this->params;
	$send_keys = Array (
	'from_email', 'from_name', 'to_email', 'to_name',
	'overwrite_to_email', 'language_id', 'use_custom_design', 'delivery',
	'PrefixSpecial', 'item_id',
	);

	foreach ($send_keys as $send_key) {
	unset($ret[$send_key]);
	}

	return $ret;
	}

	/**
	* Sends e-mail now or puts it in queue
	*
	* @param integer $recipient_user_id Recipient user id.
	* @param boolean $immediate_send Immediate send.
	*
	* @return boolean
	*/
	public function send($recipient_user_id = null, $immediate_send = null)
	{
	$this->recipientUserId = $recipient_user_id;

	$this->_resetState();
	$this->_processSender();
	$this->_processRecipients();
	$this->_changeLanguage(false);

	// 1. set headers
	try {
	$message_headers = $this->_getHeaders();
	}
	catch ( Exception $e ) {
	return $this->setError('Error parsing e-mail message headers');
	}

	$message_subject = isset($message_headers['Subject']) ? $message_headers['Subject'] : 'Mail message';
	$this->sender->SetSubject($message_subject);

	foreach ( $message_headers as $header_name => $header_value ) {
	$this->sender->SetEncodedHeader($header_name, $header_value);
	}

	if ( $this->_storeEmailLog() ) {
	// 1. prepare log
	$this->logData = Array (
	'From' => $this->fromName . ' (' . $this->fromEmail . ')',
	'To' => $this->toName . ' (' . $this->toEmail . ')',
	'OtherRecipients' => serialize($this->recipients),
	'Subject' => $message_subject,
	'Status' => EmailLogStatus::SENT,
	'ErrorMessage' => '',
	'SentOn' => TIMENOW,
	'TemplateName' => $this->emailTemplate->GetDBField('TemplateName'),
	'EventType' => $this->emailTemplate->GetDBField('Type'),
	'EventParams' => serialize($this->_getCustomParams()),
	'ToUserId' => $this->recipientUserId,
	'ItemPrefix' => $this->getItemPrefix(),
	'ItemId' => isset($this->params['item_id']) ? $this->params['item_id'] : null,
	);

	$this->params['email_access_key'] = $this->_generateAccessKey();
	}

	// 3. set body
	try {
	$html_message_body = $this->_getMessageBody(true);
	$plain_message_body = $this->_getMessageBody(false);
	}
	catch ( Exception $e ) {
	return $this->setError('Error parsing e-mail message body');
	}

	if ( $html_message_body === false && $plain_message_body === false ) {
	return $this->setError('Message template is empty (maybe after parsing).');
	}

	if ( $html_message_body !== false ) {
	$this->sender->CreateTextHtmlPart($html_message_body, true);
	}

	if ( $plain_message_body !== false ) {
	$this->sender->CreateTextHtmlPart($plain_message_body, false);
	}

	$this->_changeLanguage(true);

	if ( $this->_storeEmailLog() ) {
	// 4. set log
	$this->logData['HtmlBody'] = $html_message_body;
	$this->logData['TextBody'] = $plain_message_body;
	$this->logData['AccessKey'] = $this->params['email_access_key'];
	$this->sender->setLogData($this->logData);
	}

	if ( !isset($immediate_send) ) {
	if ( isset($this->params['delivery']) ) {
	$delivery = $this->params['delivery'];
	}
	else {
	$delivery = $this->Application->ConfigValue('EmailDelivery');
	}

	$immediate_send = $delivery == EmailDelivery::IMMEDIATE;
	}

	return $this->sender->Deliver(null, $immediate_send);
	}

	/**
	* Extracts prefix from a given PrefixSpecial parameter.
	*
	* @return string
	*/
	protected function getItemPrefix()
	{
	$prefix_special = isset($this->params['PrefixSpecial']) ? $this->params['PrefixSpecial'] : '';

	if ( !$prefix_special ) {
	return '';
	}

	$prefix_info = $this->Application->processPrefix($prefix_special);

	return $prefix_info['prefix'];
	}

	/**
	* Determines whatever we should keep e-mail log or not
	*
	* @return bool
	* @access protected
	*/
	protected function _storeEmailLog()
	{
	return $this->Application->ConfigValue('EnableEmailLog');
	}

	/**
	* Marks e-mail sending as failed.
	*
	* @param string $error_message Error message.
	*
	* @return boolean
	*/
	protected function setError($error_message)
	{
	if ( $this->_storeEmailLog() ) {
	$this->logData['Status'] = EmailLogStatus::ERROR;
	$this->logData['ErrorMessage'] = $error_message;
	$this->Conn->doInsert($this->logData, TABLE_PREFIX . 'EmailLog');
	}

	return false;
	}

	/**
	* Generates access key for accessing e-mail later
	*
	* @return string
	* @access protected
	*/
	protected function _generateAccessKey()
	{
	$ret = '';
	$use_fields = Array ('From', 'To', 'Subject');

	foreach ($use_fields as $use_field) {
	$ret .= $this->logData[$use_field] . ':';
	}

	return md5($ret . microtime(true));
	}

	/**
	* Processes email sender
	*
	* @return void
	* @access protected
	*/
	protected function _processSender()
	{
	if ( $this->emailTemplate->GetDBField('CustomSender') ) {
	$this->_processCustomSender();
	}

	// update with custom data given during event execution
	if ( isset($this->params['from_email']) ) {
	$this->fromEmail = $this->params['from_email'];
	}

	if ( isset($this->params['from_name']) ) {
	$this->fromName = $this->params['from_name'];
	}

	// still nothing, set defaults
	$this->_ensureDefaultSender();
	$this->sender->SetFrom($this->fromEmail, $this->fromName);
	}

	/**
	* Processes custom e-mail sender
	*
	* @return void
	* @access protected
	*/
	protected function _processCustomSender()
	{
	$address = $this->emailTemplate->GetDBField('SenderAddress');
	$address_type = $this->emailTemplate->GetDBField('SenderAddressType');

	switch ($address_type) {
	case EmailTemplate::ADDRESS_TYPE_EMAIL:
	$this->fromEmail = $address;
	break;

	case EmailTemplate::ADDRESS_TYPE_USER:
	$sql = 'SELECT FirstName, LastName, Email, PortalUserId
	FROM ' . TABLE_PREFIX . 'Users
	WHERE Username = ' . $this->Conn->qstr($address);
	$user_info = $this->Conn->GetRow($sql);

	if ( $user_info ) {
	// user still exists
	$this->fromEmail = $user_info['Email'];
	$this->fromName = trim($user_info['FirstName'] . ' ' . $user_info['LastName']);

	/** @var UsersItem $user */
	$user = $this->Application->recallObject(
	'u.email-from',
	null,
	array('live_table' => true, 'skip_autoload' => true)
	);

	$user->Load($user_info['PortalUserId']);
	}
	break;
	}

	if ( $this->emailTemplate->GetDBField('SenderName') ) {
	$this->fromName = $this->emailTemplate->GetDBField('SenderName');
	}
	}

	/**
	* Ensures, that sender name & e-mail are not empty
	*
	* @return void
	* @access protected
	*/
	protected function _ensureDefaultSender()
	{
	if ( !$this->fromEmail ) {
	$this->fromEmail = $this->Application->ConfigValue('DefaultEmailSender');
	}

	if ( !$this->fromName ) {
	$this->fromName = strip_tags($this->Application->ConfigValue('Site_Name'));
	}
	}

	/**
	* Processes email recipients
	*
	* @return void
	* @access protected
	*/
	protected function _processRecipients()
	{
	$this->_collectRecipients();

	$header_mapping = $this->getHeaderMapping();

	$default_email = $this->Application->ConfigValue('DefaultEmailSender');
	$this->recipients = array_map(Array ($this, '_transformRecipientsIntoPairs'), $this->recipients);

	foreach ($this->recipients as $recipient_type => $recipients) {
	// add recipients to email
	if ( !$recipients ) {
	continue;
	}

	if ( $recipient_type == EmailTemplate::RECIPIENT_TYPE_TO ) {
	$this->toEmail = $recipients[0]['email'] ? $recipients[0]['email'] : $default_email;
	$this->toName = $recipients[0]['name'] ? $recipients[0]['name'] : $this->toEmail;
	}

	$header_name = $header_mapping[$recipient_type];

	foreach ($recipients as $recipient) {
	$email = $recipient['email'] ? $recipient['email'] : $default_email;
	$name = $recipient['name'] ? $recipient['name'] : $email;

	$this->sender->AddRecipient($header_name, $email, $name);
	}
	}
	}

	/**
	* Collects e-mail recipients from various sources
	*
	* @return void
	* @access protected
	*/
	protected function _collectRecipients()
	{
	$this->_addRecipientsFromXml($this->emailTemplate->GetDBField('Recipients'));
	$this->_overwriteToRecipient();
	$this->_addRecipientByUserId();
	$this->_addRecipientFromParams();
	$this->_moveDirectRecipients();

	if ( ($this->emailTemplate->GetDBField('Type') == EmailTemplate::TEMPLATE_TYPE_ADMIN) && !$this->recipients[EmailTemplate::RECIPIENT_TYPE_TO] ) {
	// admin email template without direct recipient -> send to admin
	$this->_addDefaultRecipient();
	}
	}

	/**
	* Adds multiple recipients from an XML
	*
	* @param string $xml
	* @return bool
	* @access protected
	*/
	protected function _addRecipientsFromXml($xml)
	{
	if ( !$xml ) {
	return false;
	}

	/** @var MInputHelper $minput_helper */
	$minput_helper = $this->Application->recallObject('MInputHelper');

	// group recipients by type
	$records = $minput_helper->parseMInputXML($xml);

	foreach ($records as $record) {
	$this->recipients[$record['RecipientType']][] = $record;
	}

	return true;
	}

	/**
	* Remove all "To" recipients, when not allowed
	*
	* @return void
	* @access protected
	*/
	protected function _overwriteToRecipient()
	{
	$overwrite_to_email = isset($this->params['overwrite_to_email']) ? $this->params['overwrite_to_email'] : false;

	if ( !$this->emailTemplate->GetDBField('CustomRecipient') \|\| $overwrite_to_email ) {
	$this->recipients[EmailTemplate::RECIPIENT_TYPE_TO] = Array ();
	}
	}

	/**
	* Update with custom data given during event execution (user_id)
	*
	* @return void
	* @access protected
	*/
	protected function _addRecipientByUserId()
	{
	if ( !is_numeric($this->recipientUserId) ) {
	return;
	}

	if ( $this->recipientUserId <= 0 ) {
	// recipient is system user with negative ID (root, guest, etc.) -> send to admin
	$this->_addDefaultRecipient();

	return;
	}

	$language_field = $this->emailTemplate->GetDBField('Type') == EmailTemplate::TEMPLATE_TYPE_FRONTEND ? 'FrontLanguage' : 'AdminLanguage';

	$sql = 'SELECT FirstName, LastName, Email, ' . $language_field . ' AS Language
	FROM ' . TABLE_PREFIX . 'Users
	WHERE PortalUserId = ' . $this->recipientUserId;
	$user_info = $this->Conn->GetRow($sql);

	if ( !$user_info ) {
	return;
	}

	$add_recipient = Array (
	'RecipientAddressType' => EmailTemplate::ADDRESS_TYPE_EMAIL,
	'RecipientAddress' => $user_info['Email'],
	'RecipientName' => trim($user_info['FirstName'] . ' ' . $user_info['LastName']),
	);

	if ( $user_info['Language'] && !isset($this->params['language_id']) ) {
	$this->params['language_id'] = $user_info['Language'];
	}

	array_unshift($this->recipients[EmailTemplate::RECIPIENT_TYPE_TO], $add_recipient);

	/** @var UsersItem $user */
	$user = $this->Application->recallObject(
	'u.email-to',
	null,
	array('live_table' => true, 'skip_autoload' => true)
	);

	$user->Load($this->recipientUserId);
	}

	/**
	* Update with custom data given during event execution (email + name)
	*
	* @return void
	* @access protected
	*/
	protected function _addRecipientFromParams()
	{
	$add_recipient = Array ();

	if ( isset($this->params['to_email']) && $this->params['to_email'] ) {
	$add_recipient['RecipientName'] = '';
	$add_recipient['RecipientAddressType'] = EmailTemplate::ADDRESS_TYPE_EMAIL;
	$add_recipient['RecipientAddress'] = $this->params['to_email'];
	}

	if ( isset($this->params['to_name']) && $this->params['to_name'] ) {
	$add_recipient['RecipientName'] = $this->params['to_name'];
	}

	if ( $add_recipient ) {
	array_unshift($this->recipients[EmailTemplate::RECIPIENT_TYPE_TO], $add_recipient);
	}
	}

	/**
	* Move recipients, that were added manually via "$this->sender->Add*" methods.
	*
	* @return void
	* @access protected
	*/
	protected function _moveDirectRecipients()
	{
	foreach ( $this->getHeaderMapping() as $recipient_type => $header_name ) {
	$manual_recipients = $this->sender->GetRecipientsByHeader($header_name);

	if ( !$manual_recipients ) {
	continue;
	}

	foreach ( $manual_recipients as $manual_recipient ) {
	$this->recipients[$recipient_type][] = array(
	'RecipientName' => $manual_recipient['Name'],
	'RecipientAddressType' => EmailTemplate::ADDRESS_TYPE_EMAIL,
	'RecipientAddress' => $manual_recipient['Email'],
	);
	}

	$this->sender->SetHeader($header_name, '');
	}
	}

	/**
	* Returns mapping between recipient type and header name.
	*
	* @return array
	*/
	protected function getHeaderMapping()
	{
	return array(
	EmailTemplate::RECIPIENT_TYPE_TO => 'To',
	EmailTemplate::RECIPIENT_TYPE_CC => 'Cc',
	EmailTemplate::RECIPIENT_TYPE_BCC => 'Bcc',
	);
	}

	/**
	* This is default recipient, when we can't determine actual one
	*
	* @return void
	* @access protected
	*/
	protected function _addDefaultRecipient()
	{
	$xml = $this->Application->ConfigValue('DefaultEmailRecipients');

	if ( !$this->_addRecipientsFromXml($xml) ) {
	$recipient = Array (
	'RecipientName' => $this->Application->ConfigValue('DefaultEmailSender'),
	'RecipientAddressType' => EmailTemplate::ADDRESS_TYPE_EMAIL,
	'RecipientAddress' => $this->Application->ConfigValue('DefaultEmailSender'),
	);

	array_unshift($this->recipients[EmailTemplate::RECIPIENT_TYPE_TO], $recipient);
	}
	}

	/**
	* Transforms recipients into name/e-mail pairs
	*
	* @param Array $recipients
	* @return Array
	* @access protected
	*/
	protected function _transformRecipientsIntoPairs($recipients)
	{
	if ( !$recipients ) {
	return Array ();
	}

	$pairs = Array ();

	foreach ($recipients as $recipient) {
	$address = $recipient['RecipientAddress'];
	$address_type = $recipient['RecipientAddressType'];
	$recipient_name = $recipient['RecipientName'];

	switch ($address_type) {
	case EmailTemplate::ADDRESS_TYPE_EMAIL:
	$pairs[] = Array ('email' => $address, 'name' => $recipient_name);
	break;

	case EmailTemplate::ADDRESS_TYPE_USER:
	$sql = 'SELECT FirstName, LastName, Email
	FROM ' . TABLE_PREFIX . 'Users
	WHERE Username = ' . $this->Conn->qstr($address);
	$user_info = $this->Conn->GetRow($sql);

	if ( $user_info ) {
	// user still exists
	$name = trim($user_info['FirstName'] . ' ' . $user_info['LastName']);

	$pairs[] = Array (
	'email' => $user_info['Email'],
	'name' => $name ? $name : $recipient_name,
	);
	}
	break;

	case EmailTemplate::ADDRESS_TYPE_GROUP:
	$sql = 'SELECT u.FirstName, u.LastName, u.Email
	FROM ' . TABLE_PREFIX . 'UserGroups g
	JOIN ' . TABLE_PREFIX . 'UserGroupRelations ug ON ug.GroupId = g.GroupId
	JOIN ' . TABLE_PREFIX . 'Users u ON u.PortalUserId = ug.PortalUserId
	WHERE g.Name = ' . $this->Conn->qstr($address);
	$users = $this->Conn->Query($sql);

	foreach ($users as $user_info) {
	$name = trim($user_info['FirstName'] . ' ' . $user_info['LastName']);

	$pairs[] = Array (
	'email' => $user_info['Email'],
	'name' => $name ? $name : $recipient_name,
	);
	}
	break;
	}
	}

	return $pairs;
	}
	/**
	* Change system language temporarily to send e-mail on user language
	*
	* @param bool $restore
	* @return void
	* @access protected
	*/
	protected function _changeLanguage($restore = false)
	{
	static $prev_language_id = null;

	if ( !isset($prev_language_id) ) {
	$prev_language_id = $this->Application->GetVar('m_lang');
	}

	// ensure that language is set
	if ( !isset($this->params['language_id']) ) {
	$this->params['language_id'] = $this->Application->GetVar('m_lang');
	}

	$language_id = $restore ? $prev_language_id : $this->params['language_id'];
	$this->Application->SetVar('m_lang', $language_id);

	/** @var LanguagesItem $language */
	$language = $this->Application->recallObject('lang.current');

	$language->Load($language_id);

	$this->Application->Phrases->LanguageId = $language_id;
	$this->Application->Phrases->Phrases = Array ();
	}

	/**
	* Parses message headers into array
	*
	* @return Array
	* @access protected
	*/
	protected function _getHeaders()
	{
	$headers = $this->emailTemplate->GetDBField('Headers');
	$headers = 'Subject: ' . $this->emailTemplate->GetField('Subject') . ($headers ? "\n" . $headers : '');
	$headers = explode("\n", $this->_parseText($headers));

	$ret = Array ();

	foreach ($headers as $header) {
	$header = explode(':', $header, 2);
	$ret[ trim($header[0]) ] = trim($header[1]);
	}

	if ( $this->Application->isDebugMode() ) {
	// set special header with template name, so it will be easier to determine what's actually was received
	$template_type = $this->emailTemplate->GetDBField('Type') == EmailTemplate::TEMPLATE_TYPE_ADMIN ? 'ADMIN' : 'USER';
	$ret['X-Template-Name'] = $this->emailTemplate->GetDBField('TemplateName') . ' - ' . $template_type;
	}

	return $ret;
	}

	/**
	* Applies design to given e-mail text
	*
	* @param string $text
	* @param bool $is_html
	* @return string
	* @access protected
	*/
	protected function _applyMessageDesign($text, $is_html = true)
	{
	static $design_templates = Array();

	$design_key = 'L' . $this->params['language_id'] . ':' . ($is_html ? 'html' : 'text');

	if ( !isset($design_templates[$design_key]) ) {
	/** @var LanguagesItem $language */
	$language = $this->Application->recallObject('lang.current');

	$design_template = $language->GetDBField($is_html ? 'HtmlEmailTemplate' : 'TextEmailTemplate');

	if ( !$is_html && !$design_template ) {
	$design_template = $this->sender->ConvertToText($language->GetDBField('HtmlEmailTemplate'), true);
	}

	$design_templates[$design_key] = $design_template;
	}

	return $this->_parseText(str_replace('$body', $text, $design_templates[$design_key]), $is_html);
	}

	/**
	* Returns message body
	*
	* @param bool $is_html
	* @return bool\|string
	* @access protected
	*/
	protected function _getMessageBody($is_html = false)
	{
	$message_body = $this->emailTemplate->GetField($is_html ? 'HtmlBody' : 'PlainTextBody');

	if ( !trim($message_body) && !$is_html ) {
	// no plain text part available -> make it from html part then
	$message_body = $this->sender->ConvertToText($this->emailTemplate->GetField('HtmlBody'), true);
	}

	if ( !trim($message_body) ) {
	return false;
	}

	if ( isset($this->params['use_custom_design']) && $this->params['use_custom_design'] ) {
	$message_body = $this->_parseText($message_body, $is_html);
	}
	else {
	$message_body = $this->_applyMessageDesign($message_body, $is_html);
	}

	return trim($message_body) ? $message_body : false;
	}

	/**
	* Parse message template and return headers (as array) and message body part
	*
	* @param string $text
	* @param bool $is_html
	* @return string
	* @access protected
	*/
	protected function _parseText($text, $is_html = true)
	{
	$text = $this->_substituteReplacementTags($text);

	if ( !$text ) {
	return '';
	}

	// init for cases, when e-mail is sent from event before page template rendering
	$this->Application->InitParser();

	$parser_params = $this->Application->Parser->Params; // backup parser params
	$this->Application->Parser->SetParams($this->params);

	$template_name = 'et_' . $this->emailTemplate->GetID() . '_' . crc32($text);
	$text = $this->Application->Parser->Parse($this->_normalizeLineEndings($text), $template_name);
	$this->Application->Parser->SetParams($parser_params); // restore parser params

	/** @var CategoryHelper $category_helper */
	$category_helper = $this->Application->recallObject('CategoryHelper');

	return $category_helper->replacePageIds($is_html ? $this->_removeTrailingLineEndings($text) : $text);
	}

	/**
	* Substitutes replacement tags in given text
	*
	* @param string $text
	* @return string
	* @access protected
	*/
	protected function _substituteReplacementTags($text)
	{
	$default_replacement_tags = Array (
	'<inp:touser _Field="password"' => '<inp2:u_Field name="Password_plain"',
	'<inp:touser _Field="UserName"' => '<inp2:u_Field name="Username"',
	'<inp:touser _Field' => '<inp2:u_Field name',
	);

	$replacement_tags = $this->emailTemplate->GetDBField('ReplacementTags');
	$replacement_tags = $replacement_tags ? unserialize($replacement_tags) : Array ();
	$replacement_tags = array_merge($default_replacement_tags, $replacement_tags);

	foreach ($replacement_tags as $replace_from => $replace_to) {
	$text = str_replace($replace_from, $replace_to, $text);
	}

	return $text;
	}

	/**
	* Convert Unix/Windows/Mac line ending into Unix line endings
	*
	* @param string $text
	* @return string
	* @access protected
	*/
	protected function _normalizeLineEndings($text)
	{
	return str_replace(Array ("\r\n", "\r"), "\n", $text);
	}

	/**
	* Remove trailing line endings
	*
	* @param $text
	* @return string
	* @access protected
	*/
	protected function _removeTrailingLineEndings($text)
	{
	return preg_replace('/(\n\|\r)+/', "\\1", $text);
	}
	}

email.phpNo OneTemporaryActions

File Metadata

email.phpView Options

Event Timeline

email.php
No OneTemporary
Actions

email.php
View Options