Erstellen erweiterter E-Mail-Funktionen mit IMAP und PHP

() translation by (you can also view the original English article)

What You'll Be Creating

In diesem Tutorial werde ich Ihnen einige Beispiele aus der Praxis zeigen, wie Sie mit PHP und IMAP neue Funktionen zum Verwalten Ihrer E-Mails erstellen können - Funktionen, die die großen E-Mail-Anbieter nicht für uns entwickelt haben.

Mein Interesse daran begann im Jahr 2010, als ich zwölf Google Mail-Ideen zur Revolutionierung von E-Mails (erneut) geschrieben habe, aber die meisten Ideen, die ich mir gewünscht habe, blieben unerreichbar. So wichtig E-Mails auch sind, die Innovation von E-Mails als Anwendung war recht langsam.

Wir ertrinken in E-Mails und die Verwaltung unserer Posteingänge bleibt eine schwere Belastung. Postdienste und Kunden haben sehr wenig getan, um uns dabei zu helfen. Die meisten E-Mails, die wir erhalten, werden von Maschinen gesendet, nicht von Personen, und dennoch sind wir diejenigen, die alles einzeln verarbeiten müssen.

Die Analyse meiner eigenen E-Mail ergab, dass ich E-Mails von mehr als 230 automatisierten Absendern erhielt, weit weniger von tatsächlichen Personen. Ich hatte es satt, Filter in Google Mail zu erstellen und unzählige Abmeldeformulare auszufüllen. Ich wollte mehr Kontrolle über die Verwaltung meiner E-Mails und die Vereinfachung meines Lebens haben.

Schließlich habe ich mich im vergangenen Jahr entschlossen, die Funktionen zu entwickeln, die ich brauchte. Das Ergebnis ist Simplify Email (SE), eine kleine Web-App, die Sie selbst hosten können und die eine Vielzahl cooler neuer E-Mail-Funktionen bietet, die Sie alle auf der Projektwebsite abrufen können.

Das Beste an SE ist, dass es eine Plattform zum Lesen, Analysieren, Weiterleiten und Verwalten Ihrer E-Mails ist - die Möglichkeiten sind vielfältig. E-Mail vereinfachen ist im Wesentlichen ein programmierbarer Spielplatz zum "Hacken" Ihrer eigenen E-Mail.

Ich werde Sie durch den Code von drei Beispielen von SE führen, die PHP, IMAP und MySQL verwenden, um mit E-Mails zu arbeiten:

Überprüfen Sie Ihren Posteingang und filtern Sie Nachrichten
Implementierung einer Whitelist-Herausforderung für unbekannte Absender
Unbeantwortete E-Mails melden

Dieses Tutorial gibt Ihnen definitiv einen Vorsprung beim Schreiben von IMAP-Code in PHP. Sie können aber auch direkt mit der Codebasis "E-Mail vereinfachen" arbeiten. Sie kaufen den Code für nur 10 US-Dollar und es gibt eine ältere Open-Source-Version (der einige der unten beschriebenen Funktionen fehlen). Installationshandbücher werden für typische Linux-Konfigurationen bereitgestellt. Ich biete auch vorinstallierte Images bei Digital Ocean für 25 US-Dollar sowie eine Handheld-Valet-Installation an. SE ist in PHP im Yii Framework geschrieben.

Beachten Sie, dass Sie über Ihren lokalen Entwicklungscomputer nur dann auf die meisten E-Mail-Server zugreifen können, wenn Sie eine sichere IMAP-Bibliothek für PHP kompilieren. Dies ist einer der Gründe, warum ich Menschen dazu ermutige, Simplify Email in Tröpfchen bei Digital Ocean auszuführen. Es gibt auch einige Tricks, um die Sicherheit Ihres Google-Kontos über IMAP zu gewährleisten.

Arbeiten mit IMAP

Wie man E-Mails vereinfachen kann

Mit SE können Sie Ihren E-Mail-Client Ihrer Wahl sowohl im Web als auch auf Ihren Mobilgeräten weiterhin verwenden. Sie müssen keine Apps oder persönlichen Gewohnheiten ändern. SE greift über IMAP hinter den Kulissen auf Ihre E-Mail-Konten zu. Als intelligenter persönlicher Assistent verarbeitet SE Ihre E-Mails vor und verschiebt Nachrichten basierend auf allem, was Sie gesagt haben, an die entsprechenden Stellen.

