CLASS E-MAIL

<?php
	/**
	* Gestion d'un email : afficher, envoyer.
	* 
	* <p>Cette classe permet de manipuler un email. Elle fonctionne avec un flux imap que l'on peut gérer avec une autre class</p>
	* 
	* @name Email
	* @author generationweb <greg@generationweb.be> 
	* @http://www.generationweb.be
	* @copyright generationweb.be 2008
	* @version 1.0.0
	*/
	class Email {
	
		/*~*~*~*~*~*~*~*~*~*~*/
		/*  1. propriétés    */
		/*~*~*~*~*~*~*~*~*~*~*/
    
		/**
		* @var resource
		* @desc flux imap vers une boîte mail
		*/
		private $rFlux = null;
		
		/**
		* @var String
		* @desc Sujet de l'email
		*/
		private $sujet = "";
		
		/**
		* @var String
		* @desc Expéditeur de l'email
		*/
		private $de = "";
		
		/**
		* @var String
		* @desc Destinataire de l'email
		*/
		private $a = "";
		
		/**
		* @var Date
		* @desc Date d'envoi de l'email
		*/
		private $dateEnvoi = 0;
		
		/**
		* @var Array
		* @desc liste des adresses des destinataires
		*/
		private $sendTo = array();
		
		/**
		* @var String
		* @desc Séparateur entre l'entête et le corps de l'email
		*/
		private $boundary = "";
		
		/**
		* @var String
		* @desc Entête de l'email
		*/
		private $entete = "";
		
		/**
		* @var String
		* @desc Contenu de l'email
		*/
		private $message = "";
		
		/**
		* @var String
		* @desc les pièces jointes de l'email
		*/
		private $attachement = "";
		
		/**
		* @var Array
		* @desc liste des pièces jointes (une pièces jointes étant un tableau)
		*/
		private $pieceJointe = array();
		
				
		/*~*~*~*~*~*~*~*~*~*~*/
		/*  1.1 accesseurs    */
		/*~*~*~*~*~*~*~*~*~*~*/
		
		function getSujet() {return $this->sujet;}              // renvoi le sujet
		function getA() {return $this->a;}                      // renvoi le destinataire 
		function getDe() {return $this->de;}                    // renvoi l'expéditeur
		function getMessage() {return $this->message;}          // renvoi le message
		function getDateEnvoi() {return $this->dateEnvoi;}      // renvoi la date d'envoi
		function getPieceJointe() {return $this->pieceJointe;}  // renvoi un tableau de pièces jointes
		
		
		/*~*~*~*~*~*~*~*~*~*~*/
		/*  1.2 "seteurs"    */
		/*~*~*~*~*~*~*~*~*~*~*/
		//Set le sujet à la classe Email
		function Subject( $subject ) {
			$this->sujet = strtr( $subject, "\r\n" , " " );
		} 
		
		// Set le message à la classe Email
		function Body( $body ) {
			$entete_message = "\nContent-Type: text/html; Charset=iso-8859-1\n";
			$entete_message .= "Content-Transfert-Encoding: 8bit\n\n";
			$this->message = $entete_message . chunk_split($body) . "\n--".$this->boundary;
		} 
		
		//Set le from à la classe Email
		function From( $from ) {
			if( ! is_string($from) ) {
				echo "Class Mail: error, From is not a string";
				exit;
			}
			$this->de= $from;
		}
		
		//Add un destinataire au tableau a de la classe Email
		function To( $a ) {
			if( is_array( $a ) )
				$this->sendTo= $a;
			else
				$this->sendTo[] = $a;
		}

		
		
		/*~*~*~*~*~*~*~*~*~*~*/
		/*  2. méthodes      */
		/*~*~*~*~*~*~*~*~*~*~*/
    
		/**
		* Constructeur
		* 
		* <p>création de l'instance de la classe</p>
		* 
		* @name Nom de la classe::__construct()
		* @return void 
		*/
		function __construct () {
			//la frontière
			$this->boundary = "b" . md5(uniqid(time()));
		}

		
		/*~*~*~*~*~*~*~*~*~*~*~*~*~*/
		/*  2.1 méthodes privées   */
		/*~*~*~*~*~*~*~*~*~*~*~*~*~*/
				
		/**
		* @name _make_headers
		* Construit l'entête du mail
		* 
		*
		* @return void.
		*/
		private function _make_headers() 
		{
			// creation du header mail
			$this->entete= "From: ".$this->de."\n";
			$this->a= implode( ", ", $this->sendTo );
		}
		
		/**
		* @name _make_attachement
		* Construit les pièces jointes du mail
		* 
		*
		* @return void.
		*/
		function _make_attachement() {
			// les entêtes pour dire que c'est un message mutipart
			$this->entete .= "MIME-Version: 1.0\n";
			$this->entete .= "Content-Type: multipart/mixed; boundary = ".$this->boundary."\n\n";
			$this->entete .= "This is a MIME encoded message.\n\n--".$this->boundary;
			
			// for each attached file, do...
			$this->attachment = "";
			$iLengthPieceJointe = sizeof( $this->pieceJointe);
			for( $i=0; $i < $iLengthPieceJointe; $i++ ) {
				$filename = "" . $this->pieceJointe[$i]['nom'];
				
				if( ! file_exists( $filename) ) {
					echo "Class Email, method attach : file $filename can't be found"; exit;
				}
				
				//lecture du fichier
				$fp = fopen($filename, "r");
				$content_file = "";
				while ($data = fread($fp, 4096) )
					$content_file .= $data;
				
				//encodage en base 64 et mise en forme (ligne de 75 caractères)
				$le_fichier = chunk_split(base64_encode($content_file));
				
				//on ajout les entêtes du fichier
				$entete_fichier = "\nContent-Type: application/octet-stream; ";
				$entete_fichier .= "name =\"".basename($this->pieceJointe[$i]['nom'])."\"\n";
				$entete_fichier .= "Content-Transfer-Encoding: base64\n";
				$entete_fichier .= "Content-Disposition:" . $this->pieceJointe[$i]['dispo'] . "\n\n";
				
				
				$le_fichier = $entete_fichier.$le_fichier."\n--".$this->boundary; // avec la frontière
				
				$this->attachement .= $le_fichier;
				
				//suppression des fichiers
				Unlink($this->pieceJointe[$i]['nom']); 
			}
		}
		
		/**
		* @name trouverNom
		* trouve le nom du fichier en pièce jointe
		* 
		*
		* @return string.
		*/
		private function trouverNom($aParam) {
			$nomFichier = "";
			$iParamSize = sizeof($aParam);
			for ($i=0;$i<$iParamSize;$i++) 
			{
				if ( ($aParam[$i]->attribute == "filename") || ($aParam[$i]->attribute =="name") ) 
					$nomFichier = $aParam[$i]->value;
			}
			return $nomFichier;
		}
		
		/**
		* @name decoder
		* decode le texte en 1 paramètre suivant l'encodage passé en second paramètre
		* 
		*
		* @return string.
		*/
		private function decoder( $sTexte, $iEncodage) {
			switch ($iEncodage)
			{
				case 4:
					$ret = imap_qprint($sTexte);
					break;
				case 3:
					$ret = imap_base64($sTexte);
					break;
				default:
					$ret = $sTexte;
					break;
			}
			return $ret;
		}
		
		/**
		* @name BodyToArray
		* Mets les parties du message dans un tableau à 2 entrée contenant : 1 le texte - 2 un tableau avec les pièces jointes
		* 
		*
		* @return array.
		*/
		private function BodyToArray( $id_msg, $num_partie, $partie, $niveau, $alternative=0 ) {
			//tableau contenant les informations
			static $retour = Array('message' => '' );
			
			//si la partie contient des infomrations sru la disposition 
			//et que la chaine indique "attachment", alors nous avons
			//affaire à une pièce jointe
			if ( $partie->ifdisposition && strtolower($partie->disposition) == "attachment" )
			{
				//on récupère le nom et quelques infos
				//qu'on ajoute au tableau de résultats.
				//on suppose la fonction trouverNom qui parourt
				//le tableau parameters jusqu'à trouver le paramètre
				//name, et en retourner la valeur
				if ($partie->ifdparameters) {
					$fichier = array( 'nom' => $this->trouverNom($partie->dparameters),
									  'numero_partie' => $num_partie,
									  'encodage' => $partie->encoding,
									  'taille' => $partie->bytes);
				}
				if ($partie->ifparameters) {
					$fichier = array( 'nom' => $this->trouverNom($partie->parameters),
									  'numero_partie' => $num_partie,
									  'encodage' => $partie->encoding,
									  'taille' => $partie->bytes);
				}
				$retour['fichiers'][] = $fichier;
			}
			else
			{
				switch ($partie->type )
				{
					case TYPETEXT: //	si c'est du texte 
						if ( $alternative) //	et que c'est un texte avec une alternative
						{
							if ($this->sMailFormat == $partie->subtype) //	on fait un test du format à afficher
							{
								$texte = imap_fetchbody( $this->rFlux, $id_msg, $num_partie);
								$retour['message'] = "".nl2br($this->decoder($texte,$partie->encoding))."";
							}
						}
						else //	si c'est pas alternatif, on affiche
						{
							//if(  !empty($partie->parts) )
							//if ($niveau !=0)
							if ($num_partie<>0)
							{
								// on lit le texte à la partie qui nous interesse.
								$texte = imap_fetchbody( $this->rFlux, $id_msg, $num_partie);
								$retour['message'] = "".$this->decoder($texte,$partie->encoding)."";
							}
							else 
							{
								if ($partie->subtype == 'PLAIN') // on lit le texte PLAIN
								{
									$texte = imap_body( $this->rFlux, $id_msg);
									$retour['message'] = "".nl2br($this->decoder($texte,$partie->encoding))."";
								}
								else if($partie->subtype == 'HTML') // on le texte HTML
								{
									$texte = imap_body( $this->rFlux, $id_msg);
									$retour['message'] = "".$this->decoder($texte,$partie->encoding)."";
								}
							}
						}
						break;
						
					case TYPEMULTIPART:// si c'est pas du texte alors on se rappelle
						if ($partie->subtype == "ALTERNATIVE") 
						{
							$alternative = 1;
						}
						//on lit chaque sous parts.
						for ( $i=0;$i<count($partie->parts); $i++)
						{
							if ($niveau != 0 ) 
							{
								$pos = strrpos($num_partie, ".");
								if ($pos === false) { // si on trouve pas de point, on en ajoute un sinon pas : pas de double point
									$num_partie = $num_partie.".";
								}
							}
							else {
								$num_partie = "";
							}
							$this->BodyToArray($id_msg, $num_partie.($i + 1), $partie->parts[$i], 1, $alternative);
						}	
						break;
					/*case TYPEMESSAGE:
					case TYPEAPPLICATION:
					case TYPEAUDIO:
					case TYPEIMAGE:
					case TYPEVIDEO:
					case TYPEMODEL:*/
					default:
						if ($partie->ifdparameters) {
							$fichier = array( 'nom' => $this->trouverNom($partie->dparameters),
											  'numero_partie' => $num_partie,
							    		      'encodage' => $partie->encoding,
								    	      'taille' => $partie->bytes);
						}		
						if ($partie->ifparameters) {
							$fichier = array( 'nom' => $this->trouverNom($partie->parameters),
						         			  'numero_partie' => $num_partie,
								        	  'encodage' => $partie->encoding,
									          'taille' => $partie->bytes);
						}
						$retour['fichiers'][] = $fichier;
						break;
				}
			}			
			return $retour;
		}
		
		
		/*~*~*~*~*~*~*~*~*~*~*~*~*~*/
		/*  2.1 méthodes publiques   */
		/*~*~*~*~*~*~*~*~*~*~*~*~*~*/
				
		/**
		* @name Attach
		* Attache une pièce jointe à l'email
		* 
		* @paramString  : nom du fichier joint
		* @paramString : type du fichier joint
		* @paramString : disposition du fichier joint (attachment | inline)
		*
		* @return Boolean : Vrai.
		*/
		public function Attach( $filename, $filetype='application/x-unknown-content-type', $disposition = "attachment" )
		{
			 $piece['nom'] = $filename;
			 $piece['type'] = $filetype;
			 $piece['dispo'] = $disposition;
			 $this->pieceJointe[] = $piece;
			 return true;
		} 
			
		/**
		* @name Send
		* Envoi l'email aux destinataires
		* 
		*
		* @return void.
		*/
		public function Send()
		{
			// build th headers
			$this->_make_headers();
			$body = "";
			
			 // include attached files
			if( sizeof( $this->pieceJointe > 0 ) ) {
				$this->_make_attachement();
				$body .= $this->entete . $this->message . $this->attachement."--\n";
			}
			else {
				$body .= $this->entete . $this->message . "--\n";
			}
									
			// envoie du mail aux destinataires principal
			for( $i=0; $i< sizeof($this->sendTo); $i++ ) {
				$res = imap_mail($this->sendTo[$i], $this->sujet, '', $body);
			}
		}
		
		/**
		* @name Read
		* Lit le contenu d'un email et assignation à la class
		* 
		* @paramRessource  : flux imap vers la boîte de l'email
		* @paramNumeric : numéro séquentiel de l'email dans la boîte
		*
		* @return Boolean : Vrai.
		*/
		public function Read($rFlux, $id_msg=0) {
			$this->rFlux = $rFlux;
			//lecture des entêtes de l'email
			$entetes = imap_headerinfo($rFlux, $id_msg);
			
			// affectation
			$this->sujet = utf8_decode(imap_utf8($entetes->subject));               // sujet
			$this->de = htmlentities(utf8_decode(imap_utf8($entetes->fromaddress)));// adresse de l'expéditeur
			$this->a = htmlentities(utf8_decode(imap_utf8($entetes->toaddress)));   // adresse du destinataire
			$this->dateEnvoi = strftime("%A, %d %B %Y à %H:%M:%S", $entetes->udate);// date d'envoi
			
			//récupération de la structure du mail
			$struct = imap_fetchstructure($rFlux,$id_msg);
			$email = $this->BodyToArray($id_msg, 0, $struct, 0);
			
			// mise en forme  des liens se trouvant dans le contenu
			$body = $email['message'];
			$start_link = 0;
			$start_link = strpos($body, "http://");
			$stop_link = 0;
			if ($start_link > 0 && $start_link >100) {
				// si on trouve mais pas au début du mail (http://www.w3c.org ...)
				$aFinLink = array('<',')','>',' '); 
				$iLengthBody = (strlen($body)-1);
				for ($i=$start_link; !in_array($body{$i}, $aFinLink) && ($i<$iLengthBody);$i++) {
					$stop_link = $i;
					if ($i == strlen($body)-2) {
						$stop_link = $i+1;
					}
				}
				$adresse = substr($body, $start_link, ($stop_link-$start_link) + 1 );
				$link = "<a href=\"".$adresse."\">".$adresse."</a>";
				$body = str_replace($adresse, $link, $body);
			}
			$this->message = stripslashes($body);                                   // message
			
			//pièces jointes
			if (isset($email['fichiers']) ) {
				$this->pieceJointe = $email['fichiers'];                            // tableau des pièces jointes
			}
		}
	}
	
?>