debug("***ERROR: InboundEmail::handleCharsetTranslation() called without a \$charset!");
$GLOBALS['log']->debug("***STACKTRACE: ".print_r(debug_backtrace(), true));
return $text;
}
// typical headers have no charset - let destination pick (since it's all ASCII anyways)
if(strtolower($charset) == 'default' || strtolower($charset) == 'utf-8') {
return $text;
}
return $locale->translateCharset($text, $charset);
}
/**
* Builds up the "breadcrumb" trail that imap_fetchbody() uses to return
* parts of an email message, including attachments and inline images
* @param $parts array of objects
* @param $subtype what type of trail to return? HTML? Plain? binaries?
* @param $breadcrumb text trail to build up
*/
function buildBreadCrumbs($parts, $subtype, $breadcrumb = '0') {
//_pp('buildBreadCrumbs building for '.$subtype.' with BC at '.$breadcrumb);
// loop through available parts in the array
foreach($parts as $k => $part) {
// mark passage through level
$thisBc = ($k+1);
// if this is not the first time through, start building the map
if($breadcrumb != 0) {
$thisBc = $breadcrumb.'.'.$thisBc;
}
// found a multi-part/mixed 'part' - keep digging
if($part->type == 1 && (strtoupper($part->subtype) == 'RELATED' || strtoupper($part->subtype) == 'ALTERNATIVE' || strtoupper($part->subtype) == 'MIXED')) {
//_pp('in loop: going deeper with subtype: '.$part->subtype.' $k is: '.$k);
$thisBc = $this->buildBreadCrumbs($part->parts, $subtype, $thisBc);
return $thisBc;
} elseif(strtolower($part->subtype) == strtolower($subtype)) { // found the subtype we want, return the breadcrumb value
//_pp('found '.$subtype.' bc! returning: '.$thisBc);
return $thisBc;
} else {
//_pp('found '.$part->subtype.' instead');
}
}
}
/**
* Similar to buildBreadCrumbs() but returns an ordered array containing all parts of the message that would be
* considered "HTML" or Richtext (embedded images, formatting, etc.).
* @param array parts Array of parts of a message
* @param int breadcrumb Passed integer value to start breadcrumb trail
* @param array stackedBreadcrumbs Persistent trail of breadcrumbs
* @return array Ordered array of parts to retrieve via imap_fetchbody()
*/
function buildBreadCrumbsHTML($parts, $breadcrumb = '0', $stackedBreadcrumbs = array()) {
$subtype = 'HTML';
$disposition = 'inline';
foreach($parts as $k => $part) {
// mark passage through level
$thisBc = ($k+1);
if($breadcrumb != 0) {
$thisBc = $breadcrumb.'.'.$thisBc;
}
// found a multi-part/mixed 'part' - keep digging
if($part->type == 1 && (strtoupper($part->subtype) == 'RELATED' || strtoupper($part->subtype) == 'ALTERNATIVE' || strtoupper($part->subtype) == 'MIXED')) {
$stackedBreadcrumbs = $this->buildBreadCrumbsHTML($part->parts, $thisBc, $stackedBreadcrumbs);
} elseif(
(strtolower($part->subtype) == strtolower($subtype)) ||
(
isset($part->disposition) && strtolower($part->disposition) == 'inline' &&
in_array(strtoupper($part->subtype), $this->imageTypes)
)
) {
// found the subtype we want, return the breadcrumb value
$stackedBreadcrumbs[] = array(strtolower($part->subtype) => $thisBc);
} elseif($part->type == 5) {
$stackedBreadcrumbs[] = array(strtolower($part->subtype) => $thisBc);
}
}
return $stackedBreadcrumbs;
}
/**
* Takes a PHP imap_* object's to/from/cc/bcc address field and converts it
* to a standard string that SugarCRM expects
* @param $arr an array of email address objects
*/
function convertImapToSugarEmailAddress($arr) {
if(is_array($arr)) {
$addr = '';
foreach($arr as $key => $obj) {
$addr .= $obj->mailbox.'@'.$obj->host.', ';
}
// strip last comma
$ret = substr_replace($addr,'',-2,-1);
return trim($ret);
}
}
/**
* tries to figure out what character set a given filename is using and
* decode based on that
*
* @param string name Name of attachment
* @return string decoded name
*/
function handleEncodedFilename($name) {
$imapDecode = imap_mime_header_decode($name);
/******************************
$imapDecode => stdClass Object
(
[charset] => utf-8
[text] => w�hlen.php
)
OR
$imapDecode => stdClass Object
(
[charset] => default
[text] => UTF-8''%E3%83%8F%E3%82%99%E3%82%A4%E3%82%AA%E3%82%AF%E3%82%99%E3%83%A9%E3%83%95%E3%82%A3%E3%83%BC.txt
)
*******************************/
if($imapDecode[0]->charset != 'default') { // mime-header encoded charset
$encoding = $imapDecode[0]->charset;
$name = $imapDecode[0]->text; // encoded in that charset
} else {
/* encoded filenames are formatted as [encoding]''[filename] */
if(strpos($name, "''") !== false) {
$encoding = substr($name, 0, strpos($name, "'"));
while(strpos($name, "'") !== false) {
$name = trim(substr($name, (strpos($name, "'")+1), strlen($name)));
}
}
$name = urldecode($name);
}
return (strtolower($encoding) == 'utf-8') ? $name : $GLOBALS['locale']->translateCharset($name, $encoding, 'UTF-8');
}
/*
Primary body types for a part of a mail structure (imap_fetchstructure returned object)
0 => text
1 => multipart
2 => message
3 => application
4 => audio
5 => image
6 => video
7 => other
*/
/**
Primary body types for a part of a mail structure (imap_fetchstructure returned object)
@var array $imap_types
*/
public $imap_types = array(
0 => 'text',
1 => 'multipart',
2 => 'message',
3 => 'application',
4 => 'audio',
5 => 'image',
6 => 'video',
);
public function getMimeType($type, $subtype)
{
if(isset($this->imap_types[$type])) {
return $this->imap_types[$type]."/$subtype";
} else {
return "other/$subtype";
}
}
/**
* Takes the "parts" attribute of the object that imap_fetchbody() method
* returns, and recursively goes through looking for objects that have a
* disposition of "attachement" or "inline"
* @param int $msgNo The relative message number for the monitored mailbox
* @param object $parts Array of objects to examine
* @param string $emailId The GUID of the email saved prior to calling this method
* @param array $breadcrumb Default 0, build up of the parts mapping
* @param bool $forDisplay Default false
*/
function saveAttachments($msgNo, $parts, $emailId, $breadcrumb='0', $forDisplay) {
global $sugar_config;
/*
Primary body types for a part of a mail structure (imap_fetchstructure returned object)
0 => text
1 => multipart
2 => message
3 => application
4 => audio
5 => image
6 => video
7 => other
*/
foreach($parts as $k => $part) {
$thisBc = $k+1;
if($breadcrumb != '0') {
$thisBc = $breadcrumb.'.'.$thisBc;
}
$attach = null;
// check if we need to recurse into the object
//if($part->type == 1 && !empty($part->parts)) {
if(isset($part->parts) && !empty($part->parts) && !( isset($part->subtype) && strtolower($part->subtype) == 'rfc822') ) {
$this->saveAttachments($msgNo, $part->parts, $emailId, $thisBc, $forDisplay);
continue;
} elseif($part->ifdisposition) {
// we will take either 'attachments' or 'inline'
if(strtolower($part->disposition) == 'attachment' || ((strtolower($part->disposition) == 'inline') && $part->type != 0)) {
$attach = $this->getNoteBeanForAttachment($emailId);
$fname = $this->handleEncodedFilename($this->retrieveAttachmentNameFromStructure($part->dparameters));
if(!empty($fname)) {//assign name to attachment
$attach->name = $fname;
} else {//if name is empty, default to filename
$attach->name = urlencode($this->retrieveAttachmentNameFromStructure($part->dparameters));
}
$attach->filename = $attach->name;
if (empty($attach->filename)) {
continue;
}
// deal with the MIME types email has
$attach->file_mime_type = $this->getMimeType($part->type, $part->subtype);
$attach->safeAttachmentName();
if($forDisplay) {
$attach->id = $this->getTempFilename();
} else {
// only save if doing a full import, else we want only the binaries
$attach->save();
}
} // end if disposition type 'attachment'
}// end ifdisposition
//Retrieve contents of subtype rfc8822
elseif ($part->type == 2 && isset($part->subtype) && strtolower($part->subtype) == 'rfc822' )
{
$tmp_eml = imap_fetchbody($this->conn, $msgNo, $thisBc);
$attach = $this->getNoteBeanForAttachment($emailId);
$attach->file_mime_type = 'messsage/rfc822';
$attach->description = $tmp_eml;
$attach->filename = 'bounce.eml';
$attach->safeAttachmentName();
if($forDisplay) {
$attach->id = $this->getTempFilename();
} else {
// only save if doing a full import, else we want only the binaries
$attach->save();
}
} elseif(!$part->ifdisposition && $part->type != 1 && $part->type != 2 && $thisBc != '1') {
// No disposition here, but some IMAP servers lie about disposition headers, try to find the truth
// Also Outlook puts inline attachments as type 5 (image) without a disposition
if($part->ifparameters) {
foreach($part->parameters as $param) {
if(strtolower($param->attribute) == "name" || strtolower($param->attribute) == "filename") {
$fname = $this->handleEncodedFilename($param->value);
break;
}
}
if(empty($fname)) continue;
// we assume that named parts are attachments too
$attach = $this->getNoteBeanForAttachment($emailId);
$attach->filename = $attach->name = $fname;
$attach->file_mime_type = $this->getMimeType($part->type, $part->subtype);
$attach->safeAttachmentName();
if($forDisplay) {
$attach->id = $this->getTempFilename();
} else {
// only save if doing a full import, else we want only the binaries
$attach->save();
}
}
}
$this->saveAttachmentBinaries($attach, $msgNo, $thisBc, $part, $forDisplay);
} // end foreach
}
/**
* Return a new note object for attachments.
*
* @param string $emailId
* @return Note
*/
function getNoteBeanForAttachment($emailId)
{
$attach = new Note();
$attach->parent_id = $emailId;
$attach->parent_type = 'Emails';
return $attach;
}
/**
* Return the filename of the attachment by examining the dparameters returned from imap_fetch_structure which
* represet the content-disposition of the MIME header.
*
* @param array $dparamaters
* @return string
*/
function retrieveAttachmentNameFromStructure($dparamaters)
{
$result = "";
foreach ($dparamaters as $k => $v)
{
if( strtolower($v->attribute) == 'filename')
{
$result = $v->value;
break;
}
}
return $result;
}
/**
* saves the actual binary file of a given attachment
* @param object attach Note object that is attached to the binary file
* @param string msgNo Message Number on IMAP/POP3 server
* @param string thisBc Breadcrumb to navigate email structure to find the content
* @param object part IMAP standard object that contains the "parts" of this section of email
* @param bool $forDisplay
*/
function saveAttachmentBinaries($attach, $msgNo, $thisBc, $part, $forDisplay) {
// decide where to place the file temporarily
$uploadDir = ($forDisplay) ? "{$this->EmailCachePath}/{$this->id}/attachments/" : "upload://";
// decide what name to save file as
$fileName = $attach->id;
// download the attachment if we didn't do it yet
if(!file_exists($uploadDir.$fileName)) {
$msgPartRaw = imap_fetchbody($this->conn, $msgNo, $thisBc);
// deal with attachment encoding and decode the text string
$msgPart = $this->handleTranserEncoding($msgPartRaw, $part->encoding);
if(file_put_contents($uploadDir.$fileName, $msgPart)) {
$GLOBALS['log']->debug('InboundEmail saved attachment file: '.$attach->filename);
} else {
$GLOBALS['log']->debug('InboundEmail could not create attachment file: '.$attach->filename ." - temp file target: [ {$uploadDir}{$fileName} ]");
return;
}
}
$this->tempAttachment[$fileName] = urldecode($attach->filename);
// if all was successful, feel for inline and cache Note ID for display:
if((strtolower($part->disposition) == 'inline' && in_array($part->subtype, $this->imageTypes))
|| ($part->type == 5)) {
if(copy($uploadDir.$fileName, sugar_cached("images/{$fileName}.").strtolower($part->subtype))) {
$id = substr($part->id, 1, -1); //strip <> around
$this->inlineImages[$id] = $attach->id.".".strtolower($part->subtype);
} else {
$GLOBALS['log']->debug('InboundEmail could not copy '.$uploadDir.$fileName.' to cache');
}
}
}
/**
* decodes a string based on its associated encoding
* if nothing is passed, we default to no-encoding type
* @param $str encoded string
* @param $enc detected encoding
*/
function handleTranserEncoding($str, $enc=0) {
switch($enc) {
case 2:// BINARY
$ret = $str;
break;
case 3:// BASE64
$ret = base64_decode($str);
break;
case 4:// QUOTED-PRINTABLE
$ret = quoted_printable_decode($str);
break;
case 0:// 7BIT or 8BIT
case 1:// already in a string-useable format - do nothing
case 5:// OTHER
default:// catch all
$ret = $str;
break;
}
return $ret;
}
/**
* Some emails do not get assigned a message_id, specifically from
* Outlook/Exchange.
*
* We need to derive a reliable one for duplicate import checking.
*/
function getMessageId($header) {
$message_id = md5(print_r($header, true));
return $message_id;
}
/**
* checks for duplicate emails on polling. The uniqueness of a given email message is determined by a concatenation
* of 2 values, the messageID and the delivered-to field. This allows multiple To: and B/CC: destination addresses
* to be imported by Sugar without violating the true duplicate-email issues.
*
* @param string message_id message ID generated by sending server
* @param int message number (mailserver's key) of email
* @param object header object generated by imap_headerinfo()
* @param string textHeader Headers in normal text format
* @return bool
*/
function importDupeCheck($message_id, $header, $textHeader) {
$GLOBALS['log']->debug('*********** InboundEmail doing dupe check.');
// generate "delivered-to" seed for email duplicate check
$deliveredTo = $this->id; // cn: bug 12236 - cc's failing dupe check
$exHeader = explode("\n", $textHeader);
foreach($exHeader as $headerLine) {
if(strpos(strtolower($headerLine), 'delivered-to:') !== false) {
$deliveredTo = substr($headerLine, strpos($headerLine, " "), strlen($headerLine));
$GLOBALS['log']->debug('********* InboundEmail found [ '.$deliveredTo.' ] as the destination address for email [ '.$message_id.' ]');
} elseif(strpos(strtolower($headerLine), 'x-real-to:') !== false) {
$deliveredTo = substr($headerLine, strpos($headerLine, " "), strlen($headerLine));
$GLOBALS['log']->debug('********* InboundEmail found [ '.$deliveredTo.' ] for non-standards compliant email x-header [ '.$message_id.' ]');
}
}
//if(empty($message_id) && !isset($message_id)) {
if(empty($message_id) || !isset($message_id)) {
$GLOBALS['log']->debug('*********** NO MESSAGE_ID.');
$message_id = $this->getMessageId($header);
}
// generate compound messageId
$this->compoundMessageId = trim($message_id).trim($deliveredTo);
// if the length > 255 then md5 it so that the data will be of smaller length
if (strlen($this->compoundMessageId) > 255) {
$this->compoundMessageId = md5($this->compoundMessageId);
} // if
if (empty($this->compoundMessageId)) {
$GLOBALS['log']->error('Inbound Email found a message without a header and message_id');
return false;
} // if
$potentials = clean_xss($this->compoundMessageId, false);
if(is_array($potentials) && !empty($potentials)) {
foreach($potentials as $bad) {
$this->compoundMessageId = str_replace($bad, "", $this->compoundMessageId);
}
}
$query = 'SELECT count(emails.id) AS c FROM emails WHERE emails.message_id = \''.$this->compoundMessageId.'\' and emails.deleted = 0';
$r = $this->db->query($query, true);
$a = $this->db->fetchByAssoc($r);
if($a['c'] > 0) {
$GLOBALS['log']->debug('InboundEmail found a duplicate email with ID ('.$this->compoundMessageId.')');
return false; // we have a dupe and don't want to import the email'
} else {
return true;
}
}
/**
* takes the output from imap_mime_hader_decode() and handles multiple types of encoding
* @param string subject Raw subject string from email
* @return string ret properly formatted UTF-8 string
*/
function handleMimeHeaderDecode($subject) {
$subjectDecoded = imap_mime_header_decode($subject);
$ret = '';
foreach($subjectDecoded as $object) {
if($object->charset != 'default') {
$ret .= $this->handleCharsetTranslation($object->text, $object->charset);
} else {
$ret .= $object->text;
}
}
return $ret;
}
/**
* URL cleanup function
* Until we have comprehensive CSRF protection, we need to sanitize URLs in emails
* to avoid CSRF attacks
*/
public function urlCleaner($attr, $value)
{
// hrefs are ok
if(strtolower($attr) == "href") return true;
$items = parse_url($value);
if(empty($items)) return false;
if(!empty($items['scheme']) && strtolower($items['scheme']) != 'http' && strtolower($items['scheme']) != 'https') {
// do not touch non-HTTP URLs
return true;
}
// don't allow relative URLs
if(empty($items['host'])) return false;
// allow URLs with no query
if(empty($items['query'])) return true;
// allow URLs that don't start with /? or /index.php?
if(!empty($items['path']) && $items['path'] != '/' && strtolower(substr($items['path'], -10)) != '/index.php') {
return true;
}
// now we have blah-blah/index.php?query - let's see if query looks dangerous
$query_items = array();
parse_str(from_html($items['query']), $query_items);
// weird query, probably harmless
if(empty($query_items)) return true;
// suspiciously like SugarCRM query, reject
if(!empty($query_items['module']) && !empty($query_items['action'])) return false;
// looks like non-download entry point - allow only specific entry points
if(!empty($query_items['entryPoint']) && !in_array($query_items['entryPoint'], array('download', 'image', 'getImage'))) {
return false;
}
return true;
}
/**
* Cleans content for XSS and other types of attack vectors
* @param string str String to clean
* @return string
*/
function cleanContent($str) {
// Safe_HTML
$this->safe->clear();
$this->safe->setUrlCallback(array($this, "urlCleaner"));
$str = $this->safe->parse($str, false);
return $this->cleanXssContent($str);
}
/**
* Cleans content for XSS
* @param string str String to clean
* @return string
*/
function cleanXssContent($str) {
$potentials = clean_xss($str, false);
if(is_array($potentials) && !empty($potentials)) {
foreach($potentials as $bad) {
$str = str_replace($bad, "", $str);
}
}
return $str;
}
/**
* Calculates the appropriate display date/time sent for an email.
* @param string headerDate The date sent of email in MIME header format
* @return string GMT-0 Unix timestamp
*/
function getUnixHeaderDate($headerDate) {
global $timedate;
if (empty($headerDate)) {
return "";
}
///////////////////////////////////////////////////////////////////
//// CALCULATE CORRECT SENT DATE/TIME FOR EMAIL
if(!empty($headerDate)) {
// Bug 25254 - Strip trailing space that come in some header dates (maybe ones with 1-digit day number)
$headerDate = trim($headerDate);
// need to hack PHP/windows' bad handling of strings when using POP3
if(strstr($headerDate,'+0000 GMT')) {
$headerDate = str_replace('GMT','', $headerDate);
} elseif(!strtotime($headerDate)) {
$headerDate = 'now'; // catch non-standard format times.
} else {
// cn: bug 9196 parse the GMT offset
if(strpos($headerDate, '-') || strpos($headerDate, '+')) {
// cn: bug make sure last 5 chars are [+|-]nnnn
if(strpos($headerDate, "(")) {
$headerDate = preg_replace('/\([\w]+\)/i', "", $headerDate);
$headerDate = trim($headerDate);
}
// parse mailserver time
$gmtEmail = trim(substr($headerDate, -5, 5));
$posNeg = substr($gmtEmail, 0, 1);
$gmtHours = substr($gmtEmail, 1, 2);
$gmtMins = substr($gmtEmail, -2, 2);
// get seconds
$secsHours = $gmtHours * 60 * 60;
$secsTotal = $secsHours + ($gmtMins * 60);
$secsTotal = ($posNeg == '-') ? $secsTotal : -1 * $secsTotal;
$headerDate = trim(substr_replace($headerDate, '', -5)); // mfh: bug 10961/12855 - date time values with GMT offsets not properly formatted
}
}
} else {
$headerDate = 'now';
}
$unixHeaderDate = strtotime($headerDate);
if(isset($secsTotal)) {
// this gets the timestamp to true GMT-0
$unixHeaderDate += $secsTotal;
}
if(strtotime('Jan 1, 2001') > $unixHeaderDate) {
$unixHeaderDate = strtotime('now');
}
return $unixHeaderDate;
//// END CALCULATE CORRECT SENT DATE/TIME FOR EMAIL
///////////////////////////////////////////////////////////////////
}
/**
* This method returns the correct messageno for the pop3 protocol
* @param String UIDL
* @return returnMsgNo
*/
function getCorrectMessageNoForPop3($messageId) {
$returnMsgNo = -1;
if ($this->protocol == 'pop3') {
if($this->pop3_open()) {
// get the UIDL from database;
$query = "SELECT msgno FROM email_cache WHERE ie_id = '{$this->id}' AND message_id = '{$messageId}'";
$r = $this->db->query($query);
$a = $this->db->fetchByAssoc($r);
$msgNo = $a['msgno'];
$returnMsgNo = $msgNo;
// authenticate
$this->pop3_sendCommand("USER", $this->email_user);
$this->pop3_sendCommand("PASS", $this->email_password);
// get UIDL for this msgNo
$this->pop3_sendCommand("UIDL {$msgNo}", '', false); // leave socket buffer alone until the while()
$buf = fgets($this->pop3socket, 1024); // handle "OK+ msgNo UIDL(UIDL for this messageno)";
// if it returns OK then we have found the message else get all the UIDL
// and search for the correct msgNo;
$foundMessageNo = false;
if (preg_match("/OK/", $buf) > 0) {
$mailserverResponse = explode(" ", $buf);
// if the cachedUIDL and the UIDL from mail server matches then its the correct messageno
if (trim($mailserverResponse[sizeof($mailserverResponse) - 1]) == $messageId) {
$foundMessageNo = true;
}
} //if
//get all the UIDL and then find the correct messageno
if (!$foundMessageNo) {
// get UIDLs
$this->pop3_sendCommand("UIDL", '', false); // leave socket buffer alone until the while()
fgets($this->pop3socket, 1024); // handle "OK+";
$UIDLs = array();
$buf = '!';
if(is_resource($this->pop3socket)) {
while(!feof($this->pop3socket)) {
$buf = fgets($this->pop3socket, 1024); // 8kb max buffer - shouldn't be more than 80 chars via pop3...
if(trim($buf) == '.') {
$GLOBALS['log']->debug("*** GOT '.'");
break;
} // if
// format is [msgNo] [UIDL]
$exUidl = explode(" ", $buf);
$UIDLs[trim($exUidl[1])] = trim($exUidl[0]);
} // while
if (array_key_exists($messageId, $UIDLs)) {
$returnMsgNo = $UIDLs[$messageId];
} else {
// message could not be found on server
$returnMsgNo = -1;
} // else
} // if
} // if
$this->pop3_cleanUp();
} //if
} //if
return $returnMsgNo;
}
/**
* If the importOneEmail returns false, then findout if the duplicate email
*/
function getDuplicateEmailId($msgNo, $uid) {
global $timedate;
global $app_strings;
global $app_list_strings;
global $sugar_config;
global $current_user;
$header = imap_headerinfo($this->conn, $msgNo);
$fullHeader = imap_fetchheader($this->conn, $msgNo); // raw headers
// reset inline images cache
$this->inlineImages = array();
// handle messages deleted on server
if(empty($header)) {
if(!isset($this->email) || empty($this->email)) {
$this->email = new Email();
} // if
return "";
} else {
$dupeCheckResult = $this->importDupeCheck($header->message_id, $header, $fullHeader);
if (!$dupeCheckResult && !empty($this->compoundMessageId)) {
// we have a duplicate email
$query = 'SELECT id FROM emails WHERE emails.message_id = \''.$this->compoundMessageId.'\' and emails.deleted = 0';
$r = $this->db->query($query, true);
$a = $this->db->fetchByAssoc($r);
$this->email = new Email();
$this->email->id = $a['id'];
return $a['id'];
} // if
return "";
} // else
} // fn
/**
* shiny new importOneEmail() method
* @param int msgNo
* @param bool forDisplay
* @param clean_email boolean, default true,
*/
function importOneEmail($msgNo, $uid, $forDisplay=false, $clean_email=true) {
$GLOBALS['log']->debug("InboundEmail processing 1 email {$msgNo}-----------------------------------------------------------------------------------------");
global $timedate;
global $app_strings;
global $app_list_strings;
global $sugar_config;
global $current_user;
// Bug # 45477
// So, on older versions of PHP (PHP VERSION < 5.3),
// calling imap_headerinfo and imap_fetchheader can cause a buffer overflow for exteremly large headers,
// This leads to the remaining messages not being read because Sugar crashes everytime it tries to read the headers.
// The workaround is to mark a message as read before making trying to read the header of the msg in question
// This forces this message not be read again, and we can continue processing remaining msgs.
// UNCOMMENT THIS IF YOU HAVE THIS PROBLEM! See notes on Bug # 45477
// $this->markEmails($uid, "read");
$header = imap_headerinfo($this->conn, $msgNo);
$fullHeader = imap_fetchheader($this->conn, $msgNo); // raw headers
// reset inline images cache
$this->inlineImages = array();
// handle messages deleted on server
if(empty($header)) {
if(!isset($this->email) || empty($this->email)) {
$this->email = new Email();
}
$q = "";
if ($this->isPop3Protocol()) {
$this->email->name = $app_strings['LBL_EMAIL_ERROR_MESSAGE_DELETED'];
$q = "DELETE FROM email_cache WHERE message_id = '{$uid}' AND ie_id = '{$this->id}' AND mbox = '{$this->mailbox}'";
} else {
$this->email->name = $app_strings['LBL_EMAIL_ERROR_IMAP_MESSAGE_DELETED'];
$q = "DELETE FROM email_cache WHERE imap_uid = {$uid} AND ie_id = '{$this->id}' AND mbox = '{$this->mailbox}'";
} // else
// delete local cache
$r = $this->db->query($q);
$this->email->date_sent = $timedate->nowDb();
return false;
//return "Message deleted from server.";
}
///////////////////////////////////////////////////////////////////////
//// DUPLICATE CHECK
$dupeCheckResult = $this->importDupeCheck($header->message_id, $header, $fullHeader);
if($forDisplay || $dupeCheckResult) {
$GLOBALS['log']->debug('*********** NO duplicate found, continuing with processing.');
$structure = imap_fetchstructure($this->conn, $msgNo); // map of email
///////////////////////////////////////////////////////////////////
//// CREATE SEED EMAIL OBJECT
$email = new Email();
$email->isDuplicate = ($dupeCheckResult) ? false : true;
$email->mailbox_id = $this->id;
$message = array();
$email->id = create_guid();
$email->new_with_id = true; //forcing a GUID here to prevent double saves.
//// END CREATE SEED EMAIL
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//// PREP SYSTEM USER
if(empty($current_user)) {
// I-E runs as admin, get admin prefs
$current_user = new User();
$current_user->getSystemUser();
}
$tPref = $current_user->getUserDateTimePreferences();
//// END USER PREP
///////////////////////////////////////////////////////////////////
if(!empty($header->date)) {
$unixHeaderDate = $timedate->fromString($header->date);
}
///////////////////////////////////////////////////////////////////
//// HANDLE EMAIL ATTACHEMENTS OR HTML TEXT
//// Inline images require that I-E handle attachments before body text
// parts defines attachments - be mindful of .html being interpreted as an attachment
if($structure->type == 1 && !empty($structure->parts)) {
$GLOBALS['log']->debug('InboundEmail found multipart email - saving attachments if found.');
$this->saveAttachments($msgNo, $structure->parts, $email->id, 0, $forDisplay);
} elseif($structure->type == 0) {
$uuemail = ($this->isUuencode($email->description)) ? true : false;
/*
* UUEncoded attachments - legacy, but still have to deal with it
* format:
* begin 777 filename.txt
* UUENCODE
*
* end
*/
// set body to the filtered one
if($uuemail) {
$email->description = $this->handleUUEncodedEmailBody($email->description, $email->id);
$email->retrieve($email->id);
$email->save();
}
} else {
if($this->port != 110) {
$GLOBALS['log']->debug('InboundEmail found a multi-part email (id:'.$msgNo.') with no child parts to parse.');
}
}
//// END HANDLE EMAIL ATTACHEMENTS OR HTML TEXT
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//// ASSIGN APPROPRIATE ATTRIBUTES TO NEW EMAIL OBJECT
// handle UTF-8/charset encoding in the ***headers***
global $db;
$email->name = $this->handleMimeHeaderDecode($header->subject);
$email->date_start = (!empty($unixHeaderDate)) ? $timedate->asUserDate($unixHeaderDate) : "";
$email->time_start = (!empty($unixHeaderDate)) ? $timedate->asUserTime($unixHeaderDate) : "";
$email->type = 'inbound';
$email->date_created = (!empty($unixHeaderDate)) ? $timedate->asUser($unixHeaderDate) : "";
$email->status = 'unread'; // this is used in Contacts' Emails SubPanel
if(!empty($header->toaddress)) {
$email->to_name = $this->handleMimeHeaderDecode($header->toaddress);
$email->to_addrs_names = $email->to_name;
}
if(!empty($header->to)) {
$email->to_addrs = $this->convertImapToSugarEmailAddress($header->to);
}
$email->from_name = $this->handleMimeHeaderDecode($header->fromaddress);
$email->from_addr_name = $email->from_name;
$email->from_addr = $this->convertImapToSugarEmailAddress($header->from);
if(!empty($header->cc)) {
$email->cc_addrs = $this->convertImapToSugarEmailAddress($header->cc);
}
if(!empty($header->ccaddress)) {
$email->cc_addrs_names = $this->handleMimeHeaderDecode($header->ccaddress);
} // if
$email->reply_to_name = $this->handleMimeHeaderDecode($header->reply_toaddress);
$email->reply_to_email = $this->convertImapToSugarEmailAddress($header->reply_to);
if (!empty($email->reply_to_email)) {
$email->reply_to_addr = $email->reply_to_name;
}
$email->intent = $this->mailbox_type;
$email->message_id = $this->compoundMessageId; // filled by importDupeCheck();
$oldPrefix = $this->imagePrefix;
if(!$forDisplay) {
// Store CIDs in imported messages, convert on display
$this->imagePrefix = "cid:";
}
// handle multi-part email bodies
$email->description_html= $this->getMessageText($msgNo, 'HTML', $structure, $fullHeader,$clean_email); // runs through handleTranserEncoding() already
$email->description = $this->getMessageText($msgNo, 'PLAIN', $structure, $fullHeader,$clean_email); // runs through handleTranserEncoding() already
$this->imagePrefix = $oldPrefix;
// empty() check for body content
if(empty($email->description)) {
$GLOBALS['log']->debug('InboundEmail Message (id:'.$email->message_id.') has no body');
}
// assign_to group
if (!empty($_REQUEST['user_id'])) {
$email->assigned_user_id = $_REQUEST['user_id'];
} else {
// Samir Gandhi : Commented out this code as its not needed
//$email->assigned_user_id = $this->group_id;
}
//Assign Parent Values if set
if (!empty($_REQUEST['parent_id']) && !empty($_REQUEST['parent_type'])) {
$email->parent_id = $_REQUEST['parent_id'];
$email->parent_type = $_REQUEST['parent_type'];
$mod = strtolower($email->parent_type);
$rel = array_key_exists($mod, $email->field_defs) ? $mod : $mod . "_activities_emails"; //Custom modules rel name
if(! $email->load_relationship($rel) )
return FALSE;
$email->$rel->add($email->parent_id);
}
// override $forDisplay w/user pref
if($forDisplay) {
if($this->isAutoImport()) {
$forDisplay = false; // triggers save of imported email
}
}
if(!$forDisplay) {
$email->save();
$email->new_with_id = false; // to allow future saves by UPDATE, instead of INSERT
//// ASSIGN APPROPRIATE ATTRIBUTES TO NEW EMAIL OBJECT
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//// LINK APPROPRIATE BEANS TO NEWLY SAVED EMAIL
//$contactAddr = $this->handleLinking($email);
//// END LINK APPROPRIATE BEANS TO NEWLY SAVED EMAIL
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//// MAILBOX TYPE HANDLING
$this->handleMailboxType($email, $header);
//// END MAILBOX TYPE HANDLING
///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//// SEND AUTORESPONSE
if(!empty($email->reply_to_email)) {
$contactAddr = $email->reply_to_email;
} else {
$contactAddr = $email->from_addr;
}
if (!$this->isMailBoxTypeCreateCase()) {
$this->handleAutoresponse($email, $contactAddr);
}
//// END SEND AUTORESPONSE
///////////////////////////////////////////////////////////////////
//// END IMPORT ONE EMAIL
///////////////////////////////////////////////////////////////////
}
} else {
// only log if not POP3; pop3 iterates through ALL mail
if($this->protocol != 'pop3') {
$GLOBALS['log']->info("InboundEmail found a duplicate email: ".$header->message_id);
//echo "This email has already been imported";
}
return false;
}
//// END DUPLICATE CHECK
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
//// DEAL WITH THE MAILBOX
if(!$forDisplay) {
imap_setflag_full($this->conn, $msgNo, '\\SEEN');
// if delete_seen, mark msg as deleted
if($this->delete_seen == 1 && !$forDisplay) {
$GLOBALS['log']->info("INBOUNDEMAIL: delete_seen == 1 - deleting email");
imap_setflag_full($this->conn, $msgNo, '\\DELETED');
}
} else {
// for display - don't touch server files?
//imap_setflag_full($this->conn, $msgNo, '\\UNSEEN');
}
$GLOBALS['log']->debug('********************************* InboundEmail finished import of 1 email: '.$email->name);
//// END DEAL WITH THE MAILBOX
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
//// TO SUPPORT EMAIL 2.0
$this->email = $email;
if(empty($this->email->et)) {
$this->email->email2init();
}
return true;
}
/**
* figures out if a plain text email body has UUEncoded attachments
* @param string string The email body
* @return bool True if UUEncode is detected.
*/
function isUuencode($string) {
$rx = "begin [0-9]{3} .*";
$exBody = explode("\r", $string);
foreach($exBody as $line) {
if(preg_match("/begin [0-9]{3} .*/i", $line)) {
return true;
}
}
return false;
}
/**
* handles UU Encoded emails - a legacy from pre-RFC 822 which must still be supported (?)
* @param string raw The raw email body
* @param string id Parent email ID
* @return string The filtered email body, stripped of attachments
*/
function handleUUEncodedEmailBody($raw, $id) {
global $locale;
$emailBody = '';
$attachmentBody = '';
$inAttachment = false;
$exRaw = explode("\n", $raw);
foreach($exRaw as $k => $line) {
$line = trim($line);
if(preg_match("/begin [0-9]{3} .*/i", $line, $m)) {
$inAttachment = true;
$fileName = $this->handleEncodedFilename(substr($m[0], 10, strlen($m[0])));
$attachmentBody = ''; // reset for next part of loop;
continue;
}
// handle "end"
if(strpos($line, "end") === 0) {
if(!empty($fileName) && !empty($attachmentBody)) {
$this->handleUUDecode($id, $fileName, trim($attachmentBody));
$attachmentBody = ''; // reset for next part of loop;
}
}
if($inAttachment === false) {
$emailBody .= "\n".$line;
} else {
$attachmentBody .= "\n".$line;
}
}
/* since UUEncode was developed before MIME, we have NO idea what character set encoding was used. we will assume the user's locale character set */
$emailBody = $locale->translateCharset($emailBody, $locale->getExportCharset(), 'UTF-8');
return $emailBody;
}
/**
* wrapper for UUDecode
* @param string id Id of the email
* @param string UUEncode Encode US-ASCII
*/
function handleUUDecode($id, $fileName, $UUEncode) {
global $sugar_config;
/* include PHP_Compat library; it auto-feels for PHP5's compiled convert_uuencode() function */
require_once('include/PHP_Compat/convert_uudecode.php');
$attach = new Note();
$attach->parent_id = $id;
$attach->parent_type = 'Emails';
$fname = $this->handleEncodedFilename($fileName);
if(!empty($fname)) {//assign name to attachment
$attach->name = $fname;
} else {//if name is empty, default to filename
$attach->name = urlencode($fileName);
}
$attach->filename = urlencode($attach->name);
//get position of last "." in file name
$file_ext_beg = strrpos($attach->filename,".");
$file_ext = "";
//get file extension
if($file_ext_beg >0) {
$file_ext = substr($attach->filename, $file_ext_beg+1);
}
//check to see if this is a file with extension located in "badext"
foreach($sugar_config['upload_badext'] as $badExt) {
if(strtolower($file_ext) == strtolower($badExt)) {
//if found, then append with .txt and break out of lookup
$attach->name = $attach->name . ".txt";
$attach->file_mime_type = 'text/';
$attach->filename = $attach->filename . ".txt";
break; // no need to look for more
}
}
$attach->save();
$bin = convert_uudecode($UUEncode);
$filename = "upload://{$attach->id}";
if(file_put_contents($filename, $bin)) {
$GLOBALS['log']->debug('InboundEmail saved attachment file: '.$filename);
} else {
$GLOBALS['log']->debug('InboundEmail could not create attachment file: '.$filename);
}
}
/**
* returns true if the email's domain is NOT in the filter domain string
*
* @param object email Email object in question
* @return bool true if not filtered, false if filtered
*/
function checkFilterDomain($email) {
$filterDomain = $this->get_stored_options('filter_domain');
if(!isset($filterDomain) || empty($filterDomain)) {
return true; // nothing set for this
} else {
$replyTo = strtolower($email->reply_to_email);
$from = strtolower($email->from_addr);
$filterDomain = '@'.strtolower($filterDomain);
if(strpos($replyTo, $filterDomain) !== false) {
$GLOBALS['log']->debug('Autoreply cancelled - [reply to] address domain matches filter domain.');
return false;
} elseif(strpos($from, $filterDomain) !== false) {
$GLOBALS['log']->debug('Autoreply cancelled - [from] address domain matches filter domain.');
return false;
} else {
return true; // no match
}
}
}
/**
* returns true if subject is NOT "out of the office" type
*
* @param string subject Subject line of email in question
* @return bool returns false if OOTO found
*/
function checkOutOfOffice($subject) {
$ooto = array("Out of the Office", "Out of Office");
foreach($ooto as $str) {
if(preg_match('/'.$str.'/i', $subject)) {
$GLOBALS['log']->debug('Autoreply cancelled - found "Out of Office" type of subject.');
return false;
}
}
return true; // no matches to ooto strings
}
/**
* sets a timestamp for an autoreply to a single email addy
*
* @param string addr Address of auto-replied target
*/
function setAutoreplyStatus($addr) {
$timedate = TimeDate::getInstance();
$this->db->query( 'INSERT INTO inbound_email_autoreply (id, deleted, date_entered, date_modified, autoreplied_to, ie_id) VALUES (
\''.create_guid().'\',
0,
\''.$timedate->nowDb().'\',
\''.$timedate->nowDb().'\',
\''.$addr.'\',
\''.$this->id.'\') ', true);
}
/**
* returns true if recipient has NOT received 10 auto-replies in 24 hours
*
* @param string from target address for auto-reply
* @return bool true if target is valid/under limit
*/
function getAutoreplyStatus($from) {
global $sugar_config;
$timedate = TimeDate::getInstance();
$q_clean = 'UPDATE inbound_email_autoreply SET deleted = 1 WHERE date_entered < \''.$timedate->getNow()->modify("-24 hours")->asDb().'\'';
$r_clean = $this->db->query($q_clean, true);
$q = 'SELECT count(*) AS c FROM inbound_email_autoreply WHERE deleted = 0 AND autoreplied_to = \''.$from.'\' AND ie_id = \''.$this->id.'\'';
$r = $this->db->query($q, true);
$a = $this->db->fetchByAssoc($r);
$email_num_autoreplies_24_hours = $this->get_stored_options('email_num_autoreplies_24_hours');
$maxReplies = (isset($email_num_autoreplies_24_hours)) ? $email_num_autoreplies_24_hours : $this->maxEmailNumAutoreplies24Hours;
if($a['c'] >= $maxReplies) {
$GLOBALS['log']->debug('Autoreply cancelled - more than ' . $maxReplies . ' replies sent in 24 hours.');
return false;
} else {
return true;
}
}
/**
* returns exactly 1 id match. if more than one, than returns false
* @param $emailName the subject of the email to match
* @param $tableName the table of the matching bean type
*/
function getSingularRelatedId($emailName, $tableName) {
$repStrings = array('RE:','Re:','re:');
$preppedName = str_replace($repStrings,'',trim($emailName));
//TODO add team security to this query
$q = 'SELECT count(id) AS c FROM '.$tableName.' WHERE deleted = 0 AND name LIKE \'%'.$preppedName.'%\'';
$r = $this->db->query($q, true);
$a = $this->db->fetchByAssoc($r);
if($a['c'] == 0) {
$q = 'SELECT id FROM '.$tableName.' WHERE deleted = 0 AND name LIKE \'%'.$preppedName.'%\'';
$r = $this->db->query($q, true);
$a = $this->db->fetchByAssoc($r);
return $a['id'];
} else {
return false;
}
}
/**
* saves InboundEmail parse macros to config.php
* @param string type Bean to link
* @param string macro The new macro
*/
function saveInboundEmailSystemSettings($type, $macro) {
global $sugar_config;
// inbound_email_case_subject_macro
$var = "inbound_email_".strtolower($type)."_subject_macro";
$sugar_config[$var] = $macro;
ksort($sugar_config);
$sugar_config_string = "\n";
write_array_to_file("sugar_config", $sugar_config, "config.php");
}
/**
* returns the HTML for InboundEmail system settings
* @return string HTML
*/
function getSystemSettingsForm() {
global $sugar_config;
global $mod_strings;
global $app_strings;
global $app_list_strings;
//// Case Macro
$c = new aCase();
$macro = $c->getEmailSubjectMacro();
$ret =<<
eoq;
return $ret;
}
/**
* for mailboxes of type "Support" parse for '[CASE:%1]'
* @param $emailName the subject line of the email
* @param $aCase a Case object
*/
function getCaseIdFromCaseNumber($emailName, $aCase) {
//$emailSubjectMacro
$exMacro = explode('%1', $aCase->getEmailSubjectMacro());
$open = $exMacro[0];
$close = $exMacro[1];
if($sub = stristr($emailName, $open)) { // eliminate everything up to the beginning of the macro and return the rest
// $sub is [CASE:XX] xxxxxxxxxxxxxxxxxxxxxx
$sub2 = str_replace($open, '', $sub);
// $sub2 is XX] xxxxxxxxxxxxxx
$sub3 = substr($sub2, 0, strpos($sub2, $close));
$r = $this->db->query("SELECT id FROM cases WHERE case_number = '{$sub3}'", true);
$a = $this->db->fetchByAssoc($r);
if(!empty($a['id'])) {
return $a['id'];
} else {
return false;
}
} else {
return false;
}
}
function get_stored_options($option_name,$default_value=null,$stored_options=null) {
if (empty($stored_options)) {
$stored_options=$this->stored_options;
}
if(!empty($stored_options)) {
$storedOptions = unserialize(base64_decode($stored_options));
if (isset($storedOptions[$option_name])) {
$default_value=$storedOptions[$option_name];
}
}
return $default_value;
}
/**
* This function returns a contact or user ID if a matching email is found
* @param $email the email address to match
* @param $table which table to query
*/
function getRelatedId($email, $module) {
$email = trim(strtoupper($email));
if(strpos($email, ',') !== false) {
$emailsArray = explode(',', $email);
$emailAddressString = "";
foreach($emailsArray as $emailAddress) {
if (!empty($emailAddressString)) {
$emailAddressString .= ",";
}
$emailAddressString .= "'" . $emailAddress. "'";
} // foreach
$email = $emailAddressString;
} else {
$email = "'" . $email . "'";
} // else
$module = ucfirst($module);
$q = "SELECT bean_id FROM email_addr_bean_rel eabr
JOIN email_addresses ea ON (eabr.email_address_id = ea.id)
WHERE bean_module = '{$module}' AND ea.email_address_caps in ( {$email} ) AND eabr.deleted=0";
$r = $this->db->query($q, true);
$retArr = array();
while($a = $this->db->fetchByAssoc($r)) {
$retArr[] = $a['bean_id'];
}
if(count($retArr) > 0) {
return $retArr;
} else {
return false;
}
}
/**
* finds emails tagged "//UNSEEN" on mailserver and "SINCE: [date]" if that
* option is set
*
* @return array Array of messageNumbers (mail server's internal keys)
*/
function getNewMessageIds() {
$storedOptions = unserialize(base64_decode($this->stored_options));
//TODO figure out if the since date is UDT
if($storedOptions['only_since']) {// POP3 does not support Unseen flags
if(!isset($storedOptions['only_since_last']) && !empty($storedOptions['only_since_last'])) {
$q = 'SELECT last_run FROM schedulers WHERE job = \'function::pollMonitoredInboxes\'';
$r = $this->db->query($q, true);
$a = $this->db->fetchByAssoc($r);
$date = date('r', strtotime($a['last_run']));
} else {
$date = $storedOptions['only_since_last'];
}
$ret = imap_search($this->conn, 'SINCE "'.$date.'" UNDELETED UNSEEN');
$check = imap_check($this->conn);
$storedOptions['only_since_last'] = $check->Date;
$this->stored_options = base64_encode(serialize($storedOptions));
$this->save();
} else {
$ret = imap_search($this->conn, 'UNDELETED UNSEEN');
}
$GLOBALS['log']->debug('-----> getNewMessageIds() got '.count($ret).' new Messages');
return $ret;
}
/**
* Constructs the resource connection string that IMAP needs
* @param string $service Service string, will generate if not passed
* @return string
*/
function getConnectString($service='', $mbox='', $includeMbox=true) {
$service = empty($service) ? $this->getServiceString() : $service;
$mbox = empty($mbox) ? $this->mailbox : $mbox;
$connectString = '{'.$this->server_url.':'.$this->port.'/service='.$this->protocol.$service.'}';
$connectString .= ($includeMbox) ? $mbox : "";
return $connectString;
}
function disconnectMailserver() {
if(is_resource($this->conn)) {
imap_close($this->conn);
}
}
/**
* Connects to mailserver. If an existing IMAP resource is available, it
* will attempt to reuse the connection, updating the mailbox path.
*
* @param bool test Flag to test connection
* @param bool force Force reconnect
* @return string "true" on success, "false" or $errorMessage on failure
*/
function connectMailserver($test=false, $force=false) {
global $mod_strings;
if(!function_exists("imap_open")) {
$GLOBALS['log']->debug('------------------------- IMAP libraries NOT available!!!! die()ing thread.----');
return $mod_strings['LBL_WARN_NO_IMAP'];
}
imap_errors(); // clearing error stack
error_reporting(0); // turn off notices from IMAP
// tls::ca::ssl::protocol::novalidate-cert::notls
$useSsl = ($_REQUEST['ssl'] == 'true') ? true : false;
if($test) {
imap_timeout(1, 15); // 60 secs is the default
imap_timeout(2, 15);
imap_timeout(3, 15);
$opts = $this->findOptimumSettings($useSsl);
if(isset($opts['good']) && empty($opts['good'])) {
return array_pop($opts['err']);
} else {
$service = $opts['service'];
$service = str_replace('foo','', $service); // foo there to support no-item explodes
}
} else {
$service = $this->getServiceString();
}
$connectString = $this->getConnectString($service, $this->mailbox);
/*
* Try to recycle the current connection to reduce response times
*/
if(is_resource($this->conn)) {
if($force) {
// force disconnect
imap_close($this->conn);
}
if(imap_ping($this->conn)) {
// we have a live connection
imap_reopen($this->conn, $connectString, CL_EXPUNGE);
}
}
// final test
if(!is_resource($this->conn) && !$test) {
$this->conn = imap_open($connectString, $this->email_user, $this->email_password, CL_EXPUNGE);
}
if($test) {
if ($opts == false && !is_resource($this->conn)) {
$this->conn = imap_open($connectString, $this->email_user, $this->email_password, CL_EXPUNGE);
}
$errors = '';
$alerts = '';
$successful = false;
if(($errors = imap_last_error()) || ($alerts = imap_alerts())) {
if($errors == 'Mailbox is empty') { // false positive
$successful = true;
} else {
$msg .= $errors;
$msg .= ''.$alerts.'
';
$msg .= '
'.$mod_strings['ERR_TEST_MAILBOX'];
}
} else {
$successful = true;
}
if($successful) {
if($this->protocol == 'imap') {
$msg .= $mod_strings['LBL_TEST_SUCCESSFUL'];
/*
$testConnectString = '{'.$this->server_url.':'.$this->port.'/service='.$this->protocol.$service.'}';
if (!is_resource($this->conn)) {
$this->conn = imap_open($connectString, $this->email_user, $this->email_password, CL_EXPUNGE);
}
$list = imap_getmailboxes($this->conn, $testConnectString, "*");
if(isset($_REQUEST['personal']) && $_REQUEST['personal'] == 'true') {
$msg .= $mod_strings['LBL_TEST_SUCCESSFUL'];
} elseif (is_array($list)) {
sort($list);
_ppd($boxes);
$msg .= ''.$mod_strings['LBL_FOUND_MAILBOXES'].'
';
foreach ($list as $key => $val) {
$mb = imap_utf7_decode(str_replace($testConnectString,'',$val->name));
$msg .= '';
$msg .= $mb;
$msg .= '
';
}
} else {
$msg .= $errors;
$msg .= '
'.$mod_strings['ERR_MAILBOX_FAIL'].imap_last_error().'
';
$msg .= ''.$mod_strings['ERR_TEST_MAILBOX'].'
';
}
*/
} else {
$msg .= $mod_strings['LBL_POP3_SUCCESS'];
}
}
imap_errors(); // collapse error stack
imap_close($this->conn);
return $msg;
} elseif(!is_resource($this->conn)) {
return "false";
} else {
return "true";
}
}
function checkImap() {
global $mod_strings;
if(!function_exists('imap_open')) {
echo '
|
'.$mod_strings['LBL_WARN_IMAP_TITLE'].'
|
'.$mod_strings['LBL_WARN_IMAP'].'
|
'.$mod_strings['LBL_WARN_NO_IMAP'].'
|
|
';
}
}
/**
* retrieves an array of I-E beans based on the group_id
* @param string $groupId GUID of the group user or Individual
* @return array $beans array of beans
* @return boolean false if none returned
*/
function retrieveByGroupId($groupId) {
$q = 'SELECT id FROM inbound_email WHERE group_id = \''.$groupId.'\' AND deleted = 0 AND status = \'Active\'';
$r = $this->db->query($q, true);
$beans = array();
while($a = $this->db->fetchByAssoc($r)) {
$ie = new InboundEmail();
$ie->retrieve($a['id']);
$beans[$a['id']] = $ie;
}
return $beans;
}
/**
* Retrieves the current count of personal accounts for the user specified.
*
* @param unknown_type $user
*/
function getUserPersonalAccountCount($user = null)
{
if($user == null)
$user = $GLOBALS['current_user'];
$query = "SELECT count(*) as c FROM inbound_email WHERE deleted=0 AND is_personal='1' AND group_id='{$user->id}' AND status='Active'";
$rs = $this->db->query($query);
$row = $this->db->fetchByAssoc($rs);
return $row['c'];
}
/**
* retrieves an array of I-E beans based on the group folder id
* @param string $groupFolderId GUID of the group folder
* @return array $beans array of beans
* @return boolean false if none returned
*/
function retrieveByGroupFolderId($groupFolderId) {
$q = 'SELECT id FROM inbound_email WHERE groupfolder_id = \''.$groupFolderId.'\' AND deleted = 0 ';
$r = $this->db->query($q, true);
$beans = array();
while($a = $this->db->fetchByAssoc($r)) {
$ie = new InboundEmail();
$ie->retrieve($a['id']);
$beans[] = $ie;
}
return $beans;
}
/**
* Retrieves an array of I-E beans that the user has team access to
*/
function retrieveAllByGroupId($id, $includePersonal=true) {
global $current_user;
$beans = ($includePersonal) ? $this->retrieveByGroupId($id) : array();
$teamJoin = '';
$q = "SELECT inbound_email.id FROM inbound_email {$teamJoin} WHERE is_personal = 0 AND groupfolder_id is null AND mailbox_type not like 'bounce' AND inbound_email.deleted = 0 AND status = 'Active' ";
$r = $this->db->query($q, true);
while($a = $this->db->fetchByAssoc($r)) {
$found = false;
foreach($beans as $bean) {
if($bean->id == $a['id']) {
$found = true;
}
}
if(!$found) {
$ie = new InboundEmail();
$ie->retrieve($a['id']);
$beans[$a['id']] = $ie;
}
}
return $beans;
}
/**
* Retrieves an array of I-E beans that the user has team access to including group
*/
function retrieveAllByGroupIdWithGroupAccounts($id, $includePersonal=true) {
global $current_user;
$beans = ($includePersonal) ? $this->retrieveByGroupId($id) : array();
$teamJoin = '';
$q = "SELECT DISTINCT inbound_email.id FROM inbound_email {$teamJoin} WHERE is_personal = 0 AND mailbox_type not like 'bounce' AND status = 'Active' AND inbound_email.deleted = 0 ";
$r = $this->db->query($q, true);
while($a = $this->db->fetchByAssoc($r)) {
$found = false;
foreach($beans as $bean) {
if($bean->id == $a['id']) {
$found = true;
}
}
if(!$found) {
$ie = new InboundEmail();
$ie->retrieve($a['id']);
$beans[$a['id']] = $ie;
}
}
return $beans;
}
/**
* returns the bean name - overrides SugarBean's
*/
function get_summary_text() {
return $this->name;
}
/**
* Override's SugarBean's
*/
function create_export_query($order_by, $where, $show_deleted = 0) {
return $this->create_new_list_query($order_by, $where, $show_deleted = 0);
}
/**
* Override's SugarBean's
*/
/**
* Override's SugarBean's
*/
function get_list_view_data(){
global $mod_strings;
global $app_list_strings;
$temp_array = $this->get_list_view_array();
$temp_array['MAILBOX_TYPE_NAME']= $app_list_strings['dom_mailbox_type'][$this->mailbox_type];
//cma, fix bug 21670.
$temp_array['GLOBAL_PERSONAL_STRING']= ($this->is_personal ? $mod_strings['LBL_IS_PERSONAL'] : $mod_strings['LBL_IS_GROUP']);
$temp_array['STATUS'] = ($this->status == 'Active') ? $mod_strings['LBL_STATUS_ACTIVE'] : $mod_strings['LBL_STATUS_INACTIVE'];
return $temp_array;
}
/**
* Override's SugarBean's
*/
function fill_in_additional_list_fields() {
$this->fill_in_additional_detail_fields();
}
/**
* Override's SugarBean's
*/
function fill_in_additional_detail_fields() {
if(!empty($this->service)) {
$exServ = explode('::', $this->service);
$this->tls = $exServ[0];
if ( isset($exServ[1]) )
$this->ca = $exServ[1];
if ( isset($exServ[2]) )
$this->ssl = $exServ[2];
if ( isset($exServ[3]) )
$this->protocol = $exServ[3];
}
}
///////////////////////////////////////////////////////////////////////////
//// IN SUPPORT OF EMAIL 2.0
/**
* Checks for $user's autoImport setting and returns the current value
* @param object $user User in focus, defaults to $current_user
* @return bool
*/
function isAutoImport($user=null) {
if(!empty($this->autoImport)) {
return $this->autoImport;
}
global $current_user;
if(empty($user)) $user = $current_user;
$emailSettings = $current_user->getPreference('emailSettings', 'Emails');
$emailSettings = is_string($emailSettings) ? unserialize($emailSettings) : $emailSettings;
$this->autoImport = (isset($emailSettings['autoImport']) && !empty($emailSettings['autoImport'])) ? true : false;
return $this->autoImport;
}
/**
* Clears out cache files for a user
*/
function cleanOutCache() {
$GLOBALS['log']->debug("INBOUNDEMAIL: at cleanOutCache()");
$this->deleteCache();
}
/**
* moves emails from folder to folder
* @param string $fromIe I-E id
* @param string $fromFolder IMAP path to folder in which the email lives
* @param string $toIe I-E id
* @param string $toFolder
* @param string $uids UIDs of emails to move, either Sugar GUIDS or IMAP
* UIDs
*/
function copyEmails($fromIe, $fromFolder, $toIe, $toFolder, $uids) {
$this->moveEmails($fromIe, $fromFolder, $toIe, $toFolder, $uids, true);
}
/**
* moves emails from folder to folder
* @param string $fromIe I-E id
* @param string $fromFolder IMAP path to folder in which the email lives
* @param string $toIe I-E id
* @param string $toFolder
* @param string $uids UIDs of emails to move, either Sugar GUIDS or IMAP
* UIDs
* @param bool $copy Default false
* @return bool True on successful execution
*/
function moveEmails($fromIe, $fromFolder, $toIe, $toFolder, $uids, $copy=false) {
global $app_strings;
global $current_user;
// same I-E server
if($fromIe == $toIe) {
$GLOBALS['log']->debug("********* SUGARFOLDER - moveEmails() moving email from I-E to I-E");
//$exDestFolder = explode("::", $toFolder);
//preserve $this->mailbox
if (isset($this->mailbox)) {
$oldMailbox = $this->mailbox;
}
$this->retrieve($fromIe);
$this->mailbox = $fromFolder;
$this->connectMailserver();
$exUids = explode('::;::', $uids);
$uids = implode(",", $exUids);
// imap_mail_move accepts comma-delimited lists of UIDs
if($copy) {
if(imap_mail_copy($this->conn, $uids, $toFolder, CP_UID)) {
$this->mailbox = $toFolder;
$this->connectMailserver();
$newOverviews = imap_fetch_overview($this->conn, $uids, FT_UID);
$this->updateOverviewCacheFile($newOverviews, 'append');
if (isset($oldMailbox)) {
$this->mailbox = $oldMailbox;
}
return true;
} else {
$GLOBALS['log']->debug("INBOUNDEMAIL: could not imap_mail_copy() [ {$uids} ] to folder [ {$toFolder} ] from folder [ {$fromFolder} ]");
}
} else {
if(imap_mail_move($this->conn, $uids, $toFolder, CP_UID)) {
$GLOBALS['log']->info("INBOUNDEMAIL: imap_mail_move() [ {$uids} ] to folder [ {$toFolder} ] from folder [ {$fromFolder} ]");
imap_expunge($this->conn); // hard deletes moved messages
// update cache on fromFolder
$newOverviews = $this->getOverviewsFromCacheFile($uids, $fromFolder, true);
$this->deleteCachedMessages($uids, $fromFolder);
// update cache on toFolder
$this->checkEmailOneMailbox($toFolder, true, true);
if (isset($oldMailbox)) {
$this->mailbox = $oldMailbox;
}
return true;
} else {
$GLOBALS['log']->debug("INBOUNDEMAIL: could not imap_mail_move() [ {$uids} ] to folder [ {$toFolder} ] from folder [ {$fromFolder} ]");
}
}
} elseif($toIe == 'folder' && $fromFolder == 'sugar::Emails') {
$GLOBALS['log']->debug("********* SUGARFOLDER - moveEmails() moving email from SugarFolder to SugarFolder");
// move from sugar folder to sugar folder
require_once("include/SugarFolders/SugarFolders.php");
$sugarFolder = new SugarFolder();
$exUids = explode($app_strings['LBL_EMAIL_DELIMITER'], $uids);
foreach($exUids as $id) {
if($copy) {
$sugarFolder->copyBean($fromIe, $toFolder, $id, "Emails");
} else {
$fromSugarFolder = new SugarFolder();
$fromSugarFolder->retrieve($fromIe);
$toSugarFolder = new SugarFolder();
$toSugarFolder->retrieve($toFolder);
$email = new Email();
$email->retrieve($id);
$email->status = 'unread';
// when you move from My Emails to Group Folder, Assign To field for the Email should become null
if ($fromSugarFolder->is_dynamic && $toSugarFolder->is_group) {
$email->assigned_user_id = "";
$email->save();
if (!$toSugarFolder->checkEmailExistForFolder($id)) {
$fromSugarFolder->deleteEmailFromAllFolder($id);
$toSugarFolder->addBean($email);
}
} elseif ($fromSugarFolder->is_group && $toSugarFolder->is_dynamic) {
$fromSugarFolder->deleteEmailFromAllFolder($id);
$email->assigned_user_id = $current_user->id;
$email->save();
} else {
// If you are moving something from personal folder then delete an entry from all folder
if (!$fromSugarFolder->is_dynamic && !$fromSugarFolder->is_group) {
$fromSugarFolder->deleteEmailFromAllFolder($id);
} // if
if ($fromSugarFolder->is_dynamic && !$toSugarFolder->is_dynamic && !$toSugarFolder->is_group) {
$email->assigned_user_id = "";
$toSugarFolder->addBean($email);
} // if
if (!$toSugarFolder->checkEmailExistForFolder($id)) {
if (!$toSugarFolder->is_dynamic) {
$fromSugarFolder->deleteEmailFromAllFolder($id);
$toSugarFolder->addBean($email);
} else {
$fromSugarFolder->deleteEmailFromAllFolder($id);
$email->assigned_user_id = $current_user->id;
}
} else {
$sugarFolder->move($fromIe, $toFolder, $id);
} // else
$email->save();
} // else
}
}
return true;
} elseif($toIe == 'folder') {
$GLOBALS['log']->debug("********* SUGARFOLDER - moveEmails() moving email from I-E to SugarFolder");
// move to Sugar folder
require_once("include/SugarFolders/SugarFolders.php");
$sugarFolder = new SugarFolder();
$sugarFolder->retrieve($toFolder);
//Show the import form if we don't have the required info
if (!isset($_REQUEST['delete'])) {
$json = getJSONobj();
if ($sugarFolder->is_group) {
$_REQUEST['showTeam'] = false;
$_REQUEST['showAssignTo'] = false;
}
$ret = $this->email->et->getImportForm($_REQUEST, $this->email);
$ret['move'] = true;
$ret['srcFolder'] = $fromFolder;
$ret['srcIeId'] = $fromIe;
$ret['dstFolder'] = $toFolder;
$ret['dstIeId'] = $toIe;
$out = trim($json->encode($ret, false));
echo $out;
return true;
}
// import to Sugar
$this->retrieve($fromIe);
$this->mailbox = $fromFolder;
$this->connectMailserver();
// If its a group folder the team should be of the folder team
if ($sugarFolder->is_group) {
$_REQUEST['team_id'] = $sugarFolder->team_id;
$_REQUEST['team_set_id'] = $sugarFolder->team_set_id;
} else {
// TODO - set team_id, team_set for new UI
} // else
$exUids = explode($app_strings['LBL_EMAIL_DELIMITER'], $uids);
if(!empty($sugarFolder->id)) {
$count = 1;
$return = array();
$json = getJSONobj();
foreach($exUids as $k => $uid) {
$msgNo = $uid;
if ($this->isPop3Protocol()) {
$msgNo = $this->getCorrectMessageNoForPop3($uid);
} else {
$msgNo = imap_msgno($this->conn, $uid);
}
if(!empty($msgNo)) {
$importStatus = $this->importOneEmail($msgNo, $uid);
// add to folder
if($importStatus) {
$sugarFolder->addBean($this->email);
if(!$copy && isset($_REQUEST['delete']) && ($_REQUEST['delete'] == "true") && $importStatus) {
$GLOBALS['log']->error("********* delete from mailserver [ {explode(",", $uids)} ]");
// delete from mailserver
$this->deleteMessageOnMailServer($uid);
$this->deleteMessageFromCache($uid);
} // if
}
$return[] = $app_strings['LBL_EMAIL_MESSAGE_NO'] . " " . $count . ", " . $app_strings['LBL_STATUS'] . " " . ($importStatus ? $app_strings['LBL_EMAIL_IMPORT_SUCCESS'] : $app_strings['LBL_EMAIL_IMPORT_FAIL']);
$count++;
} // if
} // foreach
echo $json->encode($return);
return true;
} else {
$GLOBALS['log']->error("********* SUGARFOLDER - failed to retrieve folder ID [ {$toFolder} ]");
}
} else {
$GLOBALS['log']->debug("********* SUGARFOLDER - moveEmails() called with no passing criteria");
}
return false;
}
/**
* Hard deletes an I-E account
* @param string id GUID
*/
function hardDelete($id) {
$q = "DELETE FROM inbound_email WHERE id = '{$id}'";
$r = $this->db->query($q, true);
}
/**
* Generate a unique filename for attachments based on the message id. There are no maximum
* specifications for the length of the message id, the only requirement is that it be globally unique.
*
* @param bool $nameOnly Whether or not the attachment count should be appended to the filename.
* @return string The temp file name
*/
function getTempFilename($nameOnly=false) {
$str = md5($this->compoundMessageId);
if(!$nameOnly) {
$str = $str.$this->attachmentCount;
$this->attachmentCount++;
}
return $str;
}
/**
* deletes and expunges emails on server
* @param string $uid UID(s), comma delimited, of email(s) on server
* @return bool true on success
*/
function deleteMessageOnMailServer($uid) {
global $app_strings;
$this->connectMailserver();
if(strpos($uid, $app_strings['LBL_EMAIL_DELIMITER']) !== false) {
$uids = explode($app_strings['LBL_EMAIL_DELIMITER'], $uid);
} else {
$uids[] = $uid;
}
$return = true;
if($this->protocol == 'imap') {
$trashFolder = $this->get_stored_options("trashFolder");
if (empty($trashFolder)) {
$trashFolder = "INBOX.Trash";
}
foreach($uids as $uid) {
if($this->moveEmails($this->id, $this->mailbox, $this->id, $trashFolder, $uid))
$GLOBALS['log']->debug("INBOUNDEMAIL: MoveEmail to {$trashFolder} successful.");
else {
$GLOBALS['log']->debug("INBOUNDEMAIL: MoveEmail to {$trashFolder} FAILED - trying hard delete for message: $uid");
imap_delete($this->conn, $uid, FT_UID);
$return = true;
}
}
}
else {
$msgnos = array();
foreach($uids as $uid) {
$msgnos[] = $this->getCorrectMessageNoForPop3($uid);
}
$msgnos = implode(',', $msgnos);
imap_delete($this->conn, $msgnos);
$return = true;
}
if(!imap_expunge($this->conn)) {
$GLOBALS['log']->debug("NOOP: could not expunge deleted email.");
$return = false;
}
else
$GLOBALS['log']->info("INBOUNDEMAIL: hard-deleted mail with MSgno's' [ {$msgnos} ]");
return $return;
}
/**
* deletes and expunges emails on server
* @param string $uid UID(s), comma delimited, of email(s) on server
*/
function deleteMessageOnMailServerForPop3($uid) {
if(imap_delete($this->conn, $uid)) {
if(!imap_expunge($this->conn)) {
$GLOBALS['log']->debug("NOOP: could not expunge deleted email.");
$return = false;
} else {
$GLOBALS['log']->info("INBOUNDEMAIL: hard-deleted mail with MSgno's' [ {$uid} ]");
}
}
}
/**
* Checks if this is a pop3 type of an account or not
* @return boolean
*/
function isPop3Protocol() {
return ($this->protocol == 'pop3');
}
/**
* Gets the UIDL from database for the corresponding msgno
* @param int messageNo of a message
* @return UIDL for the message
*/
function getUIDLForMessage($msgNo) {
$query = "SELECT message_id FROM email_cache WHERE ie_id = '{$this->id}' AND msgno = '{$msgNo}'";
$r = $this->db->query($query);
$a = $this->db->fetchByAssoc($r);
return $a['message_id'];
}
/**
* Get the users default IE account id
*
* @param User $user
* @return string
*/
function getUsersDefaultOutboundServerId($user)
{
$id = $user->getPreference($this->keyForUsersDefaultIEAccount,'Emails',$user);
//If no preference has been set, grab the default system id.
if(empty($id))
{
$oe = new OutboundEmail();
$system = $oe->getSystemMailerSettings();
$id=empty($system->id) ? '' : $system->id;
}
return $id;
}
/**
* Get the users default IE account id
*
* @param User $user
*/
function setUsersDefaultOutboundServerId($user,$oe_id)
{
$user->setPreference($this->keyForUsersDefaultIEAccount, $oe_id, '', 'Emails');
}
/**
* Gets the UIDL from database for the corresponding msgno
* @param int messageNo of a message
* @return UIDL for the message
*/
function getMsgnoForMessageID($messageid) {
$query = "SELECT msgno FROM email_cache WHERE ie_id = '{$this->id}' AND message_id = '{$messageid}'";
$r = $this->db->query($query);
$a = $this->db->fetchByAssoc($r);
return $a['message_id'];
}
/**
* fills InboundEmail->email with an email's details
* @param int uid Unique ID of email
* @param bool isMsgNo flag that passed ID is msgNo, default false
* @param bool setRead Sets the 'seen' flag in cache
* @param bool forceRefresh Skips cache file
* @return string
*/
function setEmailForDisplay($uid, $isMsgNo=false, $setRead=false, $forceRefresh=false) {
if(empty($uid)) {
$GLOBALS['log']->debug("*** ERROR: INBOUNDEMAIL trying to setEmailForDisplay() with no UID");
return 'NOOP';
}
global $sugar_config;
global $app_strings;
// if its a pop3 then get the UIDL and see if this file name exist or not
if ($this->isPop3Protocol()) {
// get the UIDL from database;
$cachedUIDL = md5($uid);
$cache = "{$this->EmailCachePath}/{$this->id}/messages/{$this->mailbox}{$cachedUIDL}.php";
} else {
$cache = "{$this->EmailCachePath}/{$this->id}/messages/{$this->mailbox}{$uid}.php";
}
if(file_exists($cache) && !$forceRefresh) {
$GLOBALS['log']->info("INBOUNDEMAIL: Using cache file for setEmailForDisplay()");
include($cache); // profides $cacheFile
/** @var $cacheFile array */
$metaOut = unserialize($cacheFile['out']);
$meta = $metaOut['meta']['email'];
$email = new Email();
foreach($meta as $k => $v) {
$email->$k = $v;
}
$email->to_addrs = $meta['toaddrs'];
$email->date_sent = $meta['date_start'];
//_ppf($email,true);
$this->email = $email;
$this->email->email2init();
$ret = 'cache';
} else {
$GLOBALS['log']->info("INBOUNDEMAIL: opening new connection for setEmailForDisplay()");
if($this->isPop3Protocol()) {
$msgNo = $this->getCorrectMessageNoForPop3($uid);
} else {
if(empty($this->conn)) {
$this->connectMailserver();
}
$msgNo = ($isMsgNo) ? $uid : imap_msgno($this->conn, $uid);
}
if(empty($this->conn)) {
$status = $this->connectMailserver();
if($status == "false") {
$this->email = new Email();
$this->email->name = $app_strings['LBL_EMAIL_ERROR_MAILSERVERCONNECTION'];
$ret = 'error';
return $ret;
}
}
$this->importOneEmail($msgNo, $uid, true);
$this->email->id = '';
$this->email->new_with_id = false;
$ret = 'import';
}
if($setRead) {
$this->setStatuses($uid, 'seen', 1);
}
return $ret;
}
/**
* Sets status for a particular attribute on the mailserver and the local cache file
*/
function setStatuses($uid, $field, $value) {
global $sugar_config;
/** available status fields
[subject] => aaa
[from] => Some Name
[to] => Some Name
[date] => Mon, 22 Jan 2007 17:32:57 -0800
[message_id] =>
[size] => 718
[uid] => 191
[msgno] => 141
[recent] => 0
[flagged] => 0
[answered] => 0
[deleted] => 0
[seen] => 1
[draft] => 0
*/
// local cache
$file = "{$this->mailbox}.imapFetchOverview.php";
$overviews = $this->getCacheValueForUIDs($this->mailbox, array($uid));
if(!empty($overviews)) {
$updates = array();
foreach($overviews['retArr'] as $k => $obj) {
if($obj->imap_uid == $uid) {
$obj->$field = $value;
$updates[] = $obj;
}
}
if(!empty($updates)) {
$this->setCacheValue($this->mailbox, array(), $updates);
}
}
}
/**
* Removes an email from the cache file, deletes the message from the cache too
* @param string String of uids, comma delimited
*/
function deleteMessageFromCache($uids) {
global $sugar_config;
global $app_strings;
// delete message cache file and email_cache file
$exUids = explode($app_strings['LBL_EMAIL_DELIMITER'], $uids);
foreach($exUids as $uid) {
// local cache
if ($this->isPop3Protocol()) {
$q = "DELETE FROM email_cache WHERE message_id = '{$uid}' AND ie_id = '{$this->id}'";
} else {
$q = "DELETE FROM email_cache WHERE imap_uid = {$uid} AND ie_id = '{$this->id}'";
}
$r = $this->db->query($q);
if ($this->isPop3Protocol()) {
$uid = md5($uid);
} // if
$msgCacheFile = "{$this->EmailCachePath}/{$this->id}/messages/{$this->mailbox}{$uid}.php";
if(file_exists($msgCacheFile)) {
if(!unlink($msgCacheFile)) {
$GLOBALS['log']->error("***ERROR: InboundEmail could not delete the cache file [ {$msgCacheFile} ]");
}
}
}
}
/**
* Shows one email.
* @param int uid UID of email to display
* @param string mbox Mailbox to look in for the message
* @param bool isMsgNo Flag to assume $uid is a MessageNo, not UniqueID, default false
*/
function displayOneEmail($uid, $mbox, $isMsgNo=false) {
require_once("include/JSON.php");
global $timedate;
global $app_strings;
global $app_list_strings;
global $sugar_smarty;
global $theme;
global $current_user;
global $sugar_config;
$fetchedAttributes = array(
'name',
'from_name',
'from_addr',
'date_start',
'time_start',
'message_id',
);
$souEmail = array();
foreach($fetchedAttributes as $k) {
if ($k == 'date_start') {
$this->email->$k . " " . $this->email->time_start;
$souEmail[$k] = $this->email->$k . " " . $this->email->time_start;
} elseif ($k == 'time_start') {
$souEmail[$k] = "";
} else {
$souEmail[$k] = trim($this->email->$k);
}
}
// if a MsgNo is passed in, convert to UID
if($isMsgNo)
$uid = imap_uid($this->conn, $uid);
// meta object to allow quick retrieval for replies
$meta = array();
$meta['type'] = $this->email->type;
$meta['uid'] = $uid;
$meta['ieId'] = $this->id;
$meta['email'] = $souEmail;
$meta['mbox'] = $this->mailbox;
$ccs = '';
// imap vs pop3
// self mapping
$exMbox = explode("::", $mbox);
// CC section
$cc = '';
if(!empty($this->email->cc_addrs)) {
//$ccs = $this->collapseLongMailingList($this->email->cc_addrs);
$ccs = to_html($this->email->cc_addrs_names);
$cc =<<
{$app_strings['LBL_EMAIL_CC']}:
|
{$ccs}
|
eoq;
}
$meta['cc'] = $cc;
$meta['email']['cc_addrs'] = $ccs;
// attachments
$attachments = '';
if ($mbox == "sugar::Emails") {
$q = "SELECT id, filename, file_mime_type FROM notes WHERE parent_id = '{$uid}' AND deleted = 0";
$r = $this->db->query($q);
$i = 0;
while($a = $this->db->fetchByAssoc($r)) {
$url = "index.php?entryPoint=download&type=notes&id={$a['id']}";
$lbl = ($i == 0) ? $app_strings['LBL_EMAIL_ATTACHMENTS'].":" : '';
$i++;
$attachments .=<<
{$lbl}
|
{$a['filename']}
|
EOQ;
$this->email->cid2Link($a['id'], $a['file_mime_type']);
} // while
} else {
if($this->attachmentCount > 0) {
$theCount = $this->attachmentCount;
for($i=0; $i<$theCount; $i++) {
$lbl = ($i == 0) ? $app_strings['LBL_EMAIL_ATTACHMENTS'].":" : '';
$name = $this->getTempFilename(true).$i;
$tempName = urlencode($this->tempAttachment[$name]);
$url = "index.php?entryPoint=download&type=temp&isTempFile=true&ieId={$this->id}&tempName={$tempName}&id={$name}";
$attachments .=<<
{$lbl}
|
{$this->tempAttachment[$name]}
|
eoq;
} // for
} // if
} // else
$meta['email']['attachments'] = $attachments;
// toasddrs
$meta['email']['toaddrs'] = $this->collapseLongMailingList($this->email->to_addrs);
$meta['email']['cc_addrs'] = $ccs;
// body
$description = (empty($this->email->description_html)) ? nl2br($this->email->description) : $this->email->description_html;
$meta['email']['description'] = $description;
// meta-metadata
$meta['is_sugarEmail'] = ($exMbox[0] == 'sugar') ? true : false;
if(!$meta['is_sugarEmail']) {
if($this->isAutoImport) {
$meta['is_sugarEmail'] = true;
}
} else {
if( $this->email->status != 'sent' ){
// mark SugarEmail read
$q = "UPDATE emails SET status = 'read' WHERE id = '{$uid}'";
$r = $this->db->query($q);
}
}
$return = array();
$meta['email']['name'] = to_html($this->email->name);
$meta['email']['from_addr'] = ( !empty($this->email->from_addr_name) ) ? to_html($this->email->from_addr_name) : to_html($this->email->from_addr);
$meta['email']['toaddrs'] = ( !empty($this->email->to_addrs_names) ) ? to_html($this->email->to_addrs_names) : to_html($this->email->to_addrs);
$meta['email']['cc_addrs'] = to_html($this->email->cc_addrs_names);
$meta['email']['reply_to_addr'] = to_html($this->email->reply_to_addr);
$return['meta'] = $meta;
return $return;
}
/**
* Takes a long list of email addresses from a To or CC field and shows the first 3, the rest hidden
* @param string emails
* @return string
*/
function collapseLongMailingList($emails) {
global $app_strings;
$ex = explode(",", $emails);
$i = 0;
$j = 0;
if(count($ex) > 3) {
$emails = "";
$emailsHidden = "";
foreach($ex as $email) {
if($i < 2) {
if(!empty($emails)) {
$emails .= ", ";
}
$emails .= trim($email);
} else {
if(!empty($emailsHidden)) {
$emailsHidden .= ", ";
}
$emailsHidden .= trim($email);
$j++;
}
$i++;
}
if(!empty($emailsHidden)) {
$email2 = $emails;
$emails = "{$emails} [...{$j} {$app_strings['LBL_MORE']}]";
$emailsHidden = "{$email2}, {$emailsHidden} [ {$app_strings['LBL_LESS']} ]";
}
$emails .= $emailsHidden;
}
return $emails;
}
/**
* Sorts IMAP's imap_fetch_overview() results
* @param array $arr Array of standard objects
* @param string $sort Column to sort by
* @param string direction Direction to sort by (asc/desc)
* @return array Sorted array of obj.
*/
function sortFetchedOverview($arr, $sort=4, $direction='DESC', $forceSeen=false) {
global $current_user;
$sortPrefs = $current_user->getPreference('folderSortOrder', 'Emails');
if(!empty($sortPrefs))
$listPrefs = $sortPrefs;
else
$listPrefs = array();
if(isset($listPrefs[$this->id][$this->mailbox])) {
$currentNode = $listPrefs[$this->id][$this->mailbox];
}
if(isset($currentNode['current']) && !empty($currentNode['current'])) {
$sort = $currentNode['current']['sort'];
$direction = $currentNode['current']['direction'];
}
// sort defaults
if(empty($sort)) {
$sort = $this->defaultSort;//4;
$direction = $this->defaultDirection; //'DESC';
} elseif(!is_numeric($sort)) {
// handle bad sort index
$sort = $this->defaultSort;
} else {
// translate numeric index to human readable
$sort = $this->hrSort[$sort];
}
if(empty($direction)) {
$direction = 'DESC';
}
$retArr = array();
$sorts = array();
foreach($arr as $k => $overview) {
$sorts['flagged'][$k] = $overview->flagged;
$sorts['status'][$k] = $overview->answered;
$sorts['from'][$k] = str_replace('"', "", $this->handleMimeHeaderDecode($overview->from));
$sorts['subj'][$k] = $this->handleMimeHeaderDecode(quoted_printable_decode($overview->subject));
$sorts['date'][$k] = $overview->date;
}
// sort by column
natcasesort($sorts[$sort]);
//_ppd($sorts[$sort]);
// direction
if(strtolower($direction) == 'desc') {
$revSorts = array();
$keys = array_reverse(array_keys($sorts[$sort]));
// _pp("count keys in DESC: ".count($keys));
// _pp("count elements in sort[sort]: ".count($sorts[$sort]));
for($i=0; $i $overview2) {
$arr[$k2]->date = $timedate->fromString($arr[$k2]->date)->asDb();
$retArr[] = $arr[$k2];
}
//_pp("final count: ".count($retArr));
$finalReturn = array();
$finalReturn['retArr'] = $retArr;
$finalReturn['sortBy'] = $sort;
$finalReturn['direction'] = $direction;
return $finalReturn;
}
function setReadFlagOnFolderCache($mbox, $uid) {
global $sugar_config;
$this->mailbox = $mbox;
// cache
if($this->validCacheExists($this->mailbox)) {
$ret = $this->getCacheValue($this->mailbox);
$updates = array();
foreach($ret as $k => $v) {
if($v->imap_uid == $uid) {
$v->seen = 1;
$updates[] = $v;
break;
}
}
$this->setCacheValue($this->mailbox, array(), $updates);
}
}
/**
* Returns a list of emails in a mailbox.
* @param string mbox Name of mailbox using dot notation paths to display
* @param string $forceRefresh Flag to use cache or not
*/
function displayFolderContents($mbox, $forceRefresh='false', $page) {
global $current_user;
$delimiter = $this->get_stored_options('folderDelimiter');
if ($delimiter) {
$mbox = str_replace('.', $delimiter, $mbox);
}
$this->mailbox = $mbox;
// jchi #9424, get sort and direction from user preference
$sort = 'date';
$direction = 'desc';
$sortSerial = $current_user->getPreference('folderSortOrder', 'Emails');
if(!empty($sortSerial) && !empty($_REQUEST['ieId']) && !empty($_REQUEST['mbox'])) {
$sortArray = unserialize($sortSerial);
$sort = $sortArray[$_REQUEST['ieId']][$_REQUEST['mbox']]['current']['sort'];
$direction = $sortArray[$_REQUEST['ieId']][$_REQUEST['mbox']]['current']['direction'];
}
//end
// save sort order
if(!empty($_REQUEST['sort']) && !empty($_REQUEST['dir'])) {
$this->email->et->saveListViewSortOrder($_REQUEST['ieId'], $_REQUEST['mbox'], $_REQUEST['sort'], $_REQUEST['dir']);
$sort = $_REQUEST['sort'];
$direction = $_REQUEST['dir'];
} else {
$_REQUEST['sort'] = '';
$_REQUEST['dir'] = '';
}
// cache
$ret = array();
$cacheUsed = false;
if($forceRefresh == 'false' && $this->validCacheExists($this->mailbox)) {
$emailSettings = $current_user->getPreference('emailSettings', 'Emails');
// cn: default to a low number until user specifies otherwise
if(empty($emailSettings['showNumInList'])) {
$emailSettings['showNumInList'] = 20;
}
$ret = $this->getCacheValue($this->mailbox, $emailSettings['showNumInList'], $page, $sort, $direction);
$cacheUsed = true;
}
$out = $this->displayFetchedSortedListXML($ret, $mbox);
$metadata = array();
$metadata['mbox'] = $mbox;
$metadata['ieId'] = $this->id;
$metadata['name'] = $this->name;
$metadata['fromCache'] = $cacheUsed ? 1 : 0;
$metadata['out'] = $out;
return $metadata;
}
/**
* For a group email account, create subscriptions for all users associated with the
* team assigned to the account.
*
*/
function createUserSubscriptionsForGroupAccount()
{
$team = new Team();
$team->retrieve($this->team_id);
$usersList = $team->get_team_members(true);
foreach($usersList as $userObject)
{
$previousSubscriptions = unserialize(base64_decode($userObject->getPreference('showFolders', 'Emails',$userObject)));
if($previousSubscriptions === FALSE)
$previousSubscriptions = array();
$previousSubscriptions[] = $this->id;
$encodedSubs = base64_encode(serialize($previousSubscriptions));
$userObject->setPreference('showFolders',$encodedSubs , '', 'Emails');
$userObject->savePreferencesToDB();
}
}
/**
* Create a sugar folder for this inbound email account
* if the Enable Auto Import option is selected
*
* @return String Id of the sugar folder created.
*/
function createAutoImportSugarFolder()
{
global $current_user;
$guid = create_guid();
$GLOBALS['log']->debug("Creating Sugar Folder for IE with id $guid");
$folder = new SugarFolder();
$folder->id = $guid;
$folder->new_with_id = TRUE;
$folder->name = $this->name;
$folder->has_child = 0;
$folder->is_group = 1;
$folder->assign_to_id = $current_user->id;
$folder->parent_folder = "";
//If this inbound email is marked as inactive, don't add subscriptions.
$addSubscriptions = ($this->status == 'Inactive' || $this->mailbox_type == 'bounce') ? FALSE : TRUE;
$folder->save($addSubscriptions);
return $guid;
}
function validCacheExists($mbox) {
$q = "SELECT count(*) c FROM email_cache WHERE ie_id = '{$this->id}'";
$r = $this->db->query($q);
$a = $this->db->fetchByAssoc($r);
$count = $a['c'];
if($count > 0) {
return true;
}
return false;
}
function displayFetchedSortedListXML($ret, $mbox) {
global $timedate;
global $current_user;
global $sugar_config;
if(empty($ret['retArr'])) {
return array();
}
$tPref = $current_user->getUserDateTimePreferences();
$return = array();
foreach($ret['retArr'] as $msg) {
$flagged = ($msg->flagged == 0) ? "" : $this->iconFlagged;
$status = ($msg->deleted) ? $this->iconDeleted : "";
$status = ($msg->draft == 0) ? $status : $this->iconDraft;
$status = ($msg->answered == 0) ? $status : $this->iconAnswered;
$from = $this->handleMimeHeaderDecode($msg->from);
$subject = $this->handleMimeHeaderDecode($msg->subject);
//$date = date($tPref['date']." ".$tPref['time'], $msg->date);
$date = $timedate->to_display_date_time($this->db->fromConvert($msg->date, 'datetime'));
//$date = date($tPref['date'], $this->getUnixHeaderDate($msg->date));
$temp = array();
$temp['flagged'] = $flagged;
$temp['status'] = $status;
$temp['from'] = to_html($from);
$temp['subject'] = $subject;
$temp['date'] = $date;
$temp['uid'] = $msg->uid; // either from an imap_search() or massaged cache value
$temp['mbox'] = $this->mailbox;
$temp['ieId'] = $this->id;
$temp['site_url'] = $sugar_config['site_url'];
$temp['seen'] = $msg->seen;
$temp['type'] = (isset($msg->type)) ? $msg->type: 'remote';
$temp['to_addrs'] = to_html($msg->to);
$temp['hasAttach'] = '0';
$return[] = $temp;
}
return $return;
}
/**
* retrieves the mailboxes for a given account in the following format
* Array(
[INBOX] => Array
(
[Bugs] => Bugs
[Builder] => Builder
[DEBUG] => Array
(
[out] => out
[test] => test
)
)
* @param bool $justRaw Default false
* @return array
*/
function getMailboxes($justRaw=false) {
if($justRaw == true) {
return $this->mailboxarray;
} // if
return $this->generateMultiDimArrayFromFlatArray($this->mailboxarray, $this->retrieveDelimiter());
/*
$serviceString = $this->getConnectString('', '', false);
if(strpos($serviceString, 'pop3')) {
$obj = new temp();
$obj->name = $serviceString."INBOX";
$boxes = array("INBOX" => $obj);
} else {
$boxes = imap_getmailboxes($this->conn, $serviceString, "*");
}
$raw = array();
//_ppd($boxes);
$delimiter = '.';
// clean MBOX path names
foreach($boxes as $k => $mbox) {
$raw[] = str_replace($serviceString, "", $mbox->name);
if ($mbox->delimiter) {
$delimiter = $mbox->delimiter;
}
}
$storedOptions = unserialize(base64_decode($this->stored_options));
$storedOptions['folderDelimiter'] = $delimiter;
$this->stored_options = base64_encode(serialize($storedOptions));
$this->save();
sort($raw);
//_ppd($raw);
// used by $this->search()
if($justRaw == true) {
return $raw;
}
// generate a multi-dimensional array to iterate through
$ret = array();
foreach($raw as $mbox) {
$ret = $this->sortMailboxes($mbox, $ret, $delimiter);
}
//_ppd($ret);
return $ret;
*/
}
function getMailBoxesForGroupAccount() {
$mailboxes = $this->generateMultiDimArrayFromFlatArray(explode(",", $this->mailbox), $this->retrieveDelimiter());
$mailboxesArray = $this->generateFlatArrayFromMultiDimArray($mailboxes, $this->retrieveDelimiter());
$mailboxesArray = $this->filterMailBoxFromRaw(explode(",", $this->mailbox), $mailboxesArray);
$this->saveMailBoxFolders($mailboxesArray);
/*
if ($this->mailbox != $this->$email_user) {
$mailboxes = $this->sortMailboxes($this->mailbox, $this->retrieveDelimiter());
$mailboxesArray = $this->generateFlatArrayFromMultiDimArray($mailboxes, $this->retrieveDelimiter());
$this->saveMailBoxFolders($mailboxesArray);
// save mailbox value of an inbound email account to email user
$this->saveMailBoxValueOfInboundEmail();
} else {
$mailboxes = $this->getMailboxes();
}
*/
return $mailboxes;
} // fn
function saveMailBoxFolders($value) {
if (is_array($value)) {
$value = implode(",", $value);
}
$this->mailboxarray = explode(",", $value);
$value = $this->db->quoted($value);
$query = "update inbound_email set mailbox = $value where id ='{$this->id}'";
$this->db->query($query);
}
function insertMailBoxFolders($value) {
$query = "select value from config where category='InboundEmail' and name='{$this->id}'";
$r = $this->db->query($query);
$a = $this->db->fetchByAssoc($r);
if (empty($a['value'])) {
if (is_array($value)) {
$value = implode(",", $value);
}
$this->mailboxarray = explode(",", $value);
$value = $this->db->quoted($value);
$query = "INSERT INTO config VALUES('InboundEmail', '{$this->id}', $value)";
$this->db->query($query);
} // if
}
function saveMailBoxValueOfInboundEmail() {
$query = "update Inbound_email set mailbox = '{$this->email_user}'";
$this->db->query($query);
}
function retrieveMailBoxFolders() {
$this->mailboxarray = explode(",", $this->mailbox);
/*
$query = "select value from config where category='InboundEmail' and name='{$this->id}'";
$r = $this->db->query($query);
$a = $this->db->fetchByAssoc($r);
$this->mailboxarray = explode(",", $a['value']);
*/
} // fn
function retrieveDelimiter() {
$delimiter = $this->get_stored_options('folderDelimiter');
if (!$delimiter) {
$delimiter = '.';
}
return $delimiter;
} // fn
function generateFlatArrayFromMultiDimArray($arraymbox, $delimiter) {
$ret = array();
foreach($arraymbox as $key => $value) {
$this->generateArrayData($key, $value, $ret, $delimiter);
} // foreach
return $ret;
} // fn
function generateMultiDimArrayFromFlatArray($raw, $delimiter) {
// generate a multi-dimensional array to iterate through
$ret = array();
foreach($raw as $mbox) {
$ret = $this->sortMailboxes($mbox, $ret, $delimiter);
}
return $ret;
} // fn
function generateArrayData($key, $arraymbox, &$ret, $delimiter) {
$ret [] = $key;
if (is_array($arraymbox)) {
foreach($arraymbox as $mboxKey => $value) {
$newKey = $key . $delimiter . $mboxKey;
$this->generateArrayData($newKey, $value, $ret, $delimiter);
} // foreach
} // if
}
/**
* sorts the folders in a mailbox in a multi-dimensional array
* @param string $MBOX
* @param array $ret
* @return array
*/
function sortMailboxes($mbox, $ret, $delimeter = ".") {
if(strpos($mbox, $delimeter)) {
$node = substr($mbox, 0, strpos($mbox, $delimeter));
$nodeAfter = substr($mbox, strpos($mbox, $node) + strlen($node) + 1, strlen($mbox));
if(!isset($ret[$node])) {
$ret[$node] = array();
} elseif(isset($ret[$node]) && !is_array($ret[$node])) {
$ret[$node] = array();
}
$ret[$node] = $this->sortMailboxes($nodeAfter, $ret[$node], $delimeter);
} else {
$ret[$mbox] = $mbox;
}
return $ret;
}
/**
* parses Sugar's storage method for imap server service strings
* @return string
*/
function getServiceString() {
$service = '';
$exServ = explode('::', $this->service);
foreach($exServ as $v) {
if(!empty($v) && ($v != 'imap' && $v !='pop3')) {
$service .= '/'.$v;
}
}
return $service;
}
} // end class definition
/**
* Simple class to mirror the passed object from an imap_fetch_overview() call
*/
class Overview {
var $subject;
var $from;
var $fromaddr;
var $to;
var $toaddr;
var $date;
var $message_id;
var $size;
var $uid;
var $msgno;
var $recent;
var $flagged;
var $answered;
var $deleted;
var $seen;
var $draft;
var $indices; /* = array(
array(
'name' => 'mail_date',
'type' => 'index',
'fields' => array(
'mbox',
'senddate',
)
),
array(
'name' => 'mail_from',
'type' => 'index',
'fields' => array(
'mbox',
'fromaddr',
)
),
array(
'name' => 'mail_subj',
'type' => 'index',
'fields' => array(
'mbox',
'subject',
)
),
);
*/
var $fieldDefs;/* = array(
'mbox' => array(
'name' => 'mbox',
'type' => 'varchar',
'len' => 60,
'required' => true,
),
'subject' => array(
'name' => 'subject',
'type' => 'varchar',
'len' => 100,
'required' => false,
),
'fromaddr' => array(
'name' => 'fromaddr',
'type' => 'varchar',
'len' => 100,
'required' => true,
),
'toaddr' => array(
'name' => 'toaddr',
'type' => 'varchar',
'len' => 100,
'required' => true,
),
'senddate' => array(
'name' => 'senddate',
'type' => 'datetime',
'required' => true,
),
'message_id' => array(
'name' => 'message_id',
'type' => 'varchar',
'len' => 255,
'required' => false,
),
'mailsize' => array(
'name' => 'mailsize',
'type' => 'uint',
'len' => 16,
'required' => true,
),
'uid' => array(
'name' => 'uid',
'type' => 'uint',
'len' => 32,
'required' => true,
),
'msgno' => array(
'name' => 'msgno',
'type' => 'uint',
'len' => 32,
'required' => false,
),
'recent' => array(
'name' => 'recent',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
'flagged' => array(
'name' => 'flagged',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
'answered' => array(
'name' => 'answered',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
'deleted' => array(
'name' => 'deleted',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
'seen' => array(
'name' => 'seen',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
'draft' => array(
'name' => 'draft',
'type' => 'tinyint',
'len' => 1,
'required' => true,
),
);
*/
function Overview() {
global $dictionary;
if(!isset($dictionary['email_cache']) || empty($dictionary['email_cache'])) {
if(file_exists('custom/metadata/email_cacheMetaData.php')) {
include('custom/metadata/email_cacheMetaData.php');
} else {
include('metadata/email_cacheMetaData.php');
}
}
$this->fieldDefs = $dictionary['email_cache']['fields'];
$this->indices = $dictionary['email_cache']['indices'];
}
}