예제 #1
0
파일: Parser.php 프로젝트: Hildy/cerb5
 /**
  * Enter description here...
  *
  * @param CerberusParserMessage $message
  * @return integer
  */
 public static function parseMessage(CerberusParserMessage $message, $options = array())
 {
     /*
      * options:
      * 'no_autoreply'
      */
     $logger = DevblocksPlatform::getConsoleLog();
     $settings = DevblocksPlatform::getPluginSettingsService();
     $helpdesk_senders = CerberusApplication::getHelpdeskSenders();
     // Pre-parse mail filters
     $pre_filters = Model_PreParseRule::getMatches($message);
     if (is_array($pre_filters) && !empty($pre_filters)) {
         // Load filter action manifests for reuse
         $ext_action_mfts = DevblocksPlatform::getExtensions('cerberusweb.mail_filter.action', false);
         // Loop through all matching filters
         foreach ($pre_filters as $pre_filter) {
             // Do something with matching filter's actions
             foreach ($pre_filter->actions as $action_key => $action) {
                 switch ($action_key) {
                     case 'blackhole':
                         return NULL;
                         break;
                     case 'redirect':
                         @($to = $action['to']);
                         CerberusMail::reflect($message, $to);
                         return NULL;
                         break;
                     case 'bounce':
                         @($msg = $action['message']);
                         @($subject = 'Delivery failed: ' . self::fixQuotePrintableString($message->headers['subject']));
                         // [TODO] Follow the RFC spec on a true bounce
                         if (null != ($fromAddressInst = CerberusParser::getAddressFromHeaders($message->headers))) {
                             CerberusMail::quickSend($fromAddressInst->email, $subject, $msg);
                         }
                         return NULL;
                         break;
                     default:
                         // Plugin pre-parser filter actions
                         if (isset($ext_action_mfts[$action_key])) {
                             if (null != @($ext_action = $ext_action_mfts[$action_key]->createInstance())) {
                                 try {
                                     /* @var $ext_action Extension_MailFilterAction */
                                     $ext_action->run($pre_filter, $message);
                                 } catch (Exception $e) {
                                 }
                             }
                         }
                         break;
                 }
             }
         }
     }
     $headers =& $message->headers;
     // From
     if (null == ($fromAddressInst = CerberusParser::getAddressFromHeaders($headers))) {
         $logger->err("[Parser] 'From' address could not be created.");
         return NULL;
     }
     // To/Cc/Bcc
     $to = array();
     $sTo = @$headers['to'];
     $bIsNew = true;
     if (!empty($sTo)) {
         // [TODO] Do we still need this RFC address parser?
         $to = CerberusParser::parseRfcAddress($sTo);
     }
     // Subject
     // Fix quote printable subject (quoted blocks can appear anywhere in subject)
     $sSubject = "";
     if (isset($headers['subject']) && !empty($headers['subject'])) {
         $sSubject = $headers['subject'];
         if (is_array($sSubject)) {
             $sSubject = array_shift($sSubject);
         }
     }
     // The subject can still end up empty after QP decode
     if (empty($sSubject)) {
         $sSubject = "(no subject)";
     }
     // Date
     $iDate = @strtotime($headers['date']);
     // If blank, or in the future, set to the current date
     if (empty($iDate) || $iDate > time()) {
         $iDate = time();
     }
     // Is banned?
     if (1 == $fromAddressInst->is_banned) {
         $logger->info("[Parser] Ignoring ticket from banned address: " . $fromAddressInst->email);
         return NULL;
     }
     // Overloadable
     $enumSpamTraining = '';
     // Message Id / References / In-Reply-To
     @($sMessageId = $headers['message-id']);
     $body_append_text = array();
     $body_append_html = array();
     // [mdf]Check attached files before creating the ticket because we may need to overwrite the message-id
     // also store any contents of rfc822 files so we can include them after the body
     foreach ($message->files as $filename => $file) {
         /* @var $file ParserFile */
         switch ($file->mime_type) {
             case 'message/rfc822':
                 $full_filename = $file->tmpname;
                 $mail = mailparse_msg_parse_file($full_filename);
                 $struct = mailparse_msg_get_structure($mail);
                 $msginfo = mailparse_msg_get_part_data($mail);
                 $inline_headers = $msginfo['headers'];
                 if (isset($headers['from']) && (strtolower(substr($headers['from'], 0, 11)) == 'postmaster@' || strtolower(substr($headers['from'], 0, 14)) == 'mailer-daemon@')) {
                     $headers['in-reply-to'] = $inline_headers['message-id'];
                 }
                 break;
         }
     }
     // [JAS] [TODO] References header may contain multiple message-ids to find
     if (null != ($ids = self::findParentMessage($headers))) {
         $bIsNew = false;
         $id = $ids['ticket_id'];
         $msgid = $ids['message_id'];
         // Is it a worker reply from an external client?  If so, proxy
         if (null != ($worker_address = DAO_AddressToWorker::getByAddress($fromAddressInst->email))) {
             $logger->info("[Parser] Handling an external worker response from " . $fromAddressInst->email);
             if (!DAO_Ticket::isTicketRequester($worker_address->address, $id)) {
                 // Watcher Commands [TODO] Document on wiki/etc
                 if (0 != ($matches = preg_match_all("/\\[(.*?)\\]/i", $message->headers['subject'], $commands))) {
                     @($command = strtolower(array_pop($commands[1])));
                     $logger->info("[Parser] Worker command: " . $command);
                     switch ($command) {
                         case 'close':
                             DAO_Ticket::updateTicket($id, array(DAO_Ticket::IS_CLOSED => CerberusTicketStatus::CLOSED));
                             break;
                         case 'take':
                             DAO_Ticket::updateTicket($id, array(DAO_Ticket::NEXT_WORKER_ID => $worker_address->worker_id));
                             break;
                         case 'comment':
                             $comment_id = DAO_TicketComment::create(array(DAO_TicketComment::ADDRESS_ID => $fromAddressInst->id, DAO_TicketComment::CREATED => time(), DAO_TicketComment::TICKET_ID => $id, DAO_TicketComment::COMMENT => $message->body));
                             return $id;
                             break;
                         default:
                             // Typo?
                             break;
                     }
                 }
                 $attachment_files = array();
                 $attachment_files['name'] = array();
                 $attachment_files['type'] = array();
                 $attachment_files['tmp_name'] = array();
                 $attachment_files['size'] = array();
                 $i = 0;
                 foreach ($message->files as $filename => $file) {
                     $attachment_files['name'][$i] = $filename;
                     $attachment_files['type'][$i] = $file->mime_type;
                     $attachment_files['tmp_name'][$i] = $file->tmpname;
                     $attachment_files['size'][$i] = $file->file_size;
                     $i++;
                 }
                 CerberusMail::sendTicketMessage(array('message_id' => $msgid, 'content' => $message->body, 'files' => $attachment_files, 'agent_id' => $worker_address->worker_id));
                 return $id;
             } else {
                 // ... worker is a requester, treat as normal
                 $logger->info("[Parser] The external worker was a ticket requester, so we're not treating them as a watcher.");
             }
         } else {
             // Reply: Not sent by a worker
             /*
              * [TODO] check that this sender is a requester on the matched ticket
              * Otherwise blank out the $id
              */
         }
     }
     $group_id = 0;
     if (empty($id)) {
         // New Ticket
         $sMask = CerberusApplication::generateTicketMask();
         $groups = DAO_Group::getAll();
         // Routing new tickets
         if (null != ($routing_rules = Model_MailToGroupRule::getMatches($fromAddressInst, $message))) {
             if (is_array($routing_rules)) {
                 foreach ($routing_rules as $rule) {
                     // Only end up with the last 'move' action (ignore the previous)
                     if (isset($rule->actions['move'])) {
                         $group_id = intval($rule->actions['move']['group_id']);
                         // We don't need to move again when running rule actions
                         unset($rule->actions['move']);
                     }
                 }
             }
         }
         // Make sure the group exists
         if (!isset($groups[$group_id])) {
             $group_id = null;
         }
         // Last ditch effort to check for a default group to deliver to
         if (empty($group_id)) {
             if (null != ($default_team = DAO_Group::getDefaultGroup())) {
                 $group_id = $default_team->id;
             } else {
                 // Bounce
                 return null;
             }
         }
         // [JAS] It's important to not set the group_id on the ticket until the messages exist
         // or inbox filters will just abort.
         $fields = array(DAO_Ticket::MASK => $sMask, DAO_Ticket::SUBJECT => $sSubject, DAO_Ticket::IS_CLOSED => 0, DAO_Ticket::FIRST_WROTE_ID => intval($fromAddressInst->id), DAO_Ticket::LAST_WROTE_ID => intval($fromAddressInst->id), DAO_Ticket::CREATED_DATE => $iDate, DAO_Ticket::UPDATED_DATE => $iDate, DAO_Ticket::LAST_ACTION_CODE => CerberusTicketActionCode::TICKET_OPENED);
         $id = DAO_Ticket::createTicket($fields);
         // Apply routing actions to our new ticket ID
         if (isset($routing_rules) && is_array($routing_rules)) {
             foreach ($routing_rules as $rule) {
                 $rule->run($id);
             }
         }
     }
     // [JAS]: Add requesters to the ticket
     if (!empty($fromAddressInst->id) && !empty($id)) {
         // Don't add a requester if the sender is a helpdesk address
         if (isset($helpdesk_senders[$fromAddressInst->email])) {
             $logger->info("[Parser] Not adding ourselves as a requester: " . $fromAddressInst->email);
         } else {
             DAO_Ticket::createRequester($fromAddressInst->id, $id);
         }
     }
     // Add the other TO/CC addresses to the ticket
     // [TODO] This should be cleaned up and optimized
     if ($settings->get('cerberusweb.core', CerberusSettings::PARSER_AUTO_REQ, 0)) {
         @($autoreq_exclude_list = $settings->get('cerberusweb.core', CerberusSettings::PARSER_AUTO_REQ_EXCLUDE, ''));
         $destinations = self::getDestinations($headers);
         if (is_array($destinations) && !empty($destinations)) {
             // Filter out any excluded requesters
             if (!empty($autoreq_exclude_list)) {
                 @($autoreq_exclude = DevblocksPlatform::parseCrlfString($autoreq_exclude_list));
                 if (is_array($autoreq_exclude) && !empty($autoreq_exclude)) {
                     foreach ($autoreq_exclude as $excl_pattern) {
                         $excl_regexp = DevblocksPlatform::parseStringAsRegExp($excl_pattern);
                         // Check all destinations for this pattern
                         foreach ($destinations as $idx => $dest) {
                             if (@preg_match($excl_regexp, $dest)) {
                                 unset($destinations[$idx]);
                             }
                         }
                     }
                 }
             }
             foreach ($destinations as $dest) {
                 if (null != ($destInst = CerberusApplication::hashLookupAddress($dest, true))) {
                     // Skip if the destination is one of our senders or the matching TO
                     if (isset($helpdesk_senders[$destInst->email])) {
                         continue;
                     }
                     DAO_Ticket::createRequester($destInst->id, $id);
                 }
             }
         }
     }
     $attachment_path = APP_STORAGE_PATH . '/attachments/';
     // [TODO] This should allow external attachments (S3)
     $fields = array(DAO_Message::TICKET_ID => $id, DAO_Message::CREATED_DATE => $iDate, DAO_Message::ADDRESS_ID => $fromAddressInst->id);
     $email_id = DAO_Message::create($fields);
     // Content
     DAO_MessageContent::create($email_id, $message->body);
     // Headers
     foreach ($headers as $hk => $hv) {
         DAO_MessageHeader::create($email_id, $hk, $hv);
     }
     // [mdf] Loop through files to insert attachment records in the db, and move temporary files
     if (!empty($email_id)) {
         foreach ($message->files as $filename => $file) {
             /* @var $file ParserFile */
             //[mdf] skip rfc822 messages since we extracted their content above
             if ($file->mime_type == 'message/rfc822') {
                 continue;
             }
             $fields = array(DAO_Attachment::MESSAGE_ID => $email_id, DAO_Attachment::DISPLAY_NAME => $filename, DAO_Attachment::MIME_TYPE => $file->mime_type, DAO_Attachment::FILE_SIZE => intval($file->file_size));
             $file_id = DAO_Attachment::create($fields);
             if (empty($file_id)) {
                 @unlink($file->tmpname);
                 // remove our temp file
                 continue;
             }
             // Make file attachments use buckets so we have a max per directory
             $attachment_bucket = sprintf("%03d/", mt_rand(1, 100));
             $attachment_file = $file_id;
             if (!file_exists($attachment_path . $attachment_bucket)) {
                 @mkdir($attachment_path . $attachment_bucket, 0770, true);
                 // [TODO] Needs error checking
             }
             rename($file->getTempFile(), $attachment_path . $attachment_bucket . $attachment_file);
             // [TODO] Split off attachments into its own DAO
             DAO_Attachment::update($file_id, array(DAO_Attachment::FILEPATH => $attachment_bucket . $attachment_file));
         }
     }
     // Pre-load custom fields
     if (isset($message->custom_fields) && !empty($message->custom_fields)) {
         foreach ($message->custom_fields as $cf_id => $cf_val) {
             if (is_array($cf_val) && !empty($cf_val) || !is_array($cf_val) && 0 != strlen($cf_val)) {
                 DAO_CustomFieldValue::setFieldValue('cerberusweb.fields.source.ticket', $id, $cf_id, $cf_val);
             }
         }
     }
     // Finalize our new ticket details (post-message creation)
     if ($bIsNew && !empty($id) && !empty($email_id)) {
         // First thread (needed for anti-spam)
         DAO_Ticket::updateTicket($id, array(DAO_Ticket::FIRST_MESSAGE_ID => $email_id));
         // Prime the change fields (which a few things like anti-spam might change before we commit)
         $change_fields = array(DAO_Ticket::TEAM_ID => $group_id);
         $out = CerberusBayes::calculateTicketSpamProbability($id);
         if (!empty($group_id)) {
             @($spam_threshold = DAO_GroupSettings::get($group_id, DAO_GroupSettings::SETTING_SPAM_THRESHOLD, 80));
             @($spam_action = DAO_GroupSettings::get($group_id, DAO_GroupSettings::SETTING_SPAM_ACTION, ''));
             @($spam_action_param = DAO_GroupSettings::get($group_id, DAO_GroupSettings::SETTING_SPAM_ACTION_PARAM, ''));
             if ($out['probability'] * 100 >= $spam_threshold) {
                 $enumSpamTraining = CerberusTicketSpamTraining::SPAM;
                 switch ($spam_action) {
                     default:
                     case 0:
                         // do nothing
                         break;
                     case 1:
                         // delete
                         $change_fields[DAO_Ticket::IS_CLOSED] = 1;
                         $change_fields[DAO_Ticket::IS_DELETED] = 1;
                         break;
                     case 2:
                         // move
                         $buckets = DAO_Bucket::getAll();
                         // Verify bucket exists
                         if (!empty($spam_action_param) && isset($buckets[$spam_action_param])) {
                             $change_fields[DAO_Ticket::TEAM_ID] = $group_id;
                             $change_fields[DAO_Ticket::CATEGORY_ID] = $spam_action_param;
                         }
                         break;
                 }
             }
         }
         // end spam training
         // Save properties
         if (!empty($change_fields)) {
             DAO_Ticket::updateTicket($id, $change_fields);
         }
     }
     // Reply notifications (new messages are handled by 'move' listener)
     if (!$bIsNew) {
         // Inbound Reply Event
         $eventMgr = DevblocksPlatform::getEventService();
         $eventMgr->trigger(new Model_DevblocksEvent('ticket.reply.inbound', array('ticket_id' => $id)));
     }
     // New ticket processing
     if ($bIsNew) {
         // Auto reply
         @($autoreply_enabled = DAO_GroupSettings::get($group_id, DAO_GroupSettings::SETTING_AUTO_REPLY_ENABLED, 0));
         @($autoreply = DAO_GroupSettings::get($group_id, DAO_GroupSettings::SETTING_AUTO_REPLY, ''));
         /*
          * Send the group's autoreply if one exists, as long as this ticket isn't spam
          */
         if (!isset($options['no_autoreply']) && $autoreply_enabled && !empty($autoreply) && $enumSpamTraining != CerberusTicketSpamTraining::SPAM) {
             CerberusMail::sendTicketMessage(array('ticket_id' => $id, 'message_id' => $email_id, 'content' => str_replace(array('#ticket_id#', '#mask#', '#subject#', '#timestamp#', '#sender#', '#sender_first#', '#orig_body#'), array($id, $sMask, $sSubject, date('r'), $fromAddressInst->email, $fromAddressInst->first_name, ltrim($message->body)), $autoreply), 'is_autoreply' => true, 'dont_keep_copy' => true));
         }
     }
     // end bIsNew
     unset($message);
     // Re-open and update our date on new replies
     if (!$bIsNew) {
         DAO_Ticket::updateTicket($id, array(DAO_Ticket::UPDATED_DATE => time(), DAO_Ticket::IS_WAITING => 0, DAO_Ticket::IS_CLOSED => 0, DAO_Ticket::IS_DELETED => 0, DAO_Ticket::LAST_WROTE_ID => $fromAddressInst->id, DAO_Ticket::LAST_ACTION_CODE => CerberusTicketActionCode::TICKET_CUSTOMER_REPLY));
         // [TODO] The TICKET_CUSTOMER_REPLY should be sure of this message address not being a worker
     }
     @imap_errors();
     // Prevent errors from spilling out into STDOUT
     return $id;
 }
