function getTechnicalDescriptions()
{
$attachmentIds = explode(' ', trim($this->attachmentsequence));
$attachments = array();
foreach ($attachmentIds as $id) {
$attachment_data = array();
$revision = new DocumentRevision();
if (!$revision->retrieve($id)) {
$attachment = new Document();
if ($attachment->retrieve($id)) {
if ($attachment->subcategory_id == 'Technical') {
//$attachment_data = array();
$attachment_data["id"] = $attachment->id;
$attachment_data["document_name"] = $attachment->document_name;
$attachment_data["document_revision_id"] = $attachment->document_revision_id;
// $attachment_data["doc_status"] = 'new';
$attachments[] = $attachment_data;
}
}
} else {
$attachment = new Document();
if ($attachment->retrieve($revision->document_id)) {
if ($attachment->subcategory_id == 'Technical') {
//$attachment_data = array();
$attachment_data["id"] = $attachment->id;
$attachment_data["document_name"] = $attachment->document_name . '_rev.' . $revision->revision;
$attachment_data["document_revision_id"] = $revision->id;
// $attachment_data["doc_status"] = 'new';
$attachments[] = $attachment_data;
}
}
}
}
return $attachments;
}
public function testSaveAndRetrieve()
{
error_reporting(E_ERROR | E_PARSE);
$documentRevision = new DocumentRevision();
$documentRevision->document_id = '1';
$documentRevision->doc_id = '1';
$documentRevision->doc_type = 'text';
$documentRevision->filename = 'test';
$documentRevision->file_ext = 'ext';
$documentRevision->save();
//test for record ID to verify that record is saved
$this->assertTrue(isset($documentRevision->id));
$this->assertEquals(36, strlen($documentRevision->id));
//test document retrieve method
$docRev = $documentRevision->retrieve($documentRevision->id);
$this->assertEquals('1', $docRev->document_id);
$this->assertEquals('1', $docRev->doc_id);
$this->assertEquals('text', $docRev->doc_type);
$this->assertEquals('test', $docRev->filename);
$this->assertEquals('ext', $docRev->file_ext);
//mark the record as deleted and verify that this record cannot be retrieved anymore.
$docRev->mark_deleted($docRev->id);
$result = $docRev->retrieve($docRev->id);
$this->assertEquals(null, $result);
}
function get_all_linked_attachment_revisions($attachmentsequence)
{
$attachmentIds = explode(' ', trim($attachmentsequence));
$attachments = array();
foreach ($attachmentIds as $id) {
$revision = new DocumentRevision();
if (!$revision->retrieve($id)) {
// if in old format try to recover by document id
$attachment = new Document();
if ($attachment->retrieve($id)) {
$attachment->revision = '';
$attachment->doc_rev_id = '';
$attachments[] = $attachment;
}
} else {
$attachment = new Document();
if ($attachment->retrieve($revision->document_id)) {
$attachment->revision = $revision->revision;
$attachment->doc_rev_id = $revision->id;
$attachments[] = $attachment;
}
}
}
return $attachments;
}
/**
* Constructs an attachment from the SugarBean that is passed in.
*
* @static
* @access public
* @param SugarBean $bean required
* @return Attachment
* @throws MailerException
*/
public static function attachmentFromSugarBean(SugarBean $bean)
{
$filePath = null;
$fileName = null;
$mimeType = "";
if ($bean instanceof Document) {
if (empty($bean->id)) {
throw new MailerException("Invalid Attachment: document not found", MailerException::InvalidAttachment);
}
$document_revision_id = $bean->document_revision_id;
$documentRevision = new DocumentRevision();
if (!empty($document_revision_id)) {
$documentRevision->retrieve($bean->document_revision_id);
}
if (empty($document_revision_id) || $documentRevision->id != $document_revision_id) {
throw new MailerException("Invalid Attachment: Document with Id (" . $bean->id . ") contains an invalid or empty revision id: (" . $document_revision_id . ")", MailerException::InvalidAttachment);
}
$bean = $documentRevision;
}
$beanName = get_class($bean);
switch ($beanName) {
case "Note":
case "DocumentRevision":
$filePath = rtrim(SugarConfig::getInstance()->get('upload_dir', 'upload'), '/\\') . '/' . $bean->id;
$fileName = empty($bean->filename) ? $bean->name : $bean->filename;
$mimeType = empty($bean->file_mime_type) ? $mimeType : $bean->file_mime_type;
break;
default:
throw new MailerException("Invalid Attachment: SugarBean '{$beanName}' not supported as an Email Attachment", MailerException::InvalidAttachment);
break;
}
// Path must Exist and Must be a Regular File
if (!is_file($filePath)) {
throw new MailerException("Invalid Attachment: file not found: {$filePath}", MailerException::InvalidAttachment);
}
$attachment = new Attachment($filePath, $fileName, Encoding::Base64, $mimeType);
return $attachment;
}
* All Rights Reserved.
* Contributor(s): ______________________________________..
********************************************************************************/
require_once 'XTemplate/xtpl.php';
require_once 'data/Tracker.php';
require_once 'modules/Documents/Document.php';
require_once 'modules/DocumentRevisions/DocumentRevision.php';
require_once 'modules/Notes/Forms.php';
require_once 'include/upload_file.php';
global $app_strings;
global $app_list_strings;
global $mod_strings;
global $current_user;
$focus = new DocumentRevision();
if (isset($_REQUEST['record'])) {
$focus->retrieve($_REQUEST['record']);
}
$old_id = '';
if (isset($_REQUEST['isDuplicate']) && $_REQUEST['isDuplicate'] == 'true') {
if (!empty($focus->filename)) {
$old_id = $focus->id;
}
$focus->id = "";
}
echo "\n<p>\n";
echo get_module_title('DocumentRevisions', $mod_strings['LBL_MODULE_NAME'] . ": " . $focus->document_name, true);
echo "\n</p>\n";
global $theme;
$theme_path = "themes/" . $theme . "/";
$image_path = $theme_path . "images/";
require_once $theme_path . 'layout_utils.php';
$bean_name = $beanList[$module];
if (!file_exists('modules/' . $module . '/' . $bean_name . '.php')) {
die($app_strings['ERROR_TYPE_NOT_VALID']);
}
require_once 'modules/' . $module . '/' . $bean_name . '.php';
$focus = new $bean_name();
$focus->retrieve($_REQUEST['id']);
if (!$focus->ACLAccess('view')) {
die($mod_strings['LBL_NO_ACCESS']);
}
// if
// Pull up the document revision, if it's of type Document
if (isset($focus->object_name) && $focus->object_name == 'Document') {
// It's a document, get the revision that really stores this file
$focusRevision = new DocumentRevision();
$focusRevision->retrieve($_REQUEST['id']);
if (empty($focusRevision->id)) {
// This wasn't a document revision id, it's probably actually a document id, we need to grab that, get the latest revision and use that
$focusDocument = new Document();
$focusDocument->retrieve($_REQUEST['id']);
$focusRevision->retrieve($focusDocument->document_revision_id);
if (!empty($focusRevision->id)) {
$_REQUEST['id'] = $focusRevision->id;
}
}
}
// See if it is a remote file, if so, send them that direction
if (isset($focus->doc_url) && !empty($focus->doc_url)) {
header('Location: ' . $focus->doc_url);
sugar_die();
}
/**
* Returns a filename based off of the logical (Sugar-side) Document name and combined with the revision. Tailor
* this to needs created by email RFCs, filesystem name conventions, charset conventions etc.
* @param string revId Revision ID if not latest
* @return string formatted name
*/
function getDocumentRevisionNameForDisplay($revId = '')
{
global $sugar_config;
global $current_language;
$localLabels = return_module_language($current_language, 'DocumentRevisions');
// prep - get source Document
$document = new Document();
// use passed revision ID
if (!empty($revId)) {
$tempDoc = new DocumentRevision();
$tempDoc->retrieve($revId);
} else {
$tempDoc = $this;
}
// get logical name
$document->retrieve($tempDoc->document_id);
$logicalName = $document->document_name;
// get revision string
$revString = '';
if (!empty($tempDoc->revision)) {
$revString = "-{$localLabels['LBL_REVISION']}_{$tempDoc->revision}";
}
// get extension
$realFilename = $tempDoc->filename;
$fileExtension_beg = strrpos($realFilename, ".");
$fileExtension = "";
if ($fileExtension_beg > 0) {
$fileExtension = substr($realFilename, $fileExtension_beg + 1);
}
//check to see if this is a file with extension located in "badext"
foreach ($sugar_config['upload_badext'] as $badExt) {
if (strtolower($fileExtension) == strtolower($badExt)) {
//if found, then append with .txt to filename and break out of lookup
//this will make sure that the file goes out with right extension, but is stored
//as a text in db.
$fileExtension .= ".txt";
break;
// no need to look for more
}
}
$fileExtension = "." . $fileExtension;
$return = $logicalName . $revString . $fileExtension;
// apply RFC limitations here
if (mb_strlen($return) > 1024) {
// do something if we find a real RFC issue
}
return $return;
}
function handleSave($prefix, $redirect = true, $useRequired = false)
{
require_once 'include/formbase.php';
require_once 'include/upload_file.php';
global $upload_maxsize;
global $mod_strings;
global $sugar_config;
$focus = new EmailTemplate();
if ($useRequired && !checkRequired($prefix, array_keys($focus->required_fields))) {
return null;
}
$focus = populateFromPost($prefix, $focus);
//process the text only flag
if (isset($_POST['text_only']) && $_POST['text_only'] == '1') {
$focus->text_only = 1;
} else {
$focus->text_only = 0;
}
if (!$focus->ACLAccess('Save')) {
ACLController::displayNoAccess(true);
sugar_cleanup(true);
}
if (!isset($_REQUEST['published'])) {
$focus->published = 'off';
}
$preProcessedImages = array();
$emailTemplateBodyHtml = from_html($focus->body_html);
if (strpos($emailTemplateBodyHtml, '"cache/images/')) {
$matches = array();
preg_match_all('#<img[^>]*[\\s]+src[^=]*=[\\s]*["\']cache/images/(.+?)["\']#si', $emailTemplateBodyHtml, $matches);
foreach ($matches[1] as $match) {
$filename = urldecode($match);
$file_location = sugar_cached("images/{$filename}");
$mime_type = pathinfo($filename, PATHINFO_EXTENSION);
if (file_exists($file_location)) {
$id = create_guid();
$newFileLocation = "upload://{$id}";
if (!copy($file_location, $newFileLocation)) {
$GLOBALS['log']->debug("EMAIL Template could not copy attachment to {$newFileLocation}");
} else {
$secureLink = "index.php?entryPoint=download&type=Notes&id={$id}";
$emailTemplateBodyHtml = str_replace("cache/images/{$match}", $secureLink, $emailTemplateBodyHtml);
unlink($file_location);
$preProcessedImages[$filename] = $id;
}
}
// if
}
// foreach
}
// if
if (isset($GLOBALS['check_notify'])) {
$check_notify = $GLOBALS['check_notify'];
} else {
$check_notify = FALSE;
}
$focus->body_html = $emailTemplateBodyHtml;
$return_id = $focus->save($check_notify);
///////////////////////////////////////////////////////////////////////////////
//// ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////
//// ADDING NEW ATTACHMENTS
$max_files_upload = count($_FILES);
if (!empty($focus->id)) {
$note = new Note();
$where = "notes.parent_id='{$focus->id}'";
if (!empty($_REQUEST['old_id'])) {
// to support duplication of email templates
$where .= " OR notes.parent_id='" . $_REQUEST['old_id'] . "'";
}
$notes_list = $note->get_full_list("", $where, true);
}
if (!isset($notes_list)) {
$notes_list = array();
}
if (!is_array($focus->attachments)) {
// PHP5 does not auto-create arrays(). Need to initialize it here.
$focus->attachments = array();
}
$focus->attachments = array_merge($focus->attachments, $notes_list);
//for($i = 0; $i < $max_files_upload; $i++) {
foreach ($_FILES as $key => $file) {
$note = new Note();
//Images are presaved above so we need to prevent duplicate files from being created.
if (isset($preProcessedImages[$file['name']])) {
$oldId = $preProcessedImages[$file['name']];
$note->id = $oldId;
$note->new_with_id = TRUE;
$GLOBALS['log']->debug("Image {$file['name']} has already been processed.");
}
$i = preg_replace("/email_attachment(.+)/", '$1', $key);
$upload_file = new UploadFile($key);
if (isset($_FILES[$key]) && $upload_file->confirm_upload() && preg_match("/^email_attachment/", $key)) {
$note->filename = $upload_file->get_stored_file_name();
$note->file = $upload_file;
$note->name = $mod_strings['LBL_EMAIL_ATTACHMENT'] . ': ' . $note->file->original_file_name;
if (isset($_REQUEST['embedded' . $i]) && !empty($_REQUEST['embedded' . $i])) {
if ($_REQUEST['embedded' . $i] == 'true') {
$note->embed_flag = true;
} else {
$note->embed_flag = false;
}
}
array_push($focus->attachments, $note);
}
}
$focus->saved_attachments = array();
foreach ($focus->attachments as $note) {
if (!empty($note->id) && $note->new_with_id === FALSE) {
if (empty($_REQUEST['old_id'])) {
array_push($focus->saved_attachments, $note);
} else {
// we're duplicating a template with attachments
// dupe the file, create a new note, assign the note to the new template
$newNote = new Note();
$newNote->retrieve($note->id);
$newNote->id = create_guid();
$newNote->parent_id = $focus->id;
$newNote->new_with_id = true;
$newNote->date_modified = '';
$newNote->date_entered = '';
$newNoteId = $newNote->save();
UploadFile::duplicate_file($note->id, $newNoteId, $note->filename);
}
continue;
}
$note->parent_id = $focus->id;
$note->parent_type = 'Emails';
$note->file_mime_type = $note->file->mime_type;
$note_id = $note->save();
array_push($focus->saved_attachments, $note);
$note->id = $note_id;
if ($note->new_with_id === FALSE) {
$note->file->final_move($note->id);
} else {
$GLOBALS['log']->debug("Not performing final move for note id {$note->id} as it has already been processed");
}
}
//// END NEW ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DOCUMENTS
$count = '';
//_pp($_REQUEST);
//_ppd(count($_REQUEST['document']));
if (!empty($_REQUEST['document'])) {
$count = count($_REQUEST['document']);
} else {
$count = 10;
}
for ($i = 0; $i < $count; $i++) {
if (isset($_REQUEST['documentId' . $i]) && !empty($_REQUEST['documentId' . $i])) {
$doc = new Document();
$docRev = new DocumentRevision();
$docNote = new Note();
$doc->retrieve($_REQUEST['documentId' . $i]);
$docRev->retrieve($doc->document_revision_id);
array_push($focus->saved_attachments, $docRev);
$docNote->name = $doc->document_name;
$docNote->filename = $docRev->filename;
$docNote->description = $doc->description;
$docNote->parent_id = $focus->id;
$docNote->parent_type = 'Emails';
$docNote->file_mime_type = $docRev->file_mime_type;
$docId = $docNote = $docNote->save();
UploadFile::duplicate_file($docRev->id, $docId, $docRev->filename);
}
}
//// END ATTACHMENTS FROM DOCUMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// REMOVE ATTACHMENTS
if (isset($_REQUEST['remove_attachment']) && !empty($_REQUEST['remove_attachment'])) {
foreach ($_REQUEST['remove_attachment'] as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$focus->db->query($q);
}
}
//// END REMOVE ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
//// END ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////////
clear_register_value('select_array', $focus->object_name);
if ($redirect) {
$GLOBALS['log']->debug("Saved record with id of " . $return_id);
handleRedirect($return_id, "EmailTemplates");
} else {
return $focus;
}
}
* Window - Preferences - PHPeclipse - PHP - Code Templates
*/
global $app_strings;
global $app_list_strings;
global $mod_strings;
global $current_user;
global $locale;
$xtpl = new XTemplate('modules/MailMerge/Step4.html');
$xtpl->assign("MOD", $mod_strings);
$xtpl->assign("APP", $app_strings);
if (!empty($_POST['document_id'])) {
$_SESSION['MAILMERGE_DOCUMENT_ID'] = $_POST['document_id'];
}
$document_id = $_SESSION['MAILMERGE_DOCUMENT_ID'];
$revision = new DocumentRevision();
$revision->retrieve($document_id);
//$document = new Document();
//$document->retrieve($document_id);
if (!empty($_POST['selected_objects'])) {
$selObjs = urldecode($_POST['selected_objects']);
$_SESSION['SELECTED_OBJECTS_DEF'] = $selObjs;
}
$selObjs = $_SESSION['SELECTED_OBJECTS_DEF'];
$sel_obj = array();
parse_str(stripslashes(html_entity_decode($selObjs, ENT_QUOTES)), $sel_obj);
foreach ($sel_obj as $key => $value) {
$sel_obj[$key] = stripslashes($value);
}
$relArray = array();
//build relationship array
foreach ($sel_obj as $key => $value) {
/**
* This method is used as a result of the .htaccess lock down on the cache directory. It will allow a
* properly authenticated user to download a document that they have proper rights to download.
*
* @param String $session -- Session ID returned by a previous call to login.
* @param String $id -- ID of the document revision to obtain
* @return return_document_revision - this is a complex type as defined in SoapTypes.php
*/
function get_document_revision($session, $id)
{
global $sugar_config;
$error = new SoapError();
if (!validate_authenticated($session)) {
$error->set_error('invalid_login');
return array('id' => -1, 'error' => $error->get_soap_array());
}
$dr = new DocumentRevision();
$dr->retrieve($id);
if (!empty($dr->filename)) {
$filename = $sugar_config['upload_dir'] . "/" . $dr->id;
$handle = sugar_fopen($filename, "r");
$contents = fread($handle, filesize($filename));
fclose($handle);
$contents = base64_encode($contents);
$fh = sugar_fopen($sugar_config['upload_dir'] . "/rogerrsmith.doc", 'w');
fwrite($fh, base64_decode($contents));
return array('document_revision' => array('id' => $dr->id, 'document_name' => $dr->document_name, 'revision' => $dr->revision, 'filename' => $dr->filename, 'file' => $contents), 'error' => $error->get_soap_array());
} else {
$error->set_error('no_records');
return array('id' => -1, 'error' => $error->get_soap_array());
}
}
/**
* This method is used as a result of the .htaccess lock down on the cache directory. It will allow a
* properly authenticated user to download a document that they have proper rights to download.
*
* @param String $session -- Session ID returned by a previous call to login.
* @param String $id -- ID of the document revision to obtain
* @return return_document_revision - this is a complex type as defined in SoapTypes.php
*/
function get_document_revision($session, $id)
{
global $sugar_config;
$error = new SoapError();
if (!validate_authenticated($session)) {
$error->set_error('invalid_login');
return array('id' => -1, 'error' => $error->get_soap_array());
}
$dr = new DocumentRevision();
$dr->retrieve($id);
if (!empty($dr->filename)) {
$filename = "upload://{$dr->id}";
$contents = base64_encode(sugar_file_get_contents($filename));
return array('document_revision' => array('id' => $dr->id, 'document_name' => $dr->document_name, 'revision' => $dr->revision, 'filename' => $dr->filename, 'file' => $contents), 'error' => $error->get_soap_array());
} else {
$error->set_error('no_records');
return array('id' => -1, 'error' => $error->get_soap_array());
}
}
/**
* This method is used as a result of the .htaccess lock down on the cache directory. It will allow a
* properly authenticated user to download a document that they have proper rights to download.
*
* @param String $session -- Session ID returned by a previous call to login.
* @param String $id -- ID of the document revision to obtain
* @return new_return_document_revision - Array String 'id' -- The ID of the document revision containing the attachment
* String document_name - The name of the document
* String revision - The revision value for this revision
* String 'filename' -- The file name of the attachment
* Binary 'file' -- The binary contents of the file.
* @exception 'SoapFault' -- The SOAP error, if any
*/
function get_document_revision($session, $id)
{
$GLOBALS['log']->info('Begin: SugarWebServiceImpl->get_document_revision');
global $sugar_config;
$error = new SoapError();
if (!self::$helperObject->checkSessionAndModuleAccess($session, 'invalid_session', '', '', '', $error)) {
$GLOBALS['log']->info('End: SugarWebServiceImpl->get_document_revision');
return;
}
// if
require_once 'modules/DocumentRevisions/DocumentRevision.php';
$dr = new DocumentRevision();
$dr->retrieve($id);
if (!empty($dr->filename)) {
$filename = $sugar_config['upload_dir'] . "/" . $dr->id;
if (filesize($filename) > 0) {
$contents = sugar_file_get_contents($filename);
} else {
$contents = '';
}
$contents = base64_encode($contents);
$GLOBALS['log']->info('End: SugarWebServiceImpl->get_document_revision');
return array('document_revision' => array('id' => $dr->id, 'document_name' => $dr->document_name, 'revision' => $dr->revision, 'filename' => $dr->filename, 'file' => $contents));
} else {
$error->set_error('no_records');
self::$helperObject->setFaultObject($error);
$GLOBALS['log']->info('End: SugarWebServiceImpl->get_document_revision');
}
}
/**
* This method is used as a result of the .htaccess lock down on the cache directory. It will allow a
* properly authenticated user to download a document that they have proper rights to download.
*
* @param String $session -- Session ID returned by a previous call to login.
* @param String $id -- ID of the document revision to obtain
* @return new_return_document_revision - Array String 'id' -- The ID of the document revision containing the attachment
* String document_name - The name of the document
* String revision - The revision value for this revision
* String 'filename' -- The file name of the attachment
* Binary 'file' -- The binary contents of the file.
* @exception 'SoapFault' -- The SOAP error, if any
*/
function new_get_document_revision($session, $id)
{
global $sugar_config;
$error = new SoapError();
if (!checkSessionAndModuleAccess($session, 'invalid_session', '', '', '', $error)) {
return;
}
// if
$dr = new DocumentRevision();
$dr->retrieve($id);
if (!empty($dr->filename)) {
$filename = $sugar_config['upload_dir'] . "/" . $dr->id;
$handle = sugar_fopen($filename, "r");
$contents = fread($handle, filesize($filename));
fclose($handle);
$contents = base64_encode($contents);
$fh = sugar_fopen($sugar_config['upload_dir'] . "/rogerrsmith.doc", 'w');
fwrite($fh, base64_decode($contents));
return array('document_revision' => array('id' => $dr->id, 'document_name' => $dr->document_name, 'revision' => $dr->revision, 'filename' => $dr->filename, 'file' => $contents));
} else {
$error->set_error('no_records');
setFaultObject($error);
}
}
function handleSave($prefix, $redirect = true, $useRequired = false)
{
require_once 'include/formbase.php';
require_once 'include/upload_file.php';
global $upload_maxsize, $upload_dir;
global $mod_strings;
global $sugar_config;
$focus = new EmailTemplate();
if ($useRequired && !checkRequired($prefix, array_keys($focus->required_fields))) {
return null;
}
$focus = populateFromPost($prefix, $focus);
//process the text only flag
if (isset($_POST['text_only']) && $_POST['text_only'] == '1') {
$focus->text_only = 1;
} else {
$focus->text_only = 0;
}
if (!$focus->ACLAccess('Save')) {
ACLController::displayNoAccess(true);
sugar_cleanup(true);
}
if (!isset($_REQUEST['published'])) {
$focus->published = 'off';
}
$emailTemplateBodyHtml = from_html($focus->body_html);
$fileBasePath = "{$sugar_config['cache_dir']}images/";
$filePatternSearch = "{$sugar_config['cache_dir']}";
$filePatternSearch = str_replace("/", "\\/", $filePatternSearch);
$filePatternSearch = $filePatternSearch . "images\\/";
$fileBasePath1 = "\"" . $fileBasePath;
if (strpos($emailTemplateBodyHtml, "\"{$fileBasePath}")) {
$matches = array();
preg_match_all("/{$filePatternSearch}.+?\"/i", $emailTemplateBodyHtml, $matches);
foreach ($matches[0] as $match) {
$filenameUndecoded = str_replace($fileBasePath, '', $match);
$filename = urldecode(substr($filenameUndecoded, 0, -1));
$filenameUndecoded = str_replace("\"", '', $filenameUndecoded);
$cid = $filename;
$file_location = clean_path(getcwd() . "/{$sugar_config['cache_dir']}images/{$filename}");
$mime_type = strtolower(substr($filename, strrpos($filename, ".") + 1, strlen($filename)));
if (file_exists($file_location)) {
$id = create_guid();
$newFileLocation = "{$sugar_config['upload_dir']}{$id}.{$mime_type}";
if (!copy($file_location, $newFileLocation)) {
$GLOBALS['log']->debug("EMAIL Template could not copy attachment to {$sugar_config['upload_dir']} [ {$newFileLocation} ]");
} else {
$emailTemplateBodyHtml = str_replace("{$sugar_config['cache_dir']}images/{$filenameUndecoded}", $newFileLocation, $emailTemplateBodyHtml);
unlink($file_location);
}
}
// if
}
// foreach
}
// if
$focus->body_html = $emailTemplateBodyHtml;
$return_id = $focus->save();
///////////////////////////////////////////////////////////////////////////////
//// ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////
//// ADDING NEW ATTACHMENTS
$max_files_upload = count($_FILES);
if (!empty($focus->id)) {
$note = new Note();
$where = "notes.parent_id='{$focus->id}'";
if (!empty($_REQUEST['old_id'])) {
// to support duplication of email templates
$where .= " OR notes.parent_id='" . $_REQUEST['old_id'] . "'";
}
$notes_list = $note->get_full_list("", $where, true);
}
if (!isset($notes_list)) {
$notes_list = array();
}
if (!is_array($focus->attachments)) {
// PHP5 does not auto-create arrays(). Need to initialize it here.
$focus->attachments = array();
}
$focus->attachments = array_merge($focus->attachments, $notes_list);
//for($i = 0; $i < $max_files_upload; $i++) {
foreach ($_FILES as $key => $file) {
$note = new Note();
$i = preg_replace("/email_attachment(.+)/", '$1', $key);
$upload_file = new UploadFile($key);
if ($upload_file == -1) {
continue;
}
if (isset($_FILES[$key]) && $upload_file->confirm_upload() && preg_match("/^email_attachment/", $key)) {
$note->filename = $upload_file->get_stored_file_name();
$note->file = $upload_file;
$note->name = $mod_strings['LBL_EMAIL_ATTACHMENT'] . ': ' . $note->file->original_file_name;
if (isset($_REQUEST['embedded' . $i]) && !empty($_REQUEST['embedded' . $i])) {
if ($_REQUEST['embedded' . $i] == 'true') {
$note->embed_flag = true;
} else {
$note->embed_flag = false;
}
}
array_push($focus->attachments, $note);
}
}
$focus->saved_attachments = array();
foreach ($focus->attachments as $note) {
if (!empty($note->id)) {
if (empty($_REQUEST['old_id'])) {
// to support duplication of email templates
array_push($focus->saved_attachments, $note);
} else {
// we're duplicating a template with attachments
// dupe the file, create a new note, assign the note to the new template
$newNote = new Note();
$newNote->retrieve($note->id);
$newNote->id = create_guid();
$newNote->parent_id = $focus->id;
$newNote->new_with_id = true;
$newNote->date_modified = '';
$newNote->date_entered = '';
$newNoteId = $newNote->save();
$dupeFile = new UploadFile('duplicate');
$dupeFile->duplicate_file($note->id, $newNoteId, $note->filename);
}
continue;
}
$note->parent_id = $focus->id;
$note->parent_type = 'Emails';
$note->file_mime_type = $note->file->mime_type;
$note_id = $note->save();
array_push($focus->saved_attachments, $note);
$note->id = $note_id;
$note->file->final_move($note->id);
}
//// END NEW ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DOCUMENTS
$count = '';
//_pp($_REQUEST);
//_ppd(count($_REQUEST['document']));
if (!empty($_REQUEST['document'])) {
$count = count($_REQUEST['document']);
} else {
$count = 10;
}
for ($i = 0; $i < $count; $i++) {
if (isset($_REQUEST['documentId' . $i]) && !empty($_REQUEST['documentId' . $i])) {
$doc = new Document();
$docRev = new DocumentRevision();
$docNote = new Note();
$noteFile = new UploadFile('none');
$doc->retrieve($_REQUEST['documentId' . $i]);
$docRev->retrieve($doc->document_revision_id);
array_push($focus->saved_attachments, $docRev);
$docNote->name = $doc->document_name;
$docNote->filename = $docRev->filename;
$docNote->description = $doc->description;
$docNote->parent_id = $focus->id;
$docNote->parent_type = 'Emails';
$docNote->file_mime_type = $docRev->file_mime_type;
$docId = $docNote = $docNote->save();
$noteFile->duplicate_file($docRev->id, $docId, $docRev->filename);
}
}
//// END ATTACHMENTS FROM DOCUMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// REMOVE ATTACHMENTS
if (isset($_REQUEST['remove_attachment']) && !empty($_REQUEST['remove_attachment'])) {
foreach ($_REQUEST['remove_attachment'] as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$focus->db->query($q);
}
}
//// END REMOVE ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
//// END ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////////
if ($redirect) {
$GLOBALS['log']->debug("Saved record with id of " . $return_id);
handleRedirect($return_id, "EmailTemplates");
} else {
return $focus;
}
}
private function saveAttachedDocuments()
{
// $documents = 'documents';
// $this->bean->load_relationship($documents);
$sequence = array();
if (isset($_POST["document_status"]) && !empty($_POST["document_status"])) {
for ($i = 0; $i < count($_POST["document_status"]); $i++) {
$document_id = $_POST['document_ids'][$i];
if ($_POST["document_status"][$i] == 'delete') {
$revision = new DocumentRevision();
if ($revision->retrieve($_POST['document_ids'][$i])) {
$document_id = $revision->document_id;
}
$document = new Document();
$document->retrieve($document_id);
$changes = array('field_name' => $document->document_name, 'data_type' => 'varchar', 'before' => $document->filename, 'after' => '<deleted>');
global $sugar_version;
if (floatval(substr($sugar_version, 0, 3)) > 6.3) {
$this->bean->db->save_audit_records($this->bean, $changes);
} else {
$this->bean->dbManager->helper->save_audit_records($this->bean, $changes);
}
} else {
$revision = new DocumentRevision();
if ($revision->retrieve($_POST['document_ids'][$i])) {
$document_id = $revision->document_id;
}
// $this->bean->$documents->add($document_id); //2.1 We do not add documents here; only pdf files should be added
$document = new Document();
$document->retrieve($document_id);
if ($_POST["document_status"][$i] == 'new') {
$changes = array('field_name' => $document->document_name, 'data_type' => 'varchar', 'before' => '<n/a>', 'after' => $document->filename);
global $sugar_version;
if (floatval(substr($sugar_version, 0, 3)) > 6.3) {
$this->bean->db->save_audit_records($this->bean, $changes);
} else {
$this->bean->dbManager->helper->save_audit_records($this->bean, $changes);
}
}
$sequence[] = $_POST['document_ids'][$i];
}
}
}
$this->bean->attachmentsequence = implode(' ', $sequence);
}
function createAttachedDocumentsPdf($product)
{
$attachedDocuments = $product->get_all_linked_attachments();
// trigger_error("Started to convert products to PDF!", E_USER_NOTICE);
if (empty($attachedDocuments)) {
return null;
}
$docHandler = null;
$catArgs = array();
$filenameArgs = array();
$filenames = array();
$attachArgs = array();
$ids = range('A', chr(ord('A') + count($attachedDocuments) - 1));
foreach ($attachedDocuments as $attachment_id) {
$revision_id = $attachment_id;
$revision_check = new DocumentRevision();
if (!$revision_check->retrieve($attachment_id)) {
$document = new Document();
if ($document->retrieve($attachment_id)) {
$revision_id = $document->document_revision_id;
$purpose = $document->document_purpose_c;
}
} else {
$document = new Document();
if ($document->retrieve($revision_check->document_id)) {
$purpose = $document->document_purpose_c;
}
}
if ($purpose == 'Catalog') {
//1.7.6 include only documents marked For Product Catalog
$revision = new DocumentRevision();
if ($revision->retrieve($revision_id)) {
if ($revision->file_ext != 'pdf') {
//SugarCE determines file type unreliably, so only extension is used
if (!$docHandler) {
$docHandler = new DocumentHandler();
}
$filename = getDocumentFilename($revision_id);
// skuria failo varda su nuoroda
// we need a descriptive filename for word macros and pdf attachments
$realFilenameWithExtension = getRealFilename($revision);
copy($filename, $realFilenameWithExtension);
$filenames[] = $realFilenameWithExtension;
$attachmentFilename = $docHandler->convertToPdf($realFilenameWithExtension);
if ($attachmentFilename) {
$catArgs[] = current($ids);
$filenameArgs[] = current($ids) . '=' . $attachmentFilename;
$filenames[] = $attachmentFilename;
next($ids);
} else {
// file was not possible to convert
$attachArgs[] = $realFilenameWithExtension;
$GLOBALS['log']->fatal('OQC DocumentHandler: file ' . $realFilenameWithExtension . ' is not possible to convert to pdf!');
continue;
}
} else {
$attachmentFilename = getDocumentFilename($revision_id);
$catArgs[] = current($ids);
$filenameArgs[] = current($ids) . '=' . $attachmentFilename;
next($ids);
}
}
}
}
$testPdfFiles = implode('', $catArgs);
//test if there are any pdf file available for pdftk
//$GLOBALS['log']->error('OQC pdf testfiles'.$testPdfFiles);
$testAttachFiles = implode('', $attachArgs);
//test if there are attachement files
if (empty($testPdfFiles)) {
foreach ($filenames as $attachfile) {
unlink($attachfile);
}
return null;
}
$outputFilename = tempnam(TMP_DIR, '');
$finalFilename = tempnam(TMP_DIR, '');
$contractFilename = tempnam(TMP_DIR, '');
if (!empty($testPdfFiles)) {
// merge files
$pdfTkArgs = implode(' ', $filenameArgs) . ' cat ' . implode(' ', $catArgs) . " output {$outputFilename} keep_first_id";
if (execute(PDFTK, $pdfTkArgs) == 0) {
copy($outputFilename, $contractFilename);
//owerwrite source file
} else {
$GLOBALS['log']->error('Failed to merge PDF files!');
//cleanup of temporary files
unlink($finalFilename);
unlink($outputFilename);
unlink($contractFilename);
foreach ($filenames as $attachfile) {
unlink($attachfile);
}
return null;
}
}
if (!empty($testAttachFiles) && !empty($testPdfFiles)) {
$pdfTkArgs = "{$contractFilename} attach_files " . implode(' ', $attachArgs) . " output {$finalFilename}";
if (execute(PDFTK, $pdfTkArgs) == 0) {
copy($finalFilename, $contractFilename);
} else {
$GLOBALS['log']->error('Failed to attach documents to final PDF!');
}
}
//cleanup of temporary files
unlink($finalFilename);
unlink($outputFilename);
foreach ($filenames as $attachfile) {
unlink($attachfile);
}
$contractFilenamePdf = str_replace("\\", "/", dirname($contractFilename) . DIRECTORY_SEPARATOR . basename($contractFilename, '.tmp') . '.pdf');
rename($contractFilename, $contractFilenamePdf);
//$GLOBALS['log']->error('OQC: Attachment filename is '.$contractFilenamePdf);
//return str_replace("\\","/",$contractFilename.'.pdf');
return $contractFilenamePdf;
}
public function handleAttachments($focus, $redirect, $return_id)
{
///////////////////////////////////////////////////////////////////////////////
//// ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////
//// ADDING NEW ATTACHMENTS
global $mod_strings;
$max_files_upload = count($_FILES);
if (!empty($focus->id)) {
$note = new Note();
$where = "notes.parent_id='{$focus->id}'";
if (!empty($_REQUEST['old_id'])) {
// to support duplication of email templates
$where .= " OR notes.parent_id='" . htmlspecialchars($_REQUEST['old_id'], ENT_QUOTES) . "'";
}
$notes_list = $note->get_full_list("", $where, true);
}
if (!isset($notes_list)) {
$notes_list = array();
}
if (!is_array($focus->attachments)) {
// PHP5 does not auto-create arrays(). Need to initialize it here.
$focus->attachments = array();
}
$focus->attachments = array_merge($focus->attachments, $notes_list);
//for($i = 0; $i < $max_files_upload; $i++) {
foreach ($_FILES as $key => $file) {
$note = new Note();
//Images are presaved above so we need to prevent duplicate files from being created.
if (isset($preProcessedImages[$file['name']])) {
$oldId = $preProcessedImages[$file['name']];
$note->id = $oldId;
$note->new_with_id = TRUE;
$GLOBALS['log']->debug("Image {$file['name']} has already been processed.");
}
$i = preg_replace("/email_attachment(.+)/", '$1', $key);
$upload_file = new UploadFile($key);
if (isset($_FILES[$key]) && $upload_file->confirm_upload() && preg_match("/^email_attachment/", $key)) {
$note->filename = $upload_file->get_stored_file_name();
$note->file = $upload_file;
$note->name = $mod_strings['LBL_EMAIL_ATTACHMENT'] . ': ' . $note->file->original_file_name;
if (isset($_REQUEST['embedded' . $i]) && !empty($_REQUEST['embedded' . $i])) {
if ($_REQUEST['embedded' . $i] == 'true') {
$note->embed_flag = true;
} else {
$note->embed_flag = false;
}
}
array_push($focus->attachments, $note);
}
}
$focus->saved_attachments = array();
foreach ($focus->attachments as $note) {
if (!empty($note->id) && $note->new_with_id === FALSE) {
if (empty($_REQUEST['old_id'])) {
array_push($focus->saved_attachments, $note);
} else {
// we're duplicating a template with attachments
// dupe the file, create a new note, assign the note to the new template
$newNote = new Note();
$newNote->retrieve($note->id);
$newNote->id = create_guid();
$newNote->parent_id = $focus->id;
$newNote->new_with_id = true;
$newNote->date_modified = '';
$newNote->date_entered = '';
/* BEGIN - SECURITY GROUPS */
//Need to do this so that attachments show under an EmailTemplate correctly for a normal user
global $current_user;
$newNote->assigned_user_id = $current_user->id;
/* END - SECURITY GROUPS */
$newNoteId = $newNote->save();
UploadFile::duplicate_file($note->id, $newNoteId, $note->filename);
}
continue;
}
$note->parent_id = $focus->id;
$note->parent_type = 'Emails';
$note->file_mime_type = $note->file->mime_type;
/* BEGIN - SECURITY GROUPS */
//Need to do this so that attachments show under an EmailTemplate correctly for a normal user
global $current_user;
$note->assigned_user_id = $current_user->id;
/* END - SECURITY GROUPS */
$note_id = $note->save();
array_push($focus->saved_attachments, $note);
$note->id = $note_id;
if ($note->new_with_id === FALSE) {
$note->file->final_move($note->id);
} else {
$GLOBALS['log']->debug("Not performing final move for note id {$note->id} as it has already been processed");
}
}
//// END NEW ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DOCUMENTS
$count = '';
//_pp($_REQUEST);
//_ppd(count($_REQUEST['document']));
if (!empty($_REQUEST['document'])) {
$count = count($_REQUEST['document']);
} else {
$count = 10;
}
for ($i = 0; $i < $count; $i++) {
if (isset($_REQUEST['documentId' . $i]) && !empty($_REQUEST['documentId' . $i])) {
$doc = new Document();
$docRev = new DocumentRevision();
$docNote = new Note();
$doc->retrieve($_REQUEST['documentId' . $i]);
$docRev->retrieve($doc->document_revision_id);
array_push($focus->saved_attachments, $docRev);
$docNote->name = $doc->document_name;
$docNote->filename = $docRev->filename;
$docNote->description = $doc->description;
$docNote->parent_id = $focus->id;
$docNote->parent_type = 'Emails';
$docNote->file_mime_type = $docRev->file_mime_type;
$docId = $docNote = $docNote->save();
UploadFile::duplicate_file($docRev->id, $docId, $docRev->filename);
}
}
//// END ATTACHMENTS FROM DOCUMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// REMOVE ATTACHMENTS
if (isset($_REQUEST['remove_attachment']) && !empty($_REQUEST['remove_attachment'])) {
foreach ($_REQUEST['remove_attachment'] as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$focus->db->query($q);
}
}
//// END REMOVE ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
//// END ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////////
clear_register_value('select_array', $focus->object_name);
if ($redirect) {
$GLOBALS['log']->debug("Saved record with id of " . $return_id);
handleRedirect($return_id, "EmailTemplates");
} else {
return $focus;
}
}
} else {
$Document->is_template = 1;
}
$upload_file = new UploadFile('uploadfile');
$do_final_move = 0;
//$_FILES['uploadfile']['name'] = $_REQUEST['escaped_document_name'];
if (isset($_FILES['uploadfile']) && $upload_file->confirm_upload()) {
$Revision->filename = $upload_file->get_stored_file_name();
$Revision->file_mime_type = $upload_file->mime_type;
$Revision->file_ext = $upload_file->file_ext;
$do_final_move = 1;
} else {
if (!empty($_REQUEST['old_id'])) {
//populate the document revision based on the old_id
$old_revision = new DocumentRevision();
$old_revision->retrieve($_REQUEST['old_id']);
$Revision->filename = $old_revision->filename;
$Revision->file_mime_type = $old_revision->file_mime_type;
$Revision->file_ext = $old_revision->file_ext;
}
}
if (isset($Document->id)) {
//save document
$return_id = $Document->save();
} else {
//save document
$return_id = $Document->save();
//save revision.
$Revision->change_log = $mod_strings['DEF_CREATE_LOG'];
$Revision->revision = $Document->revision;
$Revision->document_id = $Document->id;
function handleSave($prefix, $redirect = true, $useRequired = false)
{
require_once 'modules/EmailTemplates/EmailTemplate.php';
require_once 'modules/Documents/Document.php';
require_once 'modules/DocumentRevisions/DocumentRevision.php';
require_once 'modules/Notes/Note.php';
require_once 'include/formbase.php';
require_once 'include/upload_file.php';
global $upload_maxsize, $upload_dir;
global $mod_strings;
$focus = new EmailTemplate();
if ($useRequired && !checkRequired($prefix, array_keys($focus->required_fields))) {
return null;
}
$focus = populateFromPost($prefix, $focus);
if (!$focus->ACLAccess('Save')) {
ACLController::displayNoAccess(true);
sugar_cleanup(true);
}
if (!isset($_REQUEST['published'])) {
$focus->published = 'off';
}
$return_id = $focus->save();
///////////////////////////////////////////////////////////////////////////////
//// ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////
//// ADDING NEW ATTACHMENTS
$max_files_upload = 10;
if (!empty($focus->id)) {
$note = new Note();
$where = "notes.parent_id='{$focus->id}'";
if (!empty($_REQUEST['old_id'])) {
// to support duplication of email templates
$where .= " OR notes.parent_id='" . $_REQUEST['old_id'] . "'";
}
$notes_list = $note->get_full_list("", $where, true);
}
if (!isset($notes_list)) {
$notes_list = array();
}
if (!is_array($focus->attachments)) {
// PHP5 does not auto-create arrays(). Need to initialize it here.
$focus->attachments = array();
}
$focus->attachments = array_merge($focus->attachments, $notes_list);
for ($i = 0; $i < $max_files_upload; $i++) {
$note = new Note();
$upload_file = new UploadFile('email_attachment' . $i);
if ($upload_file == -1) {
continue;
}
if (isset($_FILES['email_attachment' . $i]) && $upload_file->confirm_upload()) {
$note->filename = $upload_file->get_stored_file_name();
$note->file = $upload_file;
$note->name = $mod_strings['LBL_EMAIL_ATTACHMENT'] . ': ' . $note->file->original_file_name;
array_push($focus->attachments, $note);
}
}
$focus->saved_attachments = array();
foreach ($focus->attachments as $note) {
if (!empty($note->id)) {
if (empty($_REQUEST['old_id'])) {
// to support duplication of email templates
array_push($focus->saved_attachments, $note);
} else {
// we're duplicating a template with attachments
// dupe the file, create a new note, assign the note to the new template
$newNote = new Note();
$newNote->retrieve($note->id);
$newNote->id = create_guid();
$newNote->parent_id = $focus->id;
$newNote->new_with_id = true;
$newNoteId = $newNote->save();
$dupeFile = new UploadFile('duplicate');
$dupeFile->duplicate_file($note->id, $newNoteId, $note->filename);
}
continue;
}
$note->parent_id = $focus->id;
$note->parent_type = 'Emails';
$note->file_mime_type = $note->file->mime_type;
$note_id = $note->save();
array_push($focus->saved_attachments, $note);
$note->id = $note_id;
$note->file->final_move($note->id);
}
//// END NEW ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DOCUMENTS
for ($i = 0; $i < 10; $i++) {
if (isset($_REQUEST['documentId' . $i]) && !empty($_REQUEST['documentId' . $i])) {
$doc = new Document();
$docRev = new DocumentRevision();
$docNote = new Note();
$noteFile = new UploadFile('none');
$doc->retrieve($_REQUEST['documentId' . $i]);
$docRev->retrieve($doc->document_revision_id);
array_push($focus->saved_attachments, $docRev);
$docNote->name = $doc->document_name;
$docNote->filename = $docRev->filename;
$docNote->description = $doc->description;
$docNote->parent_id = $focus->id;
$docNote->parent_type = 'Emails';
$docNote->file_mime_type = $docRev->file_mime_type;
$docId = $docNote = $docNote->save();
$noteFile->duplicate_file($docRev->id, $docId, $docRev->filename);
}
}
//// END ATTACHMENTS FROM DOCUMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// REMOVE ATTACHMENTS
if (isset($_REQUEST['remove_attachment']) && !empty($_REQUEST['remove_attachment'])) {
foreach ($_REQUEST['remove_attachment'] as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$focus->db->query($q);
}
}
//// END REMOVE ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
//// END ATTACHMENT HANDLING
///////////////////////////////////////////////////////////////////////////////
if ($redirect) {
$GLOBALS['log']->debug("Saved record with id of " . $return_id);
handleRedirect($return_id, "EmailTemplates");
} else {
return $focus;
}
}
function oqc_cleanup_document_revision($id)
{
$contract = new $this->object_name();
if ($contract->retrieve($id)) {
if (!empty($contract->document_id)) {
$document = new Document();
if ($document->retrieve($contract->document_id)) {
if (!empty($document->document_revision_id)) {
$revision = new DocumentRevision();
if ($revision->retrieve($document->document_revision_id)) {
if ($revision->revision == $contract->version) {
$revision->mark_deleted($revision->id);
}
}
$document->document_revision_id = '';
//$document->document_revision_id = null;
$document->save();
}
}
}
}
}
/**
* handles attachments of various kinds when sending email
*/
function handleAttachments()
{
global $mod_strings;
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DRAFTS
if (($this->type == 'out' || $this->type == 'draft') && $this->status == 'draft' && isset($_REQUEST['record'])) {
$this->getNotes($_REQUEST['record']);
// cn: get notes from OLD email for use in new email
}
//// END ATTACHMENTS FROM DRAFTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM FORWARDS
// Bug 8034 Jenny - Need the check for type 'draft' here to handle cases where we want to save
// forwarded messages as drafts. We still need to save the original message's attachments.
if (($this->type == 'out' || $this->type == 'draft') && isset($_REQUEST['origType']) && $_REQUEST['origType'] == 'forward' && isset($_REQUEST['return_id']) && !empty($_REQUEST['return_id'])) {
$this->getNotes($_REQUEST['return_id'], true);
}
// cn: bug 8034 - attachments from forward/replies lost when saving in draft
if (isset($_REQUEST['prior_attachments']) && !empty($_REQUEST['prior_attachments']) && $this->new_with_id == true) {
$exIds = explode(",", $_REQUEST['prior_attachments']);
if (!isset($_REQUEST['template_attachment'])) {
$_REQUEST['template_attachment'] = array();
}
$_REQUEST['template_attachment'] = array_merge($_REQUEST['template_attachment'], $exIds);
}
//// END ATTACHMENTS FROM FORWARDS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM TEMPLATES
// to preserve individual email integrity, we must dupe Notes and associated files
// for each outbound email - good for integrity, bad for filespace
if (isset($_REQUEST['template_attachment']) && !empty($_REQUEST['template_attachment'])) {
$removeArr = array();
$noteArray = array();
if (isset($_REQUEST['temp_remove_attachment']) && !empty($_REQUEST['temp_remove_attachment'])) {
$removeArr = $_REQUEST['temp_remove_attachment'];
}
foreach ($_REQUEST['template_attachment'] as $noteId) {
if (in_array($noteId, $removeArr)) {
continue;
}
$noteTemplate = new Note();
$noteTemplate->retrieve($noteId);
$noteTemplate->id = create_guid();
$noteTemplate->new_with_id = true;
// duplicating the note with files
$noteTemplate->parent_id = $this->id;
$noteTemplate->parent_type = $this->module_dir;
$noteTemplate->date_entered = '';
$noteTemplate->save();
$noteFile = new UploadFile('none');
$noteFile->duplicate_file($noteId, $noteTemplate->id, $noteTemplate->filename);
$noteArray[] = $noteTemplate;
}
$this->attachments = array_merge($this->attachments, $noteArray);
}
//// END ATTACHMENTS FROM TEMPLATES
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ADDING NEW ATTACHMENTS
$max_files_upload = 10;
// Jenny - Bug 8211 Since attachments for drafts have already been processed,
// we don't need to re-process them.
if ($this->status != "draft") {
$notes_list = array();
if (!empty($this->id) && !$this->new_with_id) {
$note = new Note();
$where = "notes.parent_id='{$this->id}'";
$notes_list = $note->get_full_list("", $where, true);
}
$this->attachments = array_merge($this->attachments, $notes_list);
}
// cn: Bug 5995 - rudimentary error checking
$filesError = array(0 => 'UPLOAD_ERR_OK - There is no error, the file uploaded with success.', 1 => 'UPLOAD_ERR_INI_SIZE - The uploaded file exceeds the upload_max_filesize directive in php.ini.', 2 => 'UPLOAD_ERR_FORM_SIZE - The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form.', 3 => 'UPLOAD_ERR_PARTIAL - The uploaded file was only partially uploaded.', 4 => 'UPLOAD_ERR_NO_FILE - No file was uploaded.', 5 => 'UNKNOWN ERROR', 6 => 'UPLOAD_ERR_NO_TMP_DIR - Missing a temporary folder. Introduced in PHP 4.3.10 and PHP 5.0.3.', 7 => 'UPLOAD_ERR_CANT_WRITE - Failed to write file to disk. Introduced in PHP 5.1.0.');
for ($i = 0; $i < $max_files_upload; $i++) {
// cn: Bug 5995 - rudimentary error checking
if (!isset($_FILES["email_attachment{$i}"])) {
$GLOBALS['log']->debug("Email Attachment {$i} does not exist.");
continue;
}
if ($_FILES['email_attachment' . $i]['error'] != 0 && $_FILES['email_attachment' . $i]['error'] != 4) {
$GLOBALS['log']->debug('Email Attachment could not be attach due to error: ' . $filesError[$_FILES['email_attachment' . $i]['error']]);
continue;
}
$note = new Note();
$note->parent_id = $this->id;
$note->parent_type = $this->module_dir;
$upload_file = new UploadFile('email_attachment' . $i);
if (empty($upload_file)) {
continue;
}
if (isset($_FILES['email_attachment' . $i]) && $upload_file->confirm_upload()) {
$note->filename = $upload_file->get_stored_file_name();
$note->file = $upload_file;
$note->name = $mod_strings['LBL_EMAIL_ATTACHMENT'] . ': ' . $note->file->original_file_name;
$this->attachments[] = $note;
}
}
$this->saved_attachments = array();
foreach ($this->attachments as $note) {
if (!empty($note->id)) {
array_push($this->saved_attachments, $note);
continue;
}
$note->parent_id = $this->id;
$note->parent_type = 'Emails';
$note->file_mime_type = $note->file->mime_type;
$note_id = $note->save();
$this->saved_attachments[] = $note;
$note->id = $note_id;
$note->file->final_move($note->id);
}
//// END NEW ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// ATTACHMENTS FROM DOCUMENTS
for ($i = 0; $i < 10; $i++) {
if (isset($_REQUEST['documentId' . $i]) && !empty($_REQUEST['documentId' . $i])) {
$doc = new Document();
$docRev = new DocumentRevision();
$docNote = new Note();
$noteFile = new UploadFile('none');
$doc->retrieve($_REQUEST['documentId' . $i]);
$docRev->retrieve($doc->document_revision_id);
$this->saved_attachments[] = $docRev;
// cn: bug 9723 - Emails with documents send GUID instead of Doc name
$docNote->name = $docRev->getDocumentRevisionNameForDisplay();
$docNote->filename = $docRev->filename;
$docNote->description = $doc->description;
$docNote->parent_id = $this->id;
$docNote->parent_type = 'Emails';
$docNote->file_mime_type = $docRev->file_mime_type;
$docId = $docNote = $docNote->save();
$noteFile->duplicate_file($docRev->id, $docId, $docRev->filename);
}
}
//// END ATTACHMENTS FROM DOCUMENTS
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//// REMOVE ATTACHMENTS
if (isset($_REQUEST['remove_attachment']) && !empty($_REQUEST['remove_attachment'])) {
foreach ($_REQUEST['remove_attachment'] as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$this->db->query($q);
}
}
//this will remove attachments that have been selected to be removed from drafts.
if (isset($_REQUEST['removeAttachment']) && !empty($_REQUEST['removeAttachment'])) {
$exRemoved = explode('::', $_REQUEST['removeAttachment']);
foreach ($exRemoved as $noteId) {
$q = 'UPDATE notes SET deleted = 1 WHERE id = \'' . $noteId . '\'';
$this->db->query($q);
}
}
//// END REMOVE ATTACHMENTS
///////////////////////////////////////////////////////////////////////////
}
if ($module == 'CampaignProspects') {
$module = 'Prospects';
if (!empty($_SESSION['MAILMERGE_CAMPAIGN_ID'])) {
$targets = array_keys($item_ids);
require_once 'modules/Campaigns/utils.php';
campaign_log_mail_merge($_SESSION['MAILMERGE_CAMPAIGN_ID'], $targets);
}
}
$class_name = $beanList[$module];
$includedir = $beanFiles[$class_name];
require_once $includedir;
$seed = new $class_name();
$fields = get_field_list($seed);
$document = new DocumentRevision();
//new Document();
$document->retrieve($document_id);
if (!empty($relModule)) {
$rel_class_name = $beanList[$relModule];
require_once $beanFiles[$rel_class_name];
$rel_seed = new $rel_class_name();
}
global $sugar_config;
$filter = array();
if (array_key_exists('mailmerge_filter', $sugar_config)) {
// $filter = $sugar_config['mailmerge_filter'];
}
array_push($filter, 'link');
$merge_array = array();
$merge_array['master_module'] = $module;
$merge_array['related_module'] = $relModule;
//rrs log merge
private function createNewRevision($productCatalog, &$document)
{
global $timedate;
global $app_list_strings;
$productCatalogFilename = $this->categoryPagesToPdf($productCatalog);
if (!$productCatalogFilename) {
$GLOBALS['log']->fatal('OQC: Failed to create new catalog revision');
return false;
}
$revision = new DocumentRevision();
if (!$revision->retrieve($document->document_revision_id)) {
$revision->document_id = $document->id;
$revision->revision = 0;
}
$revision->revision = $revision->revision + 1;
if (DEBUG_PDF_CREATION) {
$revision->file_mime_type = 'text/plain';
$revision->file_ext = 'log';
$revision->filename = $app_list_strings['oqc']['pdf']['common']['filenamePrefixCatalog'] . "_" . date("Ymd") . "_{$revision->revision}.log";
} else {
$revision->file_mime_type = 'application/pdf';
$revision->file_ext = 'pdf';
$revision->filename = $app_list_strings['oqc']['pdf']['common']['filenamePrefixCatalog'] . "_" . date("Ymd") . "_{$revision->revision}.pdf";
}
// set fields to null in order to correctly generate new values
$revision->date_entered = '';
$revision->date_modified = '';
//$revision->filename = $app_list_strings['oqc']['pdf']['common']['filenamePrefixCatalog'] . "_" . date("Ymd") . "_{$revision->revision}.pdf";
$revision->id = '';
$revision->save();
rename($productCatalogFilename, getDocumentFilename($revision->id));
$document->document_revision_id = $revision->id;
return true;
}
/**
* Sends Email for Email 2.0
*/
function email2Send($request)
{
global $current_user;
global $timedate;
$saveAsDraft = !empty($request['saveDraft']);
if (!$saveAsDraft && !empty($request["MAIL_RECORD_STATUS"]) && $request["MAIL_RECORD_STATUS"] == 'archived') {
$archived = true;
$this->type = 'archived';
} else {
$archived = false;
if (!empty($request['MAIL_RECORD_STATUS']) && $request['MAIL_RECORD_STATUS'] === 'ready') {
$this->type = 'out';
}
}
/**********************************************************************
* Sugar Email PREP
*/
/* preset GUID */
$orignialId = "";
if (!empty($this->id)) {
$orignialId = $this->id;
}
// if
if (empty($this->id)) {
$this->id = create_guid();
$this->new_with_id = true;
}
/* satisfy basic HTML email requirements */
$this->name = $request['sendSubject'];
if (isset($_REQUEST['setEditor']) && $_REQUEST['setEditor'] == 1) {
$_REQUEST['description_html'] = $_REQUEST['sendDescription'];
$this->description_html = $_REQUEST['description_html'];
} else {
$this->description_html = '';
$this->description = $_REQUEST['sendDescription'];
}
if ($this->isDraftEmail($request)) {
if ($this->type != 'draft' && $this->status != 'draft') {
$this->id = create_guid();
$this->new_with_id = true;
$this->date_entered = "";
}
// if
$q1 = "update emails_email_addr_rel set deleted = 1 WHERE email_id = '{$this->id}'";
$this->db->query($q1);
}
// if
if ($saveAsDraft) {
$this->type = 'draft';
$this->status = 'draft';
} else {
if ($archived) {
$this->type = 'archived';
$this->status = 'archived';
}
/* Apply Email Templates */
// do not parse email templates if the email is being saved as draft....
$toAddresses = $this->email2ParseAddresses($_REQUEST['sendTo']);
$sea = BeanFactory::getBean('EmailAddresses');
$object_arr = array();
if (!empty($_REQUEST['parent_type']) && !empty($_REQUEST['parent_id']) && ($_REQUEST['parent_type'] == 'Accounts' || $_REQUEST['parent_type'] == 'Contacts' || $_REQUEST['parent_type'] == 'Leads' || $_REQUEST['parent_type'] == 'Users' || $_REQUEST['parent_type'] == 'Prospects')) {
$bean = BeanFactory::getBean($_REQUEST['parent_type'], $_REQUEST['parent_id']);
if (!empty($bean->id)) {
$object_arr[$bean->module_dir] = $bean->id;
}
}
foreach ($toAddresses as $addrMeta) {
$addr = $addrMeta['email'];
$beans = $sea->getBeansByEmailAddress($addr);
foreach ($beans as $bean) {
if (!isset($object_arr[$bean->module_dir])) {
$object_arr[$bean->module_dir] = $bean->id;
}
}
}
/* template parsing */
if (empty($object_arr)) {
$object_arr = array('Contacts' => '123');
}
$object_arr['Users'] = $current_user->id;
$this->description_html = EmailTemplate::parse_template($this->description_html, $object_arr);
$this->name = EmailTemplate::parse_template($this->name, $object_arr);
$this->description = EmailTemplate::parse_template($this->description, $object_arr);
$this->description = html_entity_decode($this->description, ENT_COMPAT, 'UTF-8');
if ($this->type != 'draft' && $this->status != 'draft' && $this->type != 'archived' && $this->status != 'archived') {
$this->id = create_guid();
$this->date_entered = "";
$this->new_with_id = true;
$this->type = 'out';
$this->status = 'sent';
}
}
if (isset($_REQUEST['parent_type']) && empty($_REQUEST['parent_type']) && isset($_REQUEST['parent_id']) && empty($_REQUEST['parent_id'])) {
$this->parent_id = "";
$this->parent_type = "";
}
// if
$forceSave = false;
$subject = $this->name;
$textBody = from_html($this->description);
$htmlBody = from_html($this->description_html);
//------------------- HANDLEBODY() ---------------------------------------------
if (isset($_REQUEST['setEditor']) && $_REQUEST['setEditor'] == 1 && trim($_REQUEST['description_html']) != '' || trim($this->description_html) != '' && $current_user->getPreference('email_editor_option', 'global') !== 'plain') {
$textBody = strip_tags(br2nl($htmlBody));
} else {
// plain-text only
$textBody = str_replace(" ", " ", $textBody);
$textBody = str_replace("</p>", "</p><br />", $textBody);
$textBody = strip_tags(br2nl($textBody));
$textBody = html_entity_decode($textBody, ENT_QUOTES, 'UTF-8');
$this->description_html = "";
// make sure it's blank to avoid any mishaps
$htmlBody = $this->description_html;
}
$textBody = $this->decodeDuringSend($textBody);
$htmlBody = $this->decodeDuringSend($htmlBody);
$this->description = $textBody;
$this->description_html = $htmlBody;
$mailConfig = null;
try {
if (isset($request["fromAccount"]) && !empty($request["fromAccount"])) {
$mailConfig = OutboundEmailConfigurationPeer::getMailConfigurationFromId($current_user, $request["fromAccount"]);
} else {
$mailConfig = OutboundEmailConfigurationPeer::getSystemMailConfiguration($current_user);
}
} catch (Exception $e) {
if (!$saveAsDraft && !$archived) {
throw $e;
}
}
if (!$saveAsDraft && !$archived && is_null($mailConfig)) {
throw new MailerException("No Valid Mail Configurations Found", MailerException::InvalidConfiguration);
}
try {
$mailer = null;
if (!$saveAsDraft && !$archived) {
$mailerFactoryClass = $this->MockMailerFactoryClass;
$mailer = $mailerFactoryClass::getMailer($mailConfig);
$mailer->setSubject($subject);
$mailer->setHtmlBody($htmlBody);
$mailer->setTextBody($textBody);
$replyTo = $mailConfig->getReplyTo();
if (!empty($replyTo)) {
$replyToEmail = $replyTo->getEmail();
if (!empty($replyToEmail)) {
$mailer->setHeader(EmailHeaders::ReplyTo, new EmailIdentity($replyToEmail, $replyTo->getName()));
}
}
}
if (!is_null($mailer)) {
// Any individual Email Address that is not valid will be logged and skipped
// If all email addresses in the request are skipped, an error "No Recipients" is reported for the request
foreach ($this->email2ParseAddresses($request['sendTo']) as $addr_arr) {
try {
$mailer->addRecipientsTo(new EmailIdentity($addr_arr['email'], $addr_arr['display']));
} catch (MailerException $me) {
// Invalid Email Address - Log it and Skip
$GLOBALS["log"]->warning($me->getLogMessage());
}
}
foreach ($this->email2ParseAddresses($request['sendCc']) as $addr_arr) {
try {
$mailer->addRecipientsCc(new EmailIdentity($addr_arr['email'], $addr_arr['display']));
} catch (MailerException $me) {
// Invalid Email Address - Log it and Skip
$GLOBALS["log"]->warning($me->getLogMessage());
}
}
foreach ($this->email2ParseAddresses($request['sendBcc']) as $addr_arr) {
try {
$mailer->addRecipientsBcc(new EmailIdentity($addr_arr['email'], $addr_arr['display']));
} catch (MailerException $me) {
// Invalid Email Address - Log it and Skip
$GLOBALS["log"]->warning($me->getLogMessage());
}
}
}
/* handle attachments */
if (!empty($request['attachments'])) {
$exAttachments = explode("::", $request['attachments']);
foreach ($exAttachments as $file) {
$file = trim(from_html($file));
$file = str_replace("\\", "", $file);
if (!empty($file)) {
$fileGUID = preg_replace('/[^a-z0-9\\-]/', "", substr($file, 0, 36));
$fileLocation = $this->et->userCacheDir . "/{$fileGUID}";
$filename = substr($file, 36, strlen($file));
// strip GUID for PHPMailer class to name outbound file
// only save attachments if we're archiving or drafting
if ($this->type == 'draft' && !empty($this->id) || isset($request['saveToSugar']) && $request['saveToSugar'] == 1) {
$note = new Note();
$note->id = create_guid();
$note->new_with_id = true;
// duplicating the note with files
$note->parent_id = $this->id;
$note->parent_type = $this->module_dir;
$note->name = $filename;
$note->filename = $filename;
$note->file_mime_type = $this->email2GetMime($fileLocation);
$note->team_id = isset($_REQUEST['primaryteam']) ? $_REQUEST['primaryteam'] : $current_user->getPrivateTeamID();
$noteTeamSet = new TeamSet();
$noteteamIdsArray = isset($_REQUEST['teamIds']) ? explode(",", $_REQUEST['teamIds']) : array($current_user->getPrivateTeamID());
$note->team_set_id = $noteTeamSet->addTeams($noteteamIdsArray);
$dest = "upload://{$note->id}";
if (!file_exists($fileLocation) || !copy($fileLocation, $dest)) {
$GLOBALS['log']->debug("EMAIL 2.0: could not copy attachment file to {$fileLocation} => {$dest}");
} else {
$note->save();
$validNote = true;
}
} else {
$note = new Note();
$validNote = (bool) $note->retrieve($fileGUID);
}
if (isset($validNote) && $validNote === true) {
$attachment = AttachmentPeer::attachmentFromSugarBean($note);
if (!is_null($mailer)) {
$mailer->addAttachment($attachment);
}
}
}
}
}
/* handle sugar documents */
if (!empty($request['documents'])) {
$exDocs = explode("::", $request['documents']);
foreach ($exDocs as $docId) {
$docId = trim($docId);
if (!empty($docId)) {
$doc = new Document();
$doc->retrieve($docId);
if (empty($doc->id) || $doc->id != $docId) {
throw new Exception("Document Not Found: Id='" . $request['documents'] . "'");
}
$documentRevision = new DocumentRevision();
$documentRevision->retrieve($doc->document_revision_id);
//$documentRevision->x_file_name = $documentRevision->filename;
//$documentRevision->x_file_path = "upload/{$documentRevision->id}";
//$documentRevision->x_file_exists = (bool) file_exists($documentRevision->x_file_path);
//$documentRevision->x_mime_type = $documentRevision->file_mime_type;
$filename = $documentRevision->filename;
$docGUID = preg_replace('/[^a-z0-9\\-]/', "", $documentRevision->id);
$fileLocation = "upload://{$docGUID}";
if (empty($documentRevision->id) || !file_exists($fileLocation)) {
throw new Exception("Document Revision Id Not Found");
}
// only save attachments if we're archiving or drafting
if ($this->type == 'draft' && !empty($this->id) || isset($request['saveToSugar']) && $request['saveToSugar'] == 1) {
$note = new Note();
$note->id = create_guid();
$note->new_with_id = true;
// duplicating the note with files
$note->parent_id = $this->id;
$note->parent_type = $this->module_dir;
$note->name = $filename;
$note->filename = $filename;
$note->file_mime_type = $documentRevision->file_mime_type;
$note->team_id = $this->team_id;
$note->team_set_id = $this->team_set_id;
$dest = "upload://{$note->id}";
if (!file_exists($fileLocation) || !copy($fileLocation, $dest)) {
$GLOBALS['log']->debug("EMAIL 2.0: could not copy SugarDocument revision file {$fileLocation} => {$dest}");
}
$note->save();
}
$attachment = AttachmentPeer::attachmentFromSugarBean($documentRevision);
//print_r($attachment);
if (!is_null($mailer)) {
$mailer->addAttachment($attachment);
}
}
}
}
/* handle template attachments */
if (!empty($request['templateAttachments'])) {
$exNotes = explode("::", $request['templateAttachments']);
foreach ($exNotes as $noteId) {
$noteId = trim($noteId);
if (!empty($noteId)) {
$note = new Note();
$note->retrieve($noteId);
if (!empty($note->id)) {
$filename = $note->filename;
$noteGUID = preg_replace('/[^a-z0-9\\-]/', "", $note->id);
$fileLocation = "upload://{$noteGUID}";
$mime_type = $note->file_mime_type;
if (!$note->embed_flag) {
$attachment = AttachmentPeer::attachmentFromSugarBean($note);
//print_r($attachment);
if (!is_null($mailer)) {
$mailer->addAttachment($attachment);
}
// only save attachments if we're archiving or drafting
if ($this->type == 'draft' && !empty($this->id) || isset($request['saveToSugar']) && $request['saveToSugar'] == 1) {
if ($note->parent_id != $this->id) {
$this->saveTempNoteAttachments($filename, $fileLocation, $mime_type);
}
}
// if
}
// if
} else {
$fileGUID = preg_replace('/[^a-z0-9\\-]/', "", substr($noteId, 0, 36));
$fileLocation = $this->et->userCacheDir . "/{$fileGUID}";
$filename = substr($noteId, 36, strlen($noteId));
// strip GUID for PHPMailer class to name outbound file
$mimeType = $this->email2GetMime($fileLocation);
$note = $this->saveTempNoteAttachments($filename, $fileLocation, $mimeType);
$attachment = AttachmentPeer::attachmentFromSugarBean($note);
//print_r($attachment);
if (!is_null($mailer)) {
$mailer->addAttachment($attachment);
}
}
}
}
}
/**********************************************************************
* Final Touches
*/
if ($this->type == 'draft' && !$saveAsDraft) {
// sending a draft email
$this->type = 'out';
$this->status = 'sent';
$forceSave = true;
} elseif ($saveAsDraft) {
$this->type = 'draft';
$this->status = 'draft';
$forceSave = true;
}
if (!is_null($mailer)) {
$mailer->send();
}
} catch (MailerException $me) {
$GLOBALS["log"]->error($me->getLogMessage());
throw $me;
} catch (Exception $e) {
// eat the phpmailerException but use it's message to provide context for the failure
$me = new MailerException("Email2Send Failed: " . $e->getMessage(), MailerException::FailedToSend);
$GLOBALS["log"]->error($me->getLogMessage());
$GLOBALS["log"]->info($me->getTraceMessage());
if (!empty($mailConfig)) {
$GLOBALS["log"]->info($mailConfig->toArray(), true);
}
throw $me;
}
if (!(empty($orignialId) || $saveAsDraft || $this->type == 'draft' && $this->status == 'draft') && ($_REQUEST['composeType'] == 'reply' || $_REQUEST['composeType'] == 'replyAll' || $_REQUEST['composeType'] == 'replyCase') && $orignialId != $this->id) {
$originalEmail = BeanFactory::getBean('Emails', $orignialId);
$originalEmail->reply_to_status = 1;
$originalEmail->save();
$this->reply_to_status = 0;
}
// if
if (isset($_REQUEST['composeType']) && ($_REQUEST['composeType'] == 'reply' || $_REQUEST['composeType'] == 'replyCase')) {
if (isset($_REQUEST['ieId']) && isset($_REQUEST['mbox'])) {
$emailFromIe = BeanFactory::getBean('InboundEmail', $_REQUEST['ieId'], array('disable_row_level_security' => true));
$emailFromIe->mailbox = $_REQUEST['mbox'];
if (isset($emailFromIe->id) && $emailFromIe->is_personal) {
if ($emailFromIe->isPop3Protocol()) {
$emailFromIe->mark_answered($this->uid, 'pop3');
} elseif ($emailFromIe->connectMailserver() == 'true') {
$emailFromIe->markEmails($this->uid, 'answered');
$emailFromIe->mark_answered($this->uid);
}
}
}
}
if ($forceSave || $this->type == 'draft' || $this->type == 'archived' || isset($request['saveToSugar']) && $request['saveToSugar'] == 1) {
// Set Up From Name and Address Information
if ($this->type == 'archived') {
$this->from_addr = empty($request['archive_from_address']) ? '' : $request['archive_from_address'];
} elseif (!empty($mailConfig)) {
$sender = $mailConfig->getFrom();
$decodedFromName = mb_decode_mimeheader($sender->getName());
$this->from_addr = "{$decodedFromName} <" . $sender->getEmail() . ">";
} else {
$ret = $current_user->getUsersNameAndEmail();
if (empty($ret['email'])) {
$systemReturn = $current_user->getSystemDefaultNameAndEmail();
$ret['email'] = $systemReturn['email'];
$ret['name'] = $systemReturn['name'];
}
$decodedFromName = mb_decode_mimeheader($ret['name']);
$this->from_addr = "{$decodedFromName} <" . $ret['email'] . ">";
}
$this->from_addr_name = $this->from_addr;
$this->to_addrs = $_REQUEST['sendTo'];
$this->to_addrs_names = $_REQUEST['sendTo'];
$this->cc_addrs = $_REQUEST['sendCc'];
$this->cc_addrs_names = $_REQUEST['sendCc'];
$this->bcc_addrs = $_REQUEST['sendBcc'];
$this->bcc_addrs_names = $_REQUEST['sendBcc'];
$this->team_id = isset($_REQUEST['primaryteam']) ? $_REQUEST['primaryteam'] : $current_user->getPrivateTeamID();
$teamSet = BeanFactory::getBean('TeamSets');
$teamIdsArray = isset($_REQUEST['teamIds']) ? explode(",", $_REQUEST['teamIds']) : array($current_user->getPrivateTeamID());
$this->team_set_id = $teamSet->addTeams($teamIdsArray);
$this->assigned_user_id = $current_user->id;
$this->date_sent = $timedate->now();
///////////////////////////////////////////////////////////////////
//// LINK EMAIL TO SUGARBEANS BASED ON EMAIL ADDY
if (!empty($_REQUEST['parent_type']) && !empty($_REQUEST['parent_id'])) {
$this->parent_id = $this->db->quote($_REQUEST['parent_id']);
$this->parent_type = $this->db->quote($_REQUEST['parent_type']);
$a = $this->db->fetchOne("SELECT count(*) c FROM emails_beans WHERE email_id = '{$this->id}' AND bean_id = '{$this->parent_id}' AND bean_module = '{$this->parent_type}'");
if ($a['c'] == 0) {
$bean = BeanFactory::getBean($_REQUEST['parent_type'], $_REQUEST['parent_id']);
if (!empty($bean)) {
if (!empty($bean->field_defs['emails']['type']) && $bean->field_defs['emails']['type'] == 'link') {
$email_link = "emails";
} else {
$email_link = $this->findEmailsLink($bean);
}
if ($email_link && $bean->load_relationship($email_link)) {
$bean->{$email_link}->add($this);
}
}
}
// if
} else {
$c = BeanFactory::getBean('Cases');
if ($caseId = InboundEmail::getCaseIdFromCaseNumber($subject, $c)) {
$c->retrieve($caseId);
$c->load_relationship('emails');
$c->emails->add($this->id);
$this->parent_type = "Cases";
$this->parent_id = $caseId;
}
// if
}
// else
//// LINK EMAIL TO SUGARBEANS BASED ON EMAIL ADDY
///////////////////////////////////////////////////////////////////
$this->save();
}
/**** --------------------------------- ?????????
if(!empty($request['fromAccount'])) {
$ie = new InboundEmail();
$ie->retrieve($request['fromAccount']);
if (isset($ie->id) && !$ie->isPop3Protocol() && $mail->oe->mail_smtptype != 'gmail') {
$sentFolder = $ie->get_stored_options("sentFolder");
if (!empty($sentFolder)) {
$data = $mail->CreateHeader() . "\r\n" . $mail->CreateBody() . "\r\n";
$ie->mailbox = $sentFolder;
if ($ie->connectMailserver() == 'true') {
$connectString = $ie->getConnectString($ie->getServiceString(), $ie->mailbox);
$returnData = imap_append($ie->conn,$connectString, $data, "\\Seen");
if (!$returnData) {
$GLOBALS['log']->debug("could not copy email to {$ie->mailbox} for {$ie->name}");
} // if
} else {
$GLOBALS['log']->debug("could not connect to mail serve for folder {$ie->mailbox} for {$ie->name}");
} // else
} else {
$GLOBALS['log']->debug("could not copy email to {$ie->mailbox} sent folder as its empty");
} // else
} // if
} // if
------------------------------------- ****/
return true;
}