Wenn eine Nachricht von einem vertrauten Absender eingeht, verschiebt SE sie in den von Ihnen angegebenen Ordner. Wenn jemand zum ersten Mal von einem unbekannten Absender kommt, wird er in den Überprüfungsordner verschoben.

Alle paar Stunden (oder mit einer von Ihnen gewählten Häufigkeit) sendet SE Ihnen eine Zusammenfassung darüber, wohin Ihre Nachrichten verschoben wurden und welche Nachrichten überprüft werden. Beachten Sie, dass für den Überprüfungsordner Links für Schulungssender enthalten sind, die das Trainieren von SE im Laufe der Zeit recht einfach machen.

The Simplify Email Message Digest Shows You What Came In and How It Was Filtered

Sie können jederzeit Ihren Überprüfungsordner durchsuchen - Sie müssen nicht warten, bis der Digest eintrifft. Der Vorteil von SE ist jedoch, dass Sie Ihre Ordner nicht mehr durchsuchen müssen. Sie können einfach Ihren Digest lesen, um einen Blick auf die E-Mail zu erhalten, die Sie erhalten haben, und neue Absender schulen.

1. Überprüfen Sie Ihren Posteingang und filtern Sie Nachrichten

SE verwendet mehrere Cron-Tasks, um im Hintergrund auf Ihrem Server zu arbeiten. Jeder wird von DaemonController.php aufgerufen.

Der erste, processInbox, wird häufig aufgerufen und muss schnell funktionieren. Seine Aufgabe besteht darin, E-Mails zu überprüfen und so schnell wie möglich aus dem Posteingang in den Triage-Ordner zu verschieben, der als Filterordner bezeichnet wird.

Das zweite, processFiltering, ist prozessintensiver und führt tiefere Operationen für E-Mails durch, wodurch Nachrichten letztendlich an ihr endgültiges Ziel verschoben werden.

Die ProcessInbox-Methode

Die Cron-Tasks rufen regelmäßig processInbox auf:

public function actionInbox() {
    
    // moves inbox messages to @filtering
    // runs frequently 
    $r = new Remote();
    $r->processInbox();	  
    
}

The Simplify Email Accounts Configuration Page

Für jedes Konto entschlüsseln wir Ihre E-Mail-Anmeldeinformationen und verwenden dann imap_open, um einen imap_open für Ihren Posteingangsordner zu erstellen:

public function open($account_id, $mailbox='',$options=NULL) {
  // opens folder in an IMAP account
  $account = Account::model()->findByPk($account_id);
  $this->hostname = $account->address;
  if (!stristr($this->hostname,'{'))
    $this->hostname = '{'.$this->hostname.'}';
  $cred = Account::model()->getCredentials($account->cred);
  if ($account->provider == Account::PROVIDER_ICLOUD) {
    // icloud accepts only name part of mailbox e.g. stevejobs vs. stevejobs@icloud.com
    $temp = explode('@',$cred[0]);
    $cred[0]=$temp[0];
  }
  $this->stream = imap_open($this->hostname.$mailbox,$cred[0],$cred[1],$options,1) or die('Cannot connect to mail server - account_id:'.$account_id .' '.print_r(imap_errors()));
}

In processInbox verwenden wir die PHP-Bibliotheksfunktionen imap_search und imap_fetch_overview, um ein Array von Nachrichten abzurufen:

// lookup folder_id of this account's INBOX
$folder_id = Folder::model()->lookup($account_id,$this->path_inbox);
$this->open($account_id,$this->path_inbox);
$cnt=0;
$message_limit= 50; // break after n messages to prevent timeout
echo 'Sort since: '.date("j F Y",$tstamp);           
// imap_search date format 30 November 2013
 $recent_messages = @imap_search($this->stream, 'SINCE "'.date("j F Y",$tstamp).'"',SE_UID); 
 if ($recent_messages===false) continue; // to do - continue into next account
 $result = imap_fetch_overview($this->stream, implode(',',array_slice($recent_messages,0,$message_limit)),FT_UID);

Dann verarbeiten wir das Nachrichtenarray im Posteingang:

