Email- ez az információcsere legfontosabb eszköze, és ha munkára használod, akkor biztosan találkoztál már olyan helyzettel: postán érkezik egy levél, ami a script általi feldolgozáshoz szükséges adatokat tartalmazza. A Yandex levelezésről fogunk beszélni - ebben a cikkben megosztom veletek, kedves olvasók, a tapasztalatokat, hogyan lehet a leveleket kiszedni a postaládából, elemezzük azt a lehetőséget is, amikor a levélhez csatolt fájl van - hogyan lehet észlelni és végül töltse le a további manipulációkhoz.
Jómagam már régen szembesültem ezzel a feladattal, majd kevés tapasztalattal a Yandex levelezőprogramokkal kapcsolatban sok időt és ideget töltöttem a kívánt eredmény elérése érdekében. Az első hibám az volt, hogy sok webfejlesztőhöz hasonlóan elkezdtem intenzíven keresni hasonló példákat a weben, de magát a Yandex súgót (súgót) nem használtam. Igen, van ott hasznos információ, bár nagyon kicsi, de elég fontos egy ilyen forgatókönyv megírásához (erről lentebb). Akkoriban egy forgatókönyvet kellett írni, aminek a lényege: az áruk árlistáját tartalmazó levelet xls formátumban naponta egyszer küldtek az ügyfél Yandex levelére, azt feldolgozni (elemezni és összehasonlítani) kellett. az online áruház adatbázisából származó adatokkal és az eredménytől függően valamit, majd valahol frissíteni, letiltani vagy engedélyezni).
És az első dolog, amit a forgatókönyv megírása előtt meg fogunk tenni, az az, hogy felvázoljuk az akciótervünket, amely kilenc pontból áll majd:
A téma elég terjedelmes, de megpróbálok mindent minél tömörebben és érthetőbben megfogalmazni. Talán kezdjük is el.
Nyissa meg a leveleit, és lépjen a beállításokhoz, az alábbi képernyőképen látható módon:
Most az IMAP és POP3 protokollon keresztül elértük a levelezés beállításait:
Itt sokan olyan képet fognak látni, mint a fenti képen, de én találkoztam már nem is egyszer, amikor a hozzáférés le van tiltva. Ezért, ha a beállítások eltérnek, jelölje be a négyzeteket, mint a képernyőképen, számunkra a legfontosabb az IMAP protokollon keresztüli hozzáférés engedélyezése.
Ebben a példában nem fogunk bonyolult alkalmazásstruktúrát kitalálni, mivel nincs rá szükség, hanem csak azt adjuk hozzá, ami szükséges (a Sublime szövegszerkesztőben dolgozom):
UTF-8 kódolást fogunk használni, ezért azonnal töltsük ki a .htaccess fájlt a következő sorokkal:
AddDefaultCharset utf-8 AddCharset utf-8 *
Visszatérve az első ponthoz, egyértelmű, hogy a POP3 protokollon keresztül is dolgozhat a Yandex levelekkel. Akkor miért pont az IMAP? A kettő közül az IMAP az újabb és alternatívája a POP3-nak, így számos előnnyel jár (ami a wikipédián is megtalálható), de esetünkben csak az befolyásolta a választást, hogy újabb. Én személy szerint nem látok nagy különbséget, hogy mit használjunk konkrét feladat levelet kapni. Ha valamilyen oknál fogva a POP3 protokollt kell használnia, akkor az IMAP-ra vonatkozó összes funkció működni fog neki.
A levélhez való kapcsolódáshoz három paramétert kell tudnunk: mail bejelentkezés, jelszó és cím levelezőszerver. Ha nincs probléma két paraméterrel, akkor a második megtalálható a Yandexben. Írtam erről (a problémámról) fent, és sok példát írtam a hálózaton, ahol a harmadik paraméter nincs megfelelően megadva, és képzelje el, hogy hibák már a csatlakozási szakaszban előfordulnak - ez legalább kellemetlen. Nem fogok vergődni, és azonnal közvetlen linket adok a Yandex oldalára - beállítás email programok . A csatlakozáshoz a következőkre van szükségünk:
Most közvetlenül a kódhoz léphet:
Header("Content-Type: text/html; charset=utf-8"); error_reporting(0); request_once("functions.php"); $mail_login = "yandex_mail"; $mail_password = "mail_jelszó"; $mail_imap = "(imap.yandex.ru:993/imap/ssl)"; // A figyelembe veendő fájltípusok listája $mail_filetypes = array("MSWORD"); $kapcsolat = imap_open($mail_imap, $mail_bejelentkezés, $mail_jelszó); if(!$connection)( echo("A levélkapcsolat sikertelen - ".$mail_login); exit; )else( $msg_num = imap_num_msg($connection); $mails_data = array(); for($i = 1; $ i<= $msg_num; $i++){ /* Работать с каждым письмом из IMAP-потока будем тут */ } } imap_close($connection);
Először is megadjuk az UTF-8 kódolást a fejléc segítségével, és kikapcsoljuk a hibák megjelenítését. Csatlakoztatjuk a functions.php fájlt, és megadjuk a fentebb tárgyalt beállításokat. A $mail_filetypes tömbben megadjuk a szükséges fájlformátumokat. Azért döntöttek így, hogy kigyomlálják a felesleges szemetet és megkapják a konkrét fájlokat. A kapcsolat a levelekkel az imap_open() függvénnyel jön létre, amely siker esetén IMAP adatfolyamot, sikertelenség esetén false-t ad vissza (de ha engedélyezi a hibajelzést, ez nem így van). A streamekkel végzett munkát az imap_close () függvénnyel fejezzük be, átadva neki egy kapcsolatjelzőt. A két függvény között van egy közönséges feltételes operátor.
Ha a kapcsolat sikeres, az imap_num_msg() segítségével megtudjuk, hány betű van a levélben, és hozzáadunk egy tömböt, amelybe a folyamból minden szükséges adatot elhelyezünk. Ezt egy ciklus követi, amelyben minden betűt külön-külön feldolgozunk a számával (a számozás 1-től kezdődik).
Az e-mail fejléc eléréséhez az imap_header() függvényt kell használni, amelynek második paramétere az e-mail szám:
// E-mail fejléc $msg_header = imap_header($kapcsolat, $i);
Ebben a szakaszban kapunk egy objektumot, amelyből kivonjuk a szükséges adatokat, és elmentjük a $mails_data tömbbe. Íme egy példa az egyik betűre:
Ezen a képernyőképen látható, hogy minden adat duplikált, de ez nem játszik különösebb szerepet, azt húzzuk, ami kényelmesebb. Sokkal fontosabb a tárgysor kódolása. Bármi lehet, és ezt a pillanatot ellenőrizni kell. Ugyanez a helyzet a levél törzsével és a csatolt fájlokkal.
$mails_data[$i]["idő"] = idő($msg_header->MailDate); $mails_data[$i]["dátum"] = $msg_header->MailDate; foreach($msg_header->to as $data)( $mails_data[$i]["to"] = $data->mailbox."@".$data->host; ) foreach($msg_header->from as $ adatok)( $mails_data[$i]["from"] = $adat->postafiók."@".$data->host; )
Tömbünkön tároljuk: egy időbélyeget, a levél kézhezvételének dátumát, a címzett és a feladó e-mail-címét, és továbblépünk a levél tárgyának átvételéhez. Ehhez először három függvényt kell hozzáadnunk a functions.php fájlhoz:
Függvény check_utf8($charset)( if(strtolower($charset) != "utf-8")( return false; ) return true; ) függvény convert_to_utf8($in_charset, $str)( return iconv(strtolower($in_charset), "utf-8", $str); ) függvény get_imap_title($str)( $mime = imap_mime_header_decode($str); $title = ""; foreach($mime mint $kulcs => $m)( if(!check_utf8 ($m->charset))( $title .= convert_to_utf8($m->charset, $m->text); )else( $title .= $m->text; ) ) return $title; )
A nevek magától értetődőek, és szerintem csak az utolsó funkciót érdemes megmagyarázni. Egy kódolt karakterláncot vesz igénybe, és dekódolja az imap_mime_header_decode() segítségével, amely objektumok tömbjét adja vissza, amelyek mindegyikének két tulajdonsága van: karakterkészlet (kódolás) és szöveg (témaszöveg). Ezután minden egyszerű: egy ciklusban, a kódolás ellenőrzésével, átalakítjuk UTF-8-ra, és a tárgyat egyetlen fejlécbe ragasztjuk, és visszaküldjük.
Most térjünk vissza az index.php fájlhoz, és húzzuk ki az utolsó paramétert:
$mails_data[$i]["title"] = get_imap_title($msg_header->subject);
Ezzel befejeződik a levélfejléc feldolgozása.
Folytatjuk a tömbünk fokozatos kialakítását a feldolgozott e-mail adatokkal, és most két függvényt kell használnunk a törzs eléréséhez:
// Üzenet törzse $msg_structure = imap_fetchstructure($kapcsolat, $i); $msg_body = imap_fetchbody($kapcsolat, $i, 1);
Az első $msg_structure változó tartalmazza a betű szerkezetét - ez egy objektum, amelyben megtalálhatja a tömeget hasznos információ, az alábbi példa látható ennek az objektumnak egy részére:
Ami fontos a problémánk megoldásához:
Nézzük meg közelebbről az alkatrészek tulajdonságait. Először is azt kell mondani, hogy ennek a tömbnek a nulla cellájában olyan információk találhatók, amelyek pontosan megfelelnek a levél szövegének, és az elsőtől kezdve a csatolt fájlokhoz. Ezenkívül minden objektumtípus meg van adva, és a paraméterekben a kódolás explicit és implicit.
A betű szerkezetét tetszés szerint lehet beágyazni, nekem legalábbis volt olyan eset, hogy elérte a négy-öt szintet, így ahhoz, hogy irritáljuk, ahogy mondani szokás, a jövőben egy rekurzív függvényt kell írnunk.
A második imap_fetchbody() függvény lekéri az e-mail egy meghatározott részét, leggyakrabban kódolt formában.
Most adjunk hozzá egy változót, amelyben elmentjük a levél törzsének feldolgozott verzióját:
$body = "";
Térjünk vissza a functions.php fájlhoz, és írjunk egy rekurzív függvényt:
Függvény recursive_search($structure)( $encoding = ""; if($struktúra->altípus == "HTML" || $struktúra->típus == 0)( if($struktúra->paraméterek->attribútum == " karakterkészlet")( $karakterkészlet = $struktúra->paraméterek->érték; ) return array("kódolás" => $struktúra->kódolás, "karakterkészlet" => strtolower($karakterkészlet), "altípus" => $struktúra- >altípus); )else( if(isset($structure->parts))( return recursive_search($struktúra->parts); )else(if($struktúra->paraméterek->attribútum == "karakterkészlet")( $ karakterkészlet = $struktúra->paraméterek->érték; ) return array("kódolás" => $struktúra->kódolás, "karakterkészlet" => strtolower($karakterkészlet), "altípus" => $struktúra->altípus); ) ) )
A recursive_search() függvény egy paramétert vesz fel - a levél szerkezetét, ahol szekvenciálisan ellenőrzi a tulajdonságokat, és három paramétert kap: kódolás, karakterkészlet, altípus. A rekurzió kilépési pontja a nulla cellával rendelkező alkatrészek tulajdonság hiánya. Itt már nincs mit magyarázni, szerintem a kódból kiderül, hogy mi és hogyan történik.
Adjunk hozzá még egy függvényt a levél törzsének átalakításához, amelyre a jövőben szükségünk lesz:
Függvény structure_encoding($encoding, $msg_body)( switch((int) $encoding)( case 4: $body = imap_qprint($msg_body); break; case 3: $body = imap_base64($msg_body); break; case 2: $body = imap_binary($msg_body); break; case 1: $body = imap_8bit($msg_body); break; case 0: $body = $msg_body; break; default: $body = ""; break; ) return $body ;)
$rekurzív_adatok = recursive_search($msg_structure); if($rekurzív_adat["kódolás"] == 0 || $rekurzív_adat["kódolás"] == 1)( $törzs = $üzenet_test; ) if($rekurzív_adat["kódolás"] == 4)( $test = szerkezet_kódolás($rekurzív_adat["kódolás"], $üzenet_test); ) if($rekurzív_adat["kódolás"] == 3)( $test = szerkezet_kódolás($rekurzív_adat["kódolás"], $üzenet_test); ) if($ recursive_data["kódolás"] == 2)( $test = szerkezet_kódolás($rekurzív_adat["kódolás"], $msg_body); ) if(!check_utf8($recursive_data["karakterkészlet"]))( $body = convert_to_utf8($ recursive_data["karakterkészlet"], $msg_body); )
Miután megkaptuk a rekurzióból származó adatokat, fokozatosan ellenőrizzük az átviteli kódolást, és ennek függvényében a megfelelő paraméterekkel meghívjuk a structure_encoding () függvényt. Az utolsóban feltételes kijelentés figyelembe vesszük, hogy UTF-8-ban dolgozunk, és ha minden manipuláció után mást kapunk a kódolástól, akkor azt újrakódoljuk.
Marad egy vonal húzása:
$mails_data[$i]["body"] = base64_encode($body);
A levél törzse tartalmazhat egyszerű szöveget és HTML jelölést is, saját stílussal. BASE64-ben kódolunk, hogy az elrendezésünk ne tévedjen el a renderelés során.
Itt fokozatosan a végére érünk pályázatunk megírásának:
// Beágyazott fájlok if(isset($msg_structure->parts))( for($j = 1, $f = 2; $j< count($msg_structure->alkatrészek); $j++, $f++)(if(in_array($msg_structure->parts[$j]->altype, $mail_filetypes))( $mails_data[$i]["attachs"][$j]["type"] = $msg_structure->parts[$j]->altype; $mails_data[$i]["attachs"][$j]["size"] = $msg_structure->parts[$j]->byte; $mails_data[ $i]["attachs"][$j]["name"] = get_imap_title($msg_structure->parts[$j]->parameters->value); $mails_data[$i]["attachs"][$ j]["file"] = structure_encoding($msg_structure->parts[$j]->encoding, imap_fetchbody($connection, $i, $f)); file_put_contents("tmp/".iconv("utf-8" , "cp1251", $mails_data[$i]["csatol"][$j]["név"]), $mails_data[$i]["csatol"][$j]["fájl"]); ) ) )
A csatolt fájl feldolgozásáért felelős darab sokkal kisebb, és most - miért is pontosan. A fájlokkal való munka elve hasonló a levél törzsével való munkavégzéshez, csak ez a szakasz a résztulajdonságok tömbjében való jelenlétével kezdődik. Ne felejtse el kiszűrni a feleslegeseket a típuslistára hivatkozva. Az egyszerű file_put_contents() függvény segítségével a fájlunkat a szerverünkre mentjük a tmp mappába.
A munka során létrehoztunk egy tömböt a $mails_data adatokkal, és a vizualizációhoz már közvetlenül is dolgozunk vele. Ebben a cikkben egy tesztlevelet használtam, amit postán kaptam, lássuk, mit kaptunk a végén:
Ilyen tömböt kellene kapnod, sajnos személyes okok miatt el kellett rejtenem a fájl tartalmát. Most térjünk át a HTML-jelölésünkre:
A stílusokat itt nem adom hozzá, mivel ezek nem játszanak különösebb szerepet, végül:
És a szerveren a tmp mappában lesz egy fájl.
A cikk összes lépésének elvégzése után el fogja érni a megfelelő eredményt, de minden nem olyan egyszerű, mint amilyennek látszik - vannak buktatók, amelyeket figyelembe kell venni. Egy adott feladat szkriptjének írásakor minden szakaszban követni kell a kódolást, a levelek különböző levelekből származhatnak, amelyek mindegyikének megvan a maga árnyalata. Fontos lesz azt is figyelembe venni, hogy a Yandex leveleit és dokumentációját rendszeresen frissítik, így különböző alelemek jelenhetnek meg a levelezőprogramokkal való munkavégzéshez. Számomra ennyi, remélem hasznosnak találja ezt a cikket, amikor a Yandex mail alacsonyabb szintű verziójával dolgozik.
Nem fogadható e-mail melléklettel
ha a levelet fájllal küldik - bármilyen -, akkor a levél szövege eltűnik
segíts kérlek
Egyértelmű ... ha leveleket visz át a Yandexről a Yandexre, akkor minden sikerül ...
valahogy kitalálta
de ez a szkript ezért nem fogad el más fájlokat a Worden kívül, nem egyértelmű ... van mellette egy MSWORD sor, vesszővel elválasztva, tegyél bele PDF-t és JPG-t és PNG-t is - csak a Word olvas és ment rendesen... . valami ilyesmi
Az imap függvények egyik lehetséges felhasználási módja egy levelezési démon létrehozása, amely kezeli a felhasználók feliratkozását és leiratkozását a levelezőlistájáról. Ennek a feladatnak a végrehajtásához általában két módszert használnak a levelezőlistákban. Az első feltételezi, hogy a felhasználónak fel kell lépnie egy bizonyos oldalra, és meg kell erősítenie tevékenységét, a második e-mail küldését követeli meg. A második megköveteli, hogy a cron daemon-om rendszeresen futtassa a szkriptkezelőt. Emiatt nem olyan népszerű, mint az első módszer.
De amint látja, a legkomolyabb levelek a második módszert használják. Tehát ha lehetősége van a cron használatára, használja azt.
Valójában nem nehéz megérteni a funkciókat. Némi nehézségek adódhatnak a szkript által feldolgozott betűfejlécek elemzésekor.
Maga a szkript algoritmusa könnyen kitalálható. A démon kapcsolatot létesít a levelezőszerverrel, és ellenőrzi az üzeneteket. Ha nincsenek betűk, a szkript leáll. Ha vannak betűk, akkor az első betű fejléceit elemzi a rendszer. Megjelenik a forrás és tárgy mező. Ha a tárgy mező tartalmazza a két érvényes fejléc opció egyikét (előfizetés vagy leiratkozás), akkor a from mező értékének megfelelő rekord vagy aktívvá válik (megerősítve), vagy eltávolítja a táblából. Mindkét esetben megfelelő értesítést küld a szkript műveleteiről a feladó mezőben megadott címre. Ezt követően az e-mail törlésre kerül. Ha a tárgy nem tartalmaz érvényes tárgyat, hibaértesítést küld, és az e-mailt is megjelöli törlésre. A szkript ezután a következő e-mailre lép. Miután befejezte az összes levél elemzését, kiüríti a dobozt.
Az imap_open függvény a postafiók megnyitására szolgál. Mivel a PHP több protokollt is támogat, pontosan meg kell határozni, hogy melyik protokollt használjuk a dobozhoz. Esetünkben ez a pop3 a 110-es porton (standard). A szkript végrehajtásának eredményét a $my_box változóhoz rendeljük.
$my_box = imap_open("(you.pop.host/pop3:110)", "bejelentkezés", "jelszó");
Később látni fogja, hogy ezt a változót szinte minden imap függvény használni fogja. Ezután ellenőrizze, hogy a postafiókban vannak-e levelek. Az ellenőrzést az imap_num_msg függvény végzi.
$n = imap_num_msg($my_box);
Ennek eredményeként a $n változó a postafiókban lévő betűk számát fogja tartalmazni. Ez a szám lehet nagyobb nullánál, vagy egyenlő vele (ha a mező üres). Ha vannak betűk, akkor a while ciklusban elemezzük a betűket, egymás után eggyel növelve a betűk számát. Vegye figyelembe, hogy a mezőben az első betű 0 lesz, ahogy a tömb első eleme is. A betű számának növeléséhez a $m változóhoz 0 értéket rendelünk, majd a ciklus feltételei szerint növeljük eggyel $m++.
Két függvény elegendő a minket érdeklő fejlécek elemzéséhez: imap_header és imap_fetch_overview . Mindegyik végrehajtásához a dobozon kívül meg kell adni a betű számát. Esetünkben a cikluson belül egyenlő lesz a $m változóval.
Az imap_header egy objektumot ad vissza, amely kimerítő információkat tartalmaz az üzenet fejlécéről a végrehajtás eredményeként. Többek között ez az objektum tartalmaz egy tömböt, amelyből négy értéket tartalmaz. Ezek a személyes, az adl, a postafiók és a gazdagép. Ezek közül minket csak a postafiók és a host érdekel. Ezeket behelyettesítve megkapjuk azt a címet, ahonnan a levelet küldték.
$h = imap_header($my_box, $m); $h = $h->tól; foreach ($h mint $k => $v) ( $mailbox = $v->mailbox; $host = $v->host; $personal = $v->personal; $email = $mailbox . "@" . $host;
imap_fetch_overview - lehetővé teszi számunkra, hogy megtudjuk a levél tárgyát. Ugyanezen célokra az imap_header is használható, de ez számos okból előfordulhat, hogy ez néha nem működik. A függvény által visszaadott tömbből csak a tárgy mezőre van szükségünk
$s = imap_fetch_overview($my_box, $m); foreach ($s mint $k => $v) $subj = $v->subject;
A további teendőink abból indulnak ki, hogy kivonjuk az e-mailt az adatbázisból, és ha ott van, akkor a teljes sort ezzel a bejegyzéssel jelöljük meg, vagy töröljük. Tegyük fel, hogy a webhelyen a levelezési űrlap kitöltése után az előfizető 0 állapotot kap, és az előfizetés megerősítése után 1-re változik.
If ($subj == "feliratkozás") ( mysql_query("frissítési feliratkozási készlet stat=1 ahol email=$saját_e-mail"); $del = imap_delete($my_box, $m); mail($email, $add_sbj, $add_text , $fejlécek); ) else if ($subj == "leiratkozás") ( mysql_query("törlés a feliratkozásból ahol email = $saját_email"); $del = imap_delete($my_box, $m); mail($email, $ del_sbj, $del_text, $headers); ) else ( $del = imap_delete($my_box, $m); mail($email, $err_sbj, $err_text, $headers); ) az összes művelet befejezése után a szkript törli a postafiók. $clear = imap_expunge($my_box);
Ez a legegyszerűbb program csak azt mutatja be, hogy a PHP nem csak dinamikusan változó oldalakat tud írni, hanem olyan szolgáltatásokat is, amelyeket a felhasználó egyáltalán nem lát.
A teljes program listája, kivéve az adatbázis-kapcsolat paramétereit:
tartalmazza "config.php"; // adatbázis kapcsolat $my_box = imap_open("(you.pop.host/pop3:110)", "bejelentkezés", "jelszó"); $n = imap_num_msg($my_box); $m = 0; $add_text = "Köszönjük, hogy megerősítette előfizetését"; $add_sbj = "hozzáadtad!"; $del_text = "Eltávolítottuk a levelezőlistáról. "; $del_sbj = "törlés a listáról"; $err_text = "Sajnáljuk, de ez a postafiók csak a levelezőlista adminisztrációjára szolgál"; $err_sbj = "hiba"; $headers = "feladó: feliratkozás robot x-mailer: php4 tartalomtípus: szöveg/sima; charset=windows-1251 "; if($n != 0) ( while($m++< $n) { $h = imap_header($my_box, $m); $s = imap_fetch_overview($my_box, $m); $h = $h->tól től; foreach ($h mint $k =>$v) ( $mailbox = $v->mailbox; $host = $v->host; $personal = $v->personal; $email = $mailbox . "@" . $host; $saját_e-mail = mysql_escape_string($email); ) foreach ($s mint $k => $v) $subj = $v->subject; if ($subj == "feliratkozás") ( mysql_query("update table set stat=1 where email=$my_email"); //print mysql_error(); $del = imap_delete($my_box, $m); mail($ email, $add_sbj, $add_text, $headers); ) else if ($subj == "leiratkozás") ( mysql_query("törlés a táblázatból, ahol email = $saját_e-mail"); $del = imap_delete($my_box, $m) ; mail($email, $del_sbj, $del_text, $headers); ) else ( $del = imap_delete($open_box, $m); mail($email, $err_sbj, $err_text, $headers); ) ) $clear = imap_expunge($my_box); )
A listáról hiányzik néhány részlet, például a win-ről koi-ra való esetleges átalakítás, a feladó postafiókjának ellenőrzése stb. Ezek már funkcionális túlzások, amiket mindenki tetszés szerint hozzáadhat.
Az imap függvények egyik lehetséges felhasználási módja egy levelezési démon létrehozása, amely kezeli a felhasználók feliratkozását és leiratkozását a levelezőlistájáról. Ennek a feladatnak a végrehajtásához általában két módszert használnak a levelezőlistákban. Az első feltételezi, hogy a felhasználónak fel kell lépnie egy bizonyos oldalra, és meg kell erősítenie tevékenységét, a második e-mail küldését követeli meg. A második azt is megköveteli, hogy a cron daemon?om rendszeresen futtassa a szkriptkezelőt. Emiatt nem olyan népszerű, mint az első módszer.
De amint látja, a legkomolyabb levelek a második módszert használják. Ezért, ha lehetősége van a crond használatára, használja azt.
Valójában a funkciók megértése nem olyan nehéz. Az a személy, aki korábban a PHP-nél dolgozott, könnyen megérti, hogyan kell velük dolgozni. Némi nehézségek adódhatnak a szkript által feldolgozott betűfejlécek elemzésekor.
Maga a szkript algoritmusa könnyen kitalálható. A démon kapcsolatot létesít a levelezőszerverrel, és ellenőrzi az üzeneteket. Ha nincsenek betűk, a szkript leáll.
Ha vannak betűk, akkor az első betű fejléceit elemzi a rendszer. Megjelenik a forrás és tárgy mező. Ha a tárgy mező tartalmazza a két érvényes fejléc opció egyikét (előfizetés vagy leiratkozás), akkor a from mező értékének megfelelő rekord vagy aktívvá válik (megerősítve), vagy eltávolítja a táblából. Mindkét esetben megfelelő értesítést küld a szkript műveleteiről a feladó mezőben megadott címre. Ezt követően az e-mail törlésre kerül. Ha a tárgy nem tartalmaz érvényes tárgyat, hibaértesítést küld, és az e-mailt is megjelöli törlésre. A szkript ezután a következő e-mailre lép.
Miután befejezte az összes levél elemzését, kiüríti a dobozt.
Nem fárasztom az olvasót folyamatábrákkal, úgyhogy térjünk a lényegre. Az imap_open függvény a postafiók megnyitására szolgál. Mivel a PHP több protokollt is támogat, kifejezetten meg kell adnia, hogy melyik protokollt használja a dobozhoz. Esetünkben ez a POP3 a 110-es porton (standard). A szkript végrehajtásának eredményét a $my_box változóhoz rendeljük.
Később látni fogja, hogy ezt a változót szinte minden imap függvény használni fogja. Ezután ellenőrizze, hogy a postafiókban vannak-e levelek. Az ellenőrzést az imap_num_msg függvény végzi.
$n = imap_num_msg ($my_box );
Ennek eredményeként a $n változó a postafiókban lévő betűk számát fogja tartalmazni. Ez a szám lehet nagyobb nullánál, vagy egyenlő vele (ha a mező üres).
Ha vannak betűk, akkor a while ciklusban elemezzük a betűket, egymás után eggyel növelve a betűk számát. Vegye figyelembe, hogy a mezőben az első betű 0 lesz, ahogy a tömb első eleme is.
A betű számának növeléséhez a $m változóhoz 0 értéket rendelünk, majd a ciklus feltételei szerint növeljük eggyel $m++.
A minket érdeklő fejlécek elemzéséhez elég két függvény: imap_header és imap_fetch_overview. Mindegyik végrehajtásához a dobozon kívül meg kell adni a betű számát. Esetünkben a cikluson belül egyenlő lesz a $m változóval.
Az Imap_header a végrehajtás eredményeként egy objektumot ad vissza, amely átfogó információkat tartalmaz az üzenet fejlécéről. Többek között ez az objektum tartalmaz egy tömböt, amelyből négy értéket tartalmaz. Ezek a személyes, az adl, a postafiók és a gazdagép. Ezek közül minket csak a postafiók és a host érdekel. Ezeket behelyettesítve megkapjuk azt a címet, ahonnan a levelet küldték.
$h = $h -> innen: ;
a
foreach ($h mint $k => $v ) (
$postafiók = $v -> postafiók ;
$host = $v -> host ;
$személyes = $v -> személyes ;
$email = $postafiók . ? @ ¬ . $ host ;
imap_fetch_overview – tudatja velünk az e-mail tárgyát. Ugyanezen célokra az imap_header is használható, de ez számos okból előfordulhat, hogy ez néha nem működik. A függvény által visszaadott tömbből csak a tárgy mezőre van szükségünk
foreach ($s mint $k => $v ) (
$subj = $v -> tárgy ;
}
A következő lépésünk az, hogy kivonjuk az e-mailt az adatbázisból, és ha ott van, jelöljük meg a teljes sort ezzel a bejegyzéssel „ellenőrzöttként”, vagy töröljük. Tegyük fel, hogy a webhelyen a levelezési űrlap kitöltése után az előfizető 0 állapotot kap, és az előfizetés megerősítése után 1-re változik.
if ($subj == "FELIRATKOZÁS" ) (
mysql_query( "UPDATE subscribe SET stat=1 WHERE email=$my_email");
}
mysql_query( "DELETE FROM subscribe WHERE email = $my_email");
$del = imap_delete ($my_box , $m );
}
más(
$del = imap_delete ($my_box , $m );
}
ahogy fentebb említettük, az összes művelet végrehajtása után a szkript törli a dobozt.
Ez a legegyszerűbb program csak azt mutatja be, hogy PHP-ben nem csak dinamikusan változó oldalakat, hanem a felhasználó számára egyáltalán nem látható szolgáltatásokat is lehet írni. Természetesen a shell szkriptek tekintetében a PHP nem alkalmazható, ellentétben a versenytárs Perl-lel, de ennek ellenére ...
A teljes program listája, kivéve az adatbázis-kapcsolat paramétereit (db.php):
tartalmazza a "db.php" ;
$my_box = imap_open ("(you.pop.host/pop3:110)" , "bejelentkezés" , "jelszó" );
$n = imap_num_msg ($my_box );
$m = 0 ;
$add_text = "
Köszönjük, hogy megerősítette előfizetését " ;
$add_sbj = "Hozzáadtad!" ;
$del_text = "
Elnézést, de ez a postafiók használatban van.
csak terjesztési adminisztrációhoz" ;
$err_sbj = "Hiba" ;
$fejlécek = Feladó: Feliratkozás Robot
Xmailer: PHP4
Tartalom típusa: szöveges/sima; charset=UTF-8
"
;
if($n != 0 ) (
while($m++<
$n
) {
$h = imap_header ($my_box , $m );
$s = imap_fetch_overview ($my_box , $m );
$h = $h -> innen: ;
foreach ($h mint $k => $v ) (
$postafiók = $v -> postafiók ;
$host = $v -> host ;
$személyes = $v -> személyes ;
$email = $postafiók . "@" . $ host ;
$saját_e-mail = mysql_escape_string($email );
}
foreach ($s mint $k => $v ) (
$subj = $v -> tárgy ;
}
if ($subj == "FELIRATKOZÁS" ) (
mysql_query( "UPDATE table SET stat=1 WHERE email=$my_email");
//mysql_error();
$del = imap_delete ($my_box , $m );
mail ($email , $add_sbj , $add_text , $headers );
}
elseif ($subj == "FELIRATKOZÁS" ) (
mysql_query( "DELETE FROM FROM table WHERE email = $my_email");
$del = imap_delete ($my_box , $m );
mail ($email , $del_sbj , $del_text , $headers );
}
más(
$del = imap_delete ($nyitott_doboz , $m );
mail ($email , $err_sbj , $err_text , $headers );
}
}
$clear = imap_expunge($my_box);
}
?>
A minap kaptam egy feladatot, hogy írjak egy kis PHP modult, amivel dolgozhatok a bejövő levelekkel. Kicsit guglizva láttam, hogy az egyik protokoll megfelel nekem erre a feladatra POP3És IMAP.
De kézenfekvő volt a választás, hogy az IMAP-ot használom, mivel az funkcionálisabb és modernebb, mint a POP3 protokoll.
Most gyorsan ki kellett találnom, hogyan dolgozhatok az IMAP protokollokkal, hogyan fogadhatok leveleket a Yandex/Google levelezőszerverről.
A kényelmesebb munka érdekében a könyvtárat választottam PhpImap, mivel gyorsan és egyszerűen végrehajthat minden olyan feladatot, amire szükségem van.
Most, hogy a protokoll és a könyvtár választása mellett döntöttünk, megpróbálunk csatlakozni a levelezőszerverhez.
Ahhoz, hogy a PHP teljes mértékben működjön az IMAP protokollal, csatlakoztatnia kell a bővítményt php_imap.dll/imap.so a php.ini fájlban.
Először próbáljunk meg csatlakozni a Yandex levelezőhöz, mivel ezzel volt a legkevesebb probléma.
//Könyvtárak szerepeltetése include("/phpImap/Mailbox.php"); include("/phpImap/IncomingMail.php"); //A kényelem kedvéért hozzunk létre állandókat a levelezőszerverhez való csatlakozáshoz. define("MAIL_IMAP_SZERVER", "imap.yandex.ru"); define("MAIL_IMAP_SZERVER_PORT", 993); define("MAIL_IMAP_LOGIN", " "); define("MAIL_IMAP_PASS", "example_pass"); define("MAIL_IMAP_PATH", "(".MAIL_IMAP_SZERVER.":".MAIL_IMAP_SZERVER_PORT."/imap/ssl)INBOX"); $postaláda = new PhpImap\Mailbox(MAIL_IMAP_PATH, MAIL_IMAP_LOGIN, MAIL_IMAP_PASS, __DIR__); try ( $mailbox->getImapStream(); ) catch ($e kivétel) ( die($e->getMessage()); )
Hogyan látjuk az osztálykonstruktort Postafiók a következő érveket veszi fel:
Ezt követően ellenőrizzük, hogy a kapcsolatunk a metóduson keresztül jött-e létre getImapStream() ha valamilyen okból nem jön létre a kapcsolat, akkor az alkalmazás kivételeket dob a sikertelen csatlakozás okával együtt.
Fontos figyelembe venni azt a tényt, hogy a Yandex levelezési beállításaiban előfordulhat, hogy letiltva az IMAP protokoll használatával csatlakozhat.
Hasonlítsuk össze a kapcsolatot a Gmail levelezéssel.
Define("MAIL_IMAP_SZERVER", "imap.gmail.com"); define("MAIL_IMAP_SZERVER_PORT", 993); define("MAIL_IMAP_LOGIN", " "); define("MAIL_IMAP_PASS", "example_pass"); define("MAIL_IMAP_PATH", "(".MAIL_IMAP_SZERVER.":".MAIL_IMAP_SZERVER_PORT."/imap/ssl)INBOX");
Amint látjuk, gyakorlatilag nem különbözik az előző kapcsolattól, de valószínűleg kivételt kap a szerverhez való csatlakozáskor.
Ez a probléma összefügg azzal a ténnyel, hogy A Gmail IMAP protokoll alapértelmezés szerint le van tiltva. Engedélyezheti az IMAP-hozzáférés ⇒ IMAP engedélyezése opció Továbbítás és POP/IMAP lapjának beállításaiban.
Miután engedélyeztük az IMAP protokollt, meg kell tennünk hozzon létre alkalmazásjelszót. Ahhoz, hogy létrehozhassuk, kéttényezős jogosultságot kell tennünk ehhez a profilhoz. Ezután elkezdheti létrehozni. Amikor új jelszót hozunk létre az alkalmazáshoz, azt be kell írnunk a MAIL_IMAP_PASS állandóba a szerverhez való csatlakozáshoz.
Kérjük, vegye figyelembe, hogy az alkalmazásjelszó létrehozásakor előfordulhat, hogy nem tud csatlakozni a szerverhez, ennek az az oka, hogy ezt a jelszót még nem alkalmazták teljesen a Gmail szolgáltatásban, általában 5-60 percet vesz igénybe.
Sikeres csatlakozás után végrehajthatunk egy kérést, hogy stream üzeneteket kapjunk a szervertől. Ehhez a módszert fogjuk használni searchMailBox(string $kritérium) amely lényegében egy metódusburkoló imap_search. Itt fontos megérteni, hogy a $criteria argumentum egy bizonyos kritérium a számunkra szükséges üzenetek megtalálásához, maga a metódus adja vissza az elemek azonosítóit, amelyek a későbbiekben hasznosak lesznek számunkra, hogy részletes információkat szerezzünk a levélről.
$mailsIds = $postafiók->searchMailBox("ALL");
Ahogy sejtette, itt kapunk minden üzenetet.
És most próbáljunk meg más, hasonlóan fontos keresési feltétellel foglalkozni:
//Minden üzenet 3 napig. $mailsIds = $postaláda->searchMailBox("INCE "".date("d-H-Y",strtotime("-3 day"))."""); //Olvasatlan üzenetek 3 napig. $mailsIds = $postaláda->searchMailBox("NEM LÁTVA ".ÓTA "".date("d-H-Y",strtotime("-3 day"))."""); //Az ezzel a találattal rendelkező üzenetek keresése a TEXT fejlécben. $mailsIds = $postafiók->searchMailBox("SZÖVEG "Hírlevél""); //Az ezzel az egyezéssel rendelkező üzenetek keresése a BODY fejlécben. $mailsIds = $postafiók->searchMailBox("BODY "Információs üzenet""); //Keresés a feladó e-mailje alapján. $mailsIds = $postaláda->searchMailBox("FROM " ""); //Üzenetek lekérése TÁRGY fejléc szerint $mailsIds = $mailbox->searchMailBox("TÁRGY "Frissítések megjelentek a telefonhoz"");
Ez a példa jól megragadja a keresési feltételek használatának alapjait.
Most, hogy számos üzenetazonosítóval rendelkezünk, készen állunk a feldolgozásra:
//Az utolsó üzenet azonosítójának lekérése a tömbből. $id = end($mailsIds); //Az IncomingMail osztály objektum példányának beszerzése, amely információkat tartalmaz az üzenetről. $mail = $postafiók->getMail($id); //Az üzenethez csatolt fájlok letöltése, ha létezik. $mail->getAttachments(); //Üzenetek megjelenítése. echo $mail->textHtml;
Így gond nélkül megkaptuk az üzeneteket a levelünkből és annak mellékleteiből.
Ez a könyvtár számos hasznos módszert is tartalmaz az e-mail üzenetekkel való kényelmesebb munka érdekében:
Az üzeneteket az azonosítójával mentjük.
$postaláda->saveMail($id,$id..eml");
Üzenetek beállítása olvasatlanként az azonosítójuk alapján.
$mailbox->markMailAsUnread($id);
Üzenetek beállítása olvasottnak az azonosítójuk alapján.
$postaláda->markMailAsRead($id);
Jelöljük az üzenetet az azonosítójával.
$mailbox->markMailAsImportant($id);
Üzenetek törlése az azonosítójuk alapján.
Előfordulhat, hogy egyes webes alkalmazások meghatározott e-mail-címet kérnek a felhasználótól. Ilyen esetben megírhatjuk saját SquirrelMail vagy Roundcube email kódunkat. Függetlenül attól, hogy melyiket választja, az IMAP-mailekkel való munkavégzés ismerete hasznos lesz.
Az IMAP használatát PHP-ben két oldalon ismertetjük. Az első oldalon a levelezőszerverekhez való csatlakozáshoz és az üzenetek olvasásához szükséges funkciók. A második oldalon az e-mailekkel való munkáról lesz szó, például üzenetek törléséről, alkalmazások letöltéséről stb.
A funkcionalitás bemutatására olyan kódpéldákat használunk, amelyek natív levelezőkliens-szkriptek futtatására használhatók.
URL-paraméterek a szükséges függvények meghívásához:
A paraméterek lekérhetők a $_GET segítségével, és a kapcsolóval a megfelelő műveleteket hívhatjuk elő.
Az IMAP szerverrel való kapcsolat létrehozásához az imap_connect() függvényt használjuk, az alábbiak szerint:
Az üzenet elérési útja, felhasználónév és jelszó a szükséges paraméterek a szerverhez való csatlakozáshoz. A további lehetőségekről a kézikönyvben tájékozódhat.
A postafiók elérési útja egy karakterlánc, amely azonosítja a kiszolgálót, a zárójelben lévő port pedig a kívánt levélmappa nevét adja meg.
Íme néhány sor a mappához beérkező levelek postai szolgáltatások:
Egyes szervereken nincs engedélyezve az SSL, ebben az esetben ki kell hagynia az „SSL”-t a sorból. Más szerverek használhatják saját tanúsítványaikat, amelyekben szerepelnie kell a „NOVALIDATE-CERT” kifejezésnek.
Ha a levelezőszerver kapcsolat meg van nyitva, most megtekinthetjük a következő tevékenységekhez használt funkciókat:
beérkező levelek , Küldött , SzemétÉs Levélszemét- Ezek a mappák szinte minden e-mail fiókban láthatók, és a felhasználók gyakran létrehozhatnak saját mappákat. Az ezekben a mappákban lévő üzenetek megtekintéséhez meg kell változtatni a kapcsolati karakterláncunkat. Például alkalmazza az „INBOX” (Beérkezett üzenet) elemet az elérési út karakterláncában korábban. Ha csatlakoznia kell a spam mappához, használja helyette a „Spam”-hez hasonlót. De míg lehet, hogy mint Levélszemét egy e-mail fiókba, ha e-mail kliensen keresztül nézi, a háttérben lévő mappák tényleges neve eltérő lehet. Az imap_list() segítségével kilistázhatjuk egy fiók összes meglévő mappáját.
"; foreach ($folders mint $mappa) ( $folder = str_replace("(imap.gmail..php?folder=" . $folder . "&func=view">" . $mappa . ""; ) visszhang"";
Az imap_open()-ből kapott kapcsolatkezelőt kezdeti paraméterként át kell adnunk az imap_list() -nek. Az elérési utat is át kell adnunk (mappa nélkül, pl. "INBOX"). Harmadik paraméterként kérje le az összes elérhető mappát.
Minden mappa tartalmazza az elérhető e-mail üzenetek listáját, ezért nézzük meg, hogyan hozhatunk létre üzenetlistát a postafiókunkban.
Először be kell szereznie az imap_num_msg() segítségével elérhető üzenetek számát. Ezután az imap_header() függvény segítségével információt kaphatunk az egyes üzenetek fejlécéről.
Tegyük fel, ha az utolsó 20 e-mailt akarjuk:
($számÜzenetek - 20); $i--) ( $fejléc = imap_header($imap, $i); $fromInfo = $fejléc->from; $replyInfo = $fejléc->válasz_cím; $details = array("fromAddr" => (isset($) fromInfo->mailbox) && isset($fromInfo->host)) ?$fromInfo->mailbox ."@" .$fromInfo->host: "", "fromName" => (isset($fromInfo->personal)) ?$fromInfo->personal: "", "replyAddr" => (isset($replyInfo->mailbox) && isset($replyInfo->host)) ?$replyInfo->postafiók . "@" . $replyInfo->host : "", "replyName" => (isset($replyTo->personal)) ? $replyto->personal: "", "subject" => (isset($header->subject)) ? $fejléc->tárgy : "", "udate" => (isset($header->udate)) ? $header->udate: ""); $uid = imap_uid($imap, $i); echo "
Az $Imap kapcsolatokat a megfelelő mappában kell megnyitni. Ezután az imap_num_msg() által kapott üzenetek számának felhasználásával végigpörgethetjük az utolsó 20 e-mailt. A linket és az e-mail számot az imap_header() kapja meg, hogy megkapja a fejléc-információkat, amelyek aztán összetéveszthetők a feladó érdekes információival, e-mail címmel, névvel, témával stb.
Felhívjuk figyelmét, hogy az üzenetek teljes számából származó e-mail-szám nem az üzenet egyedi azonosítója. Ha 100 e-mail van a postaládában, akkor az utolsó szám 100 lesz, az előző 99, és így tovább. Ha törli a 100-as számú üzenetet, majd új üzenetet kap, annak száma 100 lesz.
A következő lépések folytatásához egyedi azonosítót kell beszereznie az e-mailhez. Minden e-mailnek van egy egyedi azonosítója, az UID, amelyet e-mail megadásával kaphatunk meg. Az imap_uid() UID függvénye egyedi, és nem változik az idő múlásával.
Az e-mailek olvasása nem olyan egyszerű, mint az előző feladatok, ezért a Mitul Koradia által fejlesztett levelezőosztályokat kell használnia. Az osztály a következő három függvényt adaptálta az alábbi példánkhoz:
kódolás) ( 3. eset: return imap_base64($text); 4. eset: return imap_qprint($text); alapértelmezett: return $text; ) ) // többrészes if ($struktúra->típus == 1) ( foreach ($struktúra ->részek mint $index => $subStruct) ( $prefix = ""; if ($partSzám) ( $prefix = $partSzám . "."; ) $data = get_part($imap, $uid, $mimetype, $ alStruktúra, $prefix .($index + 1)); if ($data) ( return $data; ) ) ) ) return false; ) függvény get_mime_type($structure) ( $primaryMimetype = array("SZÖVEG", "TÖBB RÉSZ", "ÜZENET", "APPLICATION", "AUDIO", "IMAGE", "VIDEO", "OTHER"); if ($struktúra ->altípus) ( return $primaryMimetype[(int)$structure->type] . "/" . $struktúra->altípus; ) return "TEXT/PLAIN"; )
A GetBody() függvény megkapja az e-mail tartalmát az UID és az IMAP kapcsolat átadásával. A függvényen belül meghívjuk a get_part() függvényt, amelynek tartalomtípusa text / HTML. Az egyszerű szöveges e-mail üzenetek sokkal könnyebben olvashatók. Tehát először megpróbáljuk megtalálni a HTML-tartalmat az e-mailben.
Ezután az imap_fetchstructure() függvény segítségével olvassuk be az e-mail szerkezetet. Módosítottuk a könyvtári funkciókat, hogy az UID-t használjuk az FT_UID állandó átadása helyett.
Ezután a get_mime_type() függvény segítségével megkapjuk az e-mail üzenet MIME típusát. Ez a függvény nyolc MIME-típust ad vissza egész számként:
A visszatérést a karakterlánc tényleges MIME típusává alakítjuk a MIME típusok tömbjei segítségével.
Az összetett üzeneteknek nagyszámú altípusa lehet, ezért rekurzív módon végigmegyünk az összes altípuson a számrész használatával, és az imap_fetchBody() segítségével lekérjük az e-mailt, amikor a mime-type segítségével megtaláljuk a megfelelőt.
Ezután a megfelelő dekódolási funkciót használjuk az üzenettípus kódolásának megfelelően, és visszaadjuk a tartalmat. Az elérhető kódolási típusok teljes listája:
Befejeztük az IMAP-kiszolgálóhoz való csatlakozás alapjait, az üzenetek listázását az elérhető mappákban, és befejeztük az e-mailek tartalmának elolvasását. A bejegyzés következő oldalán azokról a funkciókról lesz szó, amelyekkel a levelezőkliens további funkcionalitásait, például üzenetek törlését, mellékletek feldolgozását lehet megvalósítani.