예제 #2
0
 private function _handleImportTicket($xml)
 {
     $settings = CerberusSettings::getInstance();
     $logger = DevblocksPlatform::getConsoleLog();
     $workers = DAO_Worker::getAll();
     static $email_to_worker_id = null;
     static $group_name_to_id = null;
     static $bucket_name_to_id = null;
     // Hash Workers so we can ID their incoming tickets
     if (null == $email_to_worker_id) {
         $email_to_worker_id = array();
         if (is_array($workers)) {
             foreach ($workers as $worker) {
                 /* @var $worker CerberusWorker */
                 $email_to_worker_id[strtolower($worker->email)] = intval($worker->id);
             }
         }
     }
     // Hash Group names
     if (null == $group_name_to_id) {
         $groups = DAO_Group::getAll();
         $group_name_to_id = array();
         if (is_array($groups)) {
             foreach ($groups as $group) {
                 $group_name_to_id[strtolower($group->name)] = intval($group->id);
             }
         }
     }
     // Hash Bucket names
     if (null == $bucket_name_to_id) {
         $buckets = DAO_Bucket::getAll();
         $bucket_name_to_id = array();
         if (is_array($buckets)) {
             foreach ($buckets as $bucket) {
                 /* @var $bucket CerberusCategory */
                 // Hash by team ID and bucket name
                 $hash = md5($bucket->team_id . strtolower($bucket->name));
                 $bucket_to_id[$hash] = intval($bucket->id);
             }
         }
     }
     $sMask = (string) $xml->mask;
     $sSubject = substr((string) $xml->subject, 0, 255);
     $sGroup = (string) $xml->group;
     $sBucket = (string) $xml->bucket;
     $iCreatedDate = (int) $xml->created_date;
     $iUpdatedDate = (int) $xml->updated_date;
     $isWaiting = (int) $xml->is_waiting;
     $isClosed = (int) $xml->is_closed;
     if (empty($sMask)) {
         $sMask = CerberusApplication::generateTicketMask();
     }
     // Find the destination Group + Bucket (or create them)
     if (empty($sGroup)) {
         $iDestGroupId = 0;
         if (null != ($iDestGroup = DAO_Group::getDefaultGroup())) {
             $iDestGroupId = $iDestGroup->id;
         }
     } elseif (null == ($iDestGroupId = @$group_name_to_id[strtolower($sGroup)])) {
         $iDestGroupId = DAO_Group::createTeam(array(DAO_Group::TEAM_NAME => $sGroup));
         // Give all superusers manager access to this new group
         if (is_array($workers)) {
             foreach ($workers as $worker) {
                 if ($worker->is_superuser) {
                     DAO_Group::setTeamMember($iDestGroupId, $worker->id, true);
                 }
             }
         }
         // Rehash
         DAO_Group::getAll(true);
         $group_name_to_id[strtolower($sGroup)] = $iDestGroupId;
     }
     if (empty($sBucket)) {
         $iDestBucketId = 0;
         // Inbox
     } elseif (null == ($iDestBucketId = @$bucket_name_to_id[md5($iDestGroupId . strtolower($sBucket))])) {
         $iDestBucketId = DAO_Bucket::create($sBucket, $iDestGroupId);
         // Rehash
         DAO_Bucket::getAll(true);
         $bucket_name_to_id[strtolower($sBucket)] = $iDestBucketId;
     }
     // Xpath the first and last "from" out of "/ticket/messages/message/headers/from"
     $aMessageNodes = $xml->xpath("/ticket/messages/message");
     $iNumMessages = count($aMessageNodes);
     @($eFirstMessage = reset($aMessageNodes));
     if (is_null($eFirstMessage)) {
         $logger->warn('[Importer] Ticket ' . $sMask . " doesn't have any messages.  Skipping.");
         return false;
     }
     if (is_null($eFirstMessage->headers) || is_null($eFirstMessage->headers->from)) {
         $logger->warn('[Importer] Ticket ' . $sMask . " first message doesn't provide a sender address.");
         return false;
     }
     $sFirstWrote = self::_parseRfcAddressList($eFirstMessage->headers->from, true);
     if (null == ($firstWroteInst = CerberusApplication::hashLookupAddress($sFirstWrote, true))) {
         $logger->warn('[Importer] Ticket ' . $sMask . " - Invalid sender adddress: " . $sFirstWrote);
         return false;
     }
     $eLastMessage = end($aMessageNodes);
     if (is_null($eLastMessage)) {
         $logger->warn('[Importer] Ticket ' . $sMask . " doesn't have any messages.  Skipping.");
         return false;
     }
     if (is_null($eLastMessage->headers) || is_null($eLastMessage->headers->from)) {
         $logger->warn('[Importer] Ticket ' . $sMask . " last message doesn't provide a sender address.");
         return false;
     }
     $sLastWrote = self::_parseRfcAddressList($eLastMessage->headers->from, true);
     if (null == ($lastWroteInst = CerberusApplication::hashLookupAddress($sLastWrote, true))) {
         $logger->warn('[Importer] Ticket ' . $sMask . ' last message has an invalid sender address: ' . $sLastWrote);
         return false;
     }
     // Last action code + last worker
     $sLastActionCode = CerberusTicketActionCode::TICKET_OPENED;
     $iLastWorkerId = 0;
     if ($iNumMessages > 1) {
         if (null != @($iLastWorkerId = $email_to_worker_id[strtolower($lastWroteInst->email)])) {
             $sLastActionCode = CerberusTicketActionCode::TICKET_WORKER_REPLY;
         } else {
             $sLastActionCode = CerberusTicketActionCode::TICKET_CUSTOMER_REPLY;
             $iLastWorkerId = 0;
         }
     }
     // Dupe check by ticket mask
     if (null != DAO_Ticket::getTicketByMask($sMask)) {
         $logger->warn("[Importer] Ticket mask '" . $sMask . "' already exists.  Making it unique.");
         $uniqueness = 1;
         $origMask = $sMask;
         // Append new uniqueness to the ticket mask:  LLL-NNNNN-NNN-1, LLL-NNNNN-NNN-2, ...
         do {
             $sMask = $origMask . '-' . ++$uniqueness;
         } while (null != DAO_Ticket::getTicketIdByMask($sMask));
         $logger->info("[Importer] The unique mask for '" . $origMask . "' is now '" . $sMask . "'");
     }
     // Create ticket
     $fields = array(DAO_Ticket::MASK => $sMask, DAO_Ticket::SUBJECT => $sSubject, DAO_Ticket::IS_WAITING => $isWaiting, DAO_Ticket::IS_CLOSED => $isClosed, DAO_Ticket::FIRST_WROTE_ID => intval($firstWroteInst->id), DAO_Ticket::LAST_WROTE_ID => intval($lastWroteInst->id), DAO_Ticket::CREATED_DATE => $iCreatedDate, DAO_Ticket::UPDATED_DATE => $iUpdatedDate, DAO_Ticket::TEAM_ID => intval($iDestGroupId), DAO_Ticket::CATEGORY_ID => intval($iDestBucketId), DAO_Ticket::LAST_ACTION_CODE => $sLastActionCode, DAO_Ticket::LAST_WORKER_ID => intval($iLastWorkerId));
     $ticket_id = DAO_Ticket::createTicket($fields);
     //		echo "Ticket: ",$ticket_id,"<BR>";
     //		print_r($fields);
     // Create requesters
     if (!is_null($xml->requesters)) {
         foreach ($xml->requesters->address as $eAddress) {
             /* @var $eAddress SimpleXMLElement */
             $sRequesterAddy = (string) $eAddress;
             // [TODO] RFC822
             // Insert requesters
             if (null == ($requesterAddyInst = CerberusApplication::hashLookupAddress($sRequesterAddy, true))) {
                 $logger->warn('[Importer] Ticket ' . $sMask . ' - Ignoring malformed requester: ' . $sRequesterAddy);
                 continue;
             }
             DAO_Ticket::createRequester($requesterAddyInst->id, $ticket_id);
         }
     }
     // Create messages
     $is_first = true;
     if (!is_null($xml->messages)) {
         foreach ($xml->messages->message as $eMessage) {
             /* @var $eMessage SimpleXMLElement */
             $eHeaders =& $eMessage->headers;
             /* @var $eHeaders SimpleXMLElement */
             $sMsgFrom = (string) $eHeaders->from;
             $sMsgDate = (string) $eHeaders->date;
             $sMsgFrom = self::_parseRfcAddressList($sMsgFrom, true);
             if (NULL == $sMsgFrom) {
                 $logger->warn('[Importer] Ticket ' . $sMask . ' - Invalid message sender: ' . $sMsgFrom . ' (skipping)');
                 continue;
             }
             if (null == ($msgFromInst = CerberusApplication::hashLookupAddress($sMsgFrom, true))) {
                 $logger->warn('[Importer] Ticket ' . $sMask . ' - Invalid message sender: ' . $sMsgFrom . ' (skipping)');
                 continue;
             }
             @($msgWorkerId = intval($email_to_worker_id[strtolower($msgFromInst->email)]));
             //			$logger->info('Checking if '.$msgFromInst->email.' is a worker');
             $fields = array(DAO_Message::TICKET_ID => $ticket_id, DAO_Message::CREATED_DATE => strtotime($sMsgDate), DAO_Message::ADDRESS_ID => $msgFromInst->id, DAO_Message::IS_OUTGOING => !empty($msgWorkerId) ? 1 : 0, DAO_Message::WORKER_ID => !empty($msgWorkerId) ? $msgWorkerId : 0);
             $email_id = DAO_Message::create($fields);
             // First thread
             if ($is_first) {
                 DAO_Ticket::updateTicket($ticket_id, array(DAO_Ticket::FIRST_MESSAGE_ID => $email_id));
                 $is_first = false;
             }
             // Create attachments
             if (!is_null($eMessage->attachments)) {
                 foreach ($eMessage->attachments->attachment as $eAttachment) {
                     /* @var $eAttachment SimpleXMLElement */
                     $sFileName = (string) $eAttachment->name;
                     $sMimeType = (string) $eAttachment->mimetype;
                     $sFileSize = (int) $eAttachment->size;
                     $sFileContentB64 = (string) $eAttachment->content;
                     // [TODO] This could be a little smarter about detecting extensions
                     if (empty($sMimeType)) {
                         $sMimeType = "application/octet-stream";
                     }
                     $sFileContent = base64_decode($sFileContentB64);
                     unset($sFileContentB64);
                     $fields = array(DAO_Attachment::MESSAGE_ID => $email_id, DAO_Attachment::DISPLAY_NAME => $sFileName, DAO_Attachment::FILE_SIZE => intval($sFileSize), DAO_Attachment::FILEPATH => '', DAO_Attachment::MIME_TYPE => $sMimeType);
                     $file_id = DAO_Attachment::create($fields);
                     // Write file to disk using ID (Model)
                     $file_path = Model_Attachment::saveToFile($file_id, $sFileContent);
                     unset($sFileContent);
                     // Update attachment table
                     DAO_Attachment::update($file_id, array(DAO_Attachment::FILEPATH => $file_path));
                 }
             }
             // Create message content
             $sMessageContentB64 = (string) $eMessage->content;
             $sMessageContent = base64_decode($sMessageContentB64);
             // Content-type specific handling
             if (isset($eMessage->content['content-type'])) {
                 // do we have a content-type?
                 if (strtolower($eMessage->content['content-type']) == 'html') {
                     // html?
                     // Force to plaintext part
                     $sMessageContent = CerberusApplication::stripHTML($sMessageContent);
                 }
             }
             unset($sMessageContentB64);
             DAO_MessageContent::create($email_id, $sMessageContent);
             unset($sMessageContent);
             // Headers
             foreach ($eHeaders->children() as $eHeader) {
                 /* @var $eHeader SimpleXMLElement */
                 DAO_MessageHeader::create($email_id, $eHeader->getName(), (string) $eHeader);
             }
         }
     }
     // Create comments
     if (!is_null($xml->comments)) {
         foreach ($xml->comments->comment as $eComment) {
             /* @var $eMessage SimpleXMLElement */
             $iCommentDate = (int) $eComment->created_date;
             $sCommentAuthor = (string) $eComment->author;
             // [TODO] Address Hash Lookup
             $sCommentTextB64 = (string) $eComment->content;
             $sCommentText = base64_decode($sCommentTextB64);
             unset($sCommentTextB64);
             $commentAuthorInst = CerberusApplication::hashLookupAddress($sCommentAuthor, true);
             // [TODO] Sanity checking
             $fields = array(DAO_TicketComment::TICKET_ID => intval($ticket_id), DAO_TicketComment::CREATED => intval($iCommentDate), DAO_TicketComment::ADDRESS_ID => intval($commentAuthorInst->id), DAO_TicketComment::COMMENT => $sCommentText);
             $comment_id = DAO_TicketComment::create($fields);
             unset($sCommentText);
         }
     }
     $logger->info('[Importer] Imported ticket #' . $ticket_id);
     return true;
 }
예제 #3
0
파일: Parser.php 프로젝트: Hildy/cerb4
 /**
  * Enter description here...
  *
  * @param array $headers
  * @return array (group_id,address)
  */
 private static function findDestination($headers)
 {
     static $routing = null;
     $settings = CerberusSettings::getInstance();
     // [TODO] Should this cache be at the class level?
     if (is_null($routing)) {
         $routing = DAO_Mail::getMailboxRouting();
     }
     $destinations = self::getDestinations($headers);
     if (is_array($destinations)) {
         foreach ($destinations as $address) {
             // Test each pattern successively
             foreach ($routing as $route) {
                 /* @var $route Model_MailRoute */
                 $pattern = sprintf("/^%s\$/i", str_replace(array('*', '+'), array('.*?', '\\+'), $route->pattern));
                 if (preg_match($pattern, $address)) {
                     return array($route->team_id, $address);
                 }
             }
         }
     }
     // Check if we have a default mailbox configured before returning NULL.
     if (null != ($default_team = DAO_Group::getDefaultGroup())) {
         return array($default_team->id, '');
     }
     return null;
     // bounce
 }