1	foreach ($result as $item) {
2	if (!$this->checkExecutionTime($time_start)) break;
3	// get msg header and stream uid
4	$msg = $this->parseHeader($item);

Hier ist eine angepasste Version des öffentlich verfügbaren IMAP-Header-Parsing-Codes, der die zusätzlichen Informationen sammelt, die SE für eine Vielzahl von Aufgaben benötigt. Grundsätzlich wird imap_rfc822_parse_adrlist verwendet, um Empfängerinformationen, Nachrichten-ID, Betreff und Zeitstempel (oder Absenderinformationen beim Scannen des gesendeten Ordners) zu ermitteln:

  public function parseHeader($header) {
    // parses header object returned from imap_fetch_overview    
    if (!isset($header->from)) {
      return false;
    } else {
      $from_arr = imap_rfc822_parse_adrlist($header->from,'gmail.com');
      $fi = $from_arr[0];
      $msg = array(
        "uid" => (isset($header->uid))
              ? $header->uid : 0,
         "personal" => (isset($fi->personal))
            ? @imap_utf8($fi->personal) : "",
          "email" => (isset($fi->mailbox) && isset($fi->host))
              ? $fi->mailbox . "@" . $fi->host : "",
          "mailbox" => (isset($fi->mailbox))
            ? $fi->mailbox : "",
          "host" => (isset($fi->host))
            ? $fi->host : "",
          "subject" => (isset($header->subject))
              ? @imap_utf8($header->subject) : "",
          "message_id" => (isset($header->message_id))
                ? $header->message_id : "",
          "in_reply_to" => (isset($header->in_reply_to))
                    ? $header->in_reply_to : "",
          "udate" => (isset($header->udate))
              ? $header->udate : 0,
          "date_str" => (isset($header->date))
              ? $header->date : ""
      );    
      // handles fetch with uid and rfc header parsing
      if ($msg['udate']==0 && isset($header->date)) {
          $msg['udate']=strtotime($header->date);
      }
      $msg['rx_email']='';        
      $msg['rx_personal']='';
        $msg['rx_mailbox']='';
        $msg['rx_host']='';
      if (isset($header->to)) {        
        $to_arr = imap_rfc822_parse_adrlist($header->to,'gmail.com');
        $to_info = $to_arr[0];
        if (isset($to_info->mailbox) && isset($to_info->host)) {
          $msg['rx_email']=$to_info->mailbox.'@'.$to_info->host;
        }
        if (isset($to_info->personal))
          $msg['rx_personal']=$to_info->personal;
        if (isset($to_info->mailbox))
          $msg['rx_mailbox']=$to_info->mailbox;
        if (isset($to_info->host))
          $msg['rx_host']=$to_info->host;
      }
      return $msg;
    }
  }

Wir erstellen Datensätze für den Absender und den Nachrichtenumschlag in unserer Datenbank:

   // skip any system messages
   if ($msg['email']==$system_email) continue;
    // if udate is too old, skip msg
    if (time()-$msg['udate']>$this->scan_seconds) continue; // skip msg
    // default action
     $action = self::ACTION_MOVE_FILTERED;
     $isNew = $s->isNew($account_id,$msg["email"]);
    // look up sender, if new, create them
    $sender_id = $s->add($user_id,$account_id,$msg["personal"], $msg["mailbox"], $msg["host"],0);                       
    $sender = Sender::model()->findByPk($sender_id);
     // create a message in db if needed
     $message_id = $m->add($user_id,$account_id,0,$sender_id,$msg['message_id'],$msg['subject'],$msg['udate'],$msg['in_reply_to']);        
        $message = Message::model()->findByPk($message_id);

Wenn der Absender für uns neu ist (unbekannt), senden wir eine E-Mail mit einer Whitelist-Herausforderung (mehr über Whitelist-Herausforderungen im nächsten Abschnitt unten):

1	if ($isNew) {
2	$this->challengeSender($user_id,$account_id,$sender,$message);
3	}

Als Nächstes stellen wir fest, ob der Benutzer möglicherweise eine Nachricht aus einem anderen Ordner zurück in den Posteingang gezogen hat, um sie per Drag & Drop zu trainieren. In diesem Fall legen wir die Schulung für diesen Absender im Posteingang fest. Mit anderen Worten, beim nächsten Mal möchten wir nur Nachrichten von diesem Absender an den Posteingang weiterleiten:

         if ($message['status'] == Message::STATUS_FILTERED ||
   	    $message['status'] == Message::STATUS_REVIEW ||
   	    ($message['status'] == Message::STATUS_TRAINED && $message['folder_id'] <> $folder_id) ||
   	    ($message['status'] == Message::STATUS_ROUTED && $message['folder_id'] <> $folder_id))
   	    {
     	  // then it's a training
   	    $action = self::ACTION_TRAIN_INBOX;     	    
   	  } else if (($message['status'] == Message::STATUS_TRAINED || $message['status'] == Message::STATUS_ROUTED) && $message['folder_id'] == $folder_id) {
   	    // if trained already or routed to inbox already, skip it
   	    $action = self::ACTION_SKIP;  
   	    echo 'Trained previously, skip ';lb();   	  
   	    continue;  
   	  }

Wenn nicht, bereiten wir uns darauf vor, die Nachricht zur weiteren Verarbeitung in den Filterordner zu verschieben. Erstens können wir Benachrichtigungen an das Telefon des Benutzers senden, wenn eine Absender- oder Keyword-Übereinstimmung für Benachrichtigungen vorliegt (und es keine ruhigen Stunden sind):

   if ($action == self::ACTION_MOVE_FILTERED) {
     $cnt+=1;         
     if ($sender->exclude_quiet_hours == Sender::EQH_YES or !$this->isQuietHours($user_id)) {
       // send smartphone notifications based on sender
       if ($sender->alert==Sender::ALERT_YES) {
         $this->notify($sender,$message,Monitor::NOTIFY_SENDER);
       }
       // send notifications based on keywords
       if (AlertKeyword::model()->scan($msg)) {
         $this->notify($sender,$message,Monitor::NOTIFY_KEYWORD);
       }               
     }               
     // move imap msg to +Filtering
     echo 'Moving to +Filtering';lb();
     //$result = @imap_mail_move($this->stream,$msg['uid'],$this->path_filtering,CP_UID);
     $result = $this->messageMoveHandler($msg['uid'],$this->path_filtering,false);             
     if ($result) {
       echo 'moved<br />';
       $m->setStatus($message_id,Message::STATUS_FILTERED);
     }
   } 

Wenn die Nachricht in den Posteingang gezogen wurde, aktualisieren wir unsere Trainingseinstellungen:

else if ($action == self::ACTION_TRAIN_INBOX) {
     // set sender folder_id to inbox
     echo 'Train to Inbox';lb();
     $m->setStatus($message_id,Message::STATUS_TRAINED);
     // only train sender when message is newer than last setting
     if ($msg['udate']>=$sender['last_trained']) {
       $s->setFolder($sender_id,$folder_id);
     } 
   }

Die ProcessFiltering-Methode

Die sekundäre Verarbeitungsmethode heißt processFiltering, auch in DaemonController.php. Es erledigt die zeitaufwändigeren Aspekte des Verschiebens von Nachrichten in die entsprechenden Ordner:

public function actionIndex()
{
  // processes messages in @Filtering to appropriate folders
  $r = new Remote();
  $r->processFiltering();
  // Record timestamp of cronjob for monitoring
  $file = file_put_contents('./protected/runtime/cronstamp.txt',time(),FILE_USE_INCLUDE_PATH);	  
}

Diese Methode öffnet Ihr E-Mail-Konto, um nach aktuellen Nachrichten zu suchen und Daten darüber zu sammeln. Es werden auch imap_search, imap_fetch_overview und parseHeader verwendet:

$tstamp = time()-(7*24*60*60); // 7 days ago
$recent_messages = @imap_search($this->stream, 'SINCE "'.date("j F Y",$tstamp).'"',SE_UID);
if ($recent_messages===false) continue; // to do - continue into next account
$result = imap_fetch_overview($this->stream, implode(',',array_slice($recent_messages,0,$message_limit)),FT_UID);
foreach ($result as $item) {         
      $cnt+=1;
      if (!$this->checkExecutionTime($time_start)) break;
      // get msg header and stream uid
      $msg = $this->parseHeader($item);            

Die primäre Verarbeitungsschleife für jede Nachricht im Filterordner ist sehr detailliert. Zuerst betrachten wir die Empfängeradresse, da SE es Benutzern ermöglicht, Ordner nach Empfängeradresse zu trainieren, z. Nachrichten an die Domain happyvegetarian.com gehen in den vegetarischen Ordner:

 // Set the default action to move to the review folder
 $action = self::ACTION_MOVE_REVIEW;
 $destination_folder =0;
 // look up & create recipient
 $recipient_id = $r->add($user_id,$account_id,$msg['rx_email'],0);
 $routeByRx = $this->routeByRecipient($recipient_id);
 if ($routeByRx!==false) {
  $action = $routeByRx->action;
  $destination_folder = $routeByRx->destination_folder;
 }            

Dann suchen wir den Absender und erstellen einen neuen Datensatz in der Datenbank (falls erforderlich). Wenn für den Absender eine Schulung vorhanden ist, können wir den Zielordner festlegen:

 // look up sender, if new, create them
 $sender_id = $s->add($user_id,$account_id,$msg["personal"], $msg["mailbox"], $msg["host"],0);                       
 $sender = Sender::model()->findByPk($sender_id);
 // if sender destination known, route to folder
 if ($destination_folder ==0 && $sender['folder_id'] > 0) {
   $action = self::ACTION_ROUTE_FOLDER;  
   $destination_folder = $sender['folder_id'];      
 }
 

Wenn sich ein nicht geschulter (neuer) Absender über eine Whitelist-Herausforderung verifiziert hat (die im nächsten Abschnitt erläutert wird), leiten wir diese Nachricht an den Posteingang weiter:

// whitelist verified senders go to inbox
 if ($sender->is_verified==1 && $sender['folder_id'] ==0 && UserSetting::model()->useWhitelisting($user_id)) {
   // place message in inbox
   $action = self::ACTION_ROUTE_FOLDER;  
   $destination_folder = Folder::model()->lookup($account_id,$this->path_inbox);             
 }

Anschließend erstellen wir einen Nachrichteneintrag in der Datenbank mit den Umschlaginformationen zu dieser Nachricht:

  // create a message in db
      $message = Message::model()->findByAttributes(array('message_id'=>$msg['message_id']));
  if (!empty($message)) {
    // message exists already, 
	  $message_id = $message->id;    	  
  } else {
    $message_id = $m->add($user_id,$account_id,0,$sender_id,$msg['message_id'],$msg['subject'],$msg['udate'],$msg['in_reply_to']);         
  }

Wenn es von einem unbekannten, nicht verifizierten Absender stammt, können wir die Nachricht in den Überprüfungsordner verschieben. Der Überprüfungsordner enthält alle Nachrichten von Absendern, die wir nicht erkennen.

Wenn die Nachricht von einem bekannten Absender stammt und wir ein Ziel vor Augen haben, können wir sie verschieben, solange es keine ruhigen Stunden sind (und nicht stören ist ausgeschaltet):

  if ($recipient_id!==false) $m->setRecipient($message_id,$recipient_id);
  if ($action == self::ACTION_MOVE_REVIEW) {
    echo 'Moving to +Filtering/Review';lb();
    //$result = @imap_mail_move($this->stream,$msg['uid'],$this->path_review,CP_UID);
    $result = $this->messageMoveHandler($msg['uid'],$this->path_review,false);               
    if ($result) {
      echo 'moved<br />';
      $m->setStatus($message_id,Message::STATUS_REVIEW);
    }      
 } else if ($action == self::ACTION_ROUTE_FOLDER || $action == self::ACTION_ROUTE_FOLDER_BY_RX) {
  // lookup folder name by folder_id
  $folder = Folder::model()->findByPk($destination_folder);       
  // if inbox & quiet hours, don't route right now
  if (strtolower($folder['name'])=='inbox' and $sender->exclude_quiet_hours == Sender::EQH_NO and $this->isQuietHours($user_id)) continue;
  echo 'Moving to '.$folder['name'];lb();
  $mark_read = Folder::model()->isMarkRead($folder['mark_read']) || Sender::model()->isMarkRead($sender['mark_read']);
  //$result = @imap_mail_move($this->stream,$msg['uid'],$folder['name'],CP_UID);
  $result = $this->messageMoveHandler($msg['uid'],$folder['name'],$mark_read);
  if ($result) {
    echo 'moved<br />';
    $m->setStatus($message_id,Message::STATUS_ROUTED);         
    $m->setFolder($message_id,$destination_folder);
  }
}

Während ruhiger Stunden werden Nachrichten hauptsächlich im Filterordner gespeichert.

Alle paar Stunden erstellt ein anderer Prozess den Nachrichtenauszug anhand der Nachrichtentabellendatensätze, um festzustellen, welche E-Mails kürzlich empfangen und gefiltert wurden und wie sie weitergeleitet wurden.

2. Implementieren einer Whitelist-Herausforderung für unbekannte Absender

Das Ziel der Whitelist-Herausforderung besteht darin, Nachrichten von einem unbekannten Absender, z. möglicherweise ein Marketing-Bot oder Spammer aus Ihrem Posteingang. SE legt E-Mails von unbekannten Absendern im Überprüfungsordner ab. Wenn Sie jedoch die Whitelist aktivieren, senden wir eine E-Mail mit einer Aufforderung, mit der der Absender überprüfen kann, ob er ein Mensch ist. Wenn sie antworten, verschieben wir die Nachricht in Ihren Posteingang. Wenn sich herausstellt, dass die E-Mail unerwünscht ist, können Sie die Nachricht aus dem Digest zappen oder in einen beliebigen Ordner ziehen, in den Sie sie trainieren möchten.

Der Benutzer kann die Whitelist in den folgenden Einstellungen ein und ausschalten:

Simplify email settings for whitelisting

Um die Whitelist zu implementieren, senden wir E-Mail-Herausforderungen, wenn E-Mails von einem neuen Absender eingehen:

1	if ($isNew) {
2	$this->challengeSender($user_id,$account_id,$sender,$message);
3	}

ChallengeSender sendet einen codierten Link an den Benutzer, auf den er klicken kann. Wir haben auch einige Schutzmaßnahmen, um sicherzustellen, dass wir uns nicht in einer E-Mail-Schleife mit einer Abwesenheitsnachricht befinden:

 public function challengeSender($user_id,$account_id,$sender,$message) {
   // whitelist email challenge
   $yg = new Yiigun();
   $ac = Account::model()->findByPk($account_id);
   if (!empty($ac['challenge_name']))
     $from = $ac['challenge_name'].' <no-reply@'.$yg->mg_domain.'>';
    else
      $from = 'Filter <no-reply@'.$yg->mg_domain.'>';      
   $cred = Account::model()->getCredentials($ac->cred);
   $account_email = $cred[0];
   unset($cred); 
   // safety: checks no recent email
   if ($sender->last_emailed>(time()-(48*60*60))) return false;   
   if ($sender->isBot($sender['email'])) {
     // to do - can also set this person to bulk by default
     return false;
   }
$link=Yii::app()->getBaseUrl(true)."/sender/verify/s/".$sender->id."/m/".$message->id.'/u/'.$message->udate;
    $subject = 'Please verify the message you sent to '.$account_email;
    $body="<p>Hi,<br /><br /> I'm trying to reduce unsolicited email. Could you please verify your email address by clicking the link below:<br /><a href=\"".$link.'">'.$link.'</a><br /><br />Verifying your email address will help speed your message into my inbox. Thanks for your assistance!</p>';
    $yg->send_html_message($from, $sender['email'], $subject,$body);
    // update last_emailed
    $sender->touchLastEmailed($sender->id);
 }

Wenn der Empfänger dann auf den codierten Link klickt, überprüfen wir ihn in der Datenbank. Der Sender Controller verarbeitet diese Anforderungen und überprüft ihre Gültigkeit:

  public function actionVerify($s = 0, $m=0,$u=0) {
    // verify that secure msg url from digest is valid, log in user, show msg
    $sender_id = $s;
    $message_id = $m;
    $udate = $u;
    $msg = Message::model()->findByPk($message_id);
    if (!empty($msg) && $msg->sender_id == $sender_id && $msg->udate == $udate) {
      $result = 'Thank you for your assistance. I\'ll respond to your email as soon as possible.';
      $a = new Advanced();
      $a->verifySender($msg->account_id,$sender_id);
    } else {
      $result = 'Sorry, we could not verify your email address.';
    }
    	$this->render('verify',array(
			'result'=>$result,
		));
  }

Dies weist unsere Verarbeitungsschleifen an, diese und zukünftige Nachrichten von diesem Absender in den Posteingang zu verschieben.

3. Melden unbeantworteter E-Mails

Manchmal ist es hilfreich, eine Zusammenfassung der Nachrichten anzuzeigen, auf die Sie gesendet, aber keine Antwort erhalten haben. Um diese zu identifizieren, überwacht Simplify Email Nachrichten, die gesendet wurden, aber keine Antwort erhalten haben.

Jede Nachricht, die wr erhalten, enthält eine eindeutige ID namens message_id (Teil der IMAP-Spezifikation). Es sieht oft so aus:

1	Message-Id: <CALe0OAaF3fb3d=gCq2Fs=Ex61Qp6FdbiA4Mvs6kTQ@mail.gmail.com>

Wenn Nachrichten als Antwort auf andere Nachrichten gesendet werden, haben sie außerdem ein Feld in_reply_to, das auf die ursprüngliche message_id verweist.

Daher verwenden wir eine SQL-Abfrage, um alle empfangenen Nachrichten zu finden, für die keine entsprechende Antwortnachricht vorhanden ist, die auf ihre message_id verweist. Dazu verwenden wir einen LEFT OUTER JOIN, bei dem es keine in_reply_to id gibt:

public function getUnanswered($account_id,$mode=0, $range_days = 7) {
    if ($mode==0)
      $subject_compare = 'not';
    else
      $subject_compare = '';
    $query = Yii::app()->db->createCommand("SELECT fi_sent_message.id, fi_sent_message.recipient_id as sender_id,fi_sent_message.subject,fi_sent_message.udate,fi_message.in_reply_to,fi_sent_message.message_id  FROM fi_sent_message LEFT OUTER JOIN fi_message ON fi_message.in_reply_to = fi_sent_message.message_id WHERE fi_sent_message.account_id = ".$account_id." AND fi_message.in_reply_to is null and fi_sent_message.udate > ".(time()-(3600*24*$range_days))." and fi_sent_message.subject ".$subject_compare." like 'Re: %' ORDER BY fi_sent_message.udate  DESC")->queryAll();
    return $query;
  }

Wir verwenden den $subject_compare-Modus, um zwischen unseren gesendeten Nachrichten, die nicht beantwortet wurden, und unseren gesendeten Antworten auf einen Thread, der nicht beantwortet wurde, zu unterscheiden. Hier ist der unbeantwortete Nachrichtenbericht in Ihrem Konto:

Unanswered sent emails and unanswered sent replies threads

SE bietet diese Informationen auch als optionalen Digest an, den so genannten unbeantworteten E-Mail-Digest. Sie können es jeden Tag, alle paar Tage oder jede Woche erhalten.

Wir verwendenauch eine ähnliche SQL-Tabelle mit Google Charts, um Berichte darüber bereitzustellen, wie häufig bestimmte Personen Ihnen E-Mails senden:

Reports of inbound email frequency by sender

  public function reportInbound($account_id,$range=30,$limit = 100) {
    $result= Yii::app()->db->createCommand('SELECT fi_sender.personal, fi_sender.email,count(sender_id) as cnt
      FROM fi_message LEFT JOIN fi_sender ON fi_sender.id =fi_message.sender_id WHERE fi_sender.account_id = :account_id AND fi_message.created_at > DATE_SUB( NOW() , INTERVAL :range DAY )  
      GROUP BY sender_id ORDER BY cnt desc LIMIT :limit ')->bindValue('range',$range)->bindValue('account_id',$account_id)->bindValue('limit',$limit)->queryAll();
    return $result;
  }

Ich werde bald mehr über Google Charts for Tuts+ schreiben.

Nächste Schritte

Ich hoffe, Sie fanden Simplify Email faszinierend genug, um sich in der PHP IMAP-Programmierung zu versuchen. Es gibt so viele coole Funktionen, die Sie erstellen können, ohne dass die großen E-Mail-Anbieter etwas Neues tun müssen.

Wenn Sie Fragen oder Korrekturen haben, posten Sie diese bitte in den Kommentaren. Wenn Sie über meine zukünftigen Tuts+ -Tutorials und andere Serien auf dem Laufenden bleiben möchten, folgen Sie bitte @reifman oder besuchen Sie meine Autorenseite. Sie können mich auch hier kontaktieren.