RedVodkaJelly Logo

PHP Email Class

POSTED AT 15:34 on 23rd May 2008

This is an easy to use PHP Email class making it easy to send emails with attachments in PHP.

It supports:

  • Sending To, CC, BCC.

  • Sending email attachments.

  • Setting email priorities.

  • Sending plain and HTML emails.

This class is by no means complete and if you want more features I suggest you check out PHPMailer.

Source Code

  1. <?php 
  2. /* 
  3. * PHP Email Class 
  4. * 
  5. * Class to deal with sending emails in PHP 
  6. * Makes it easy to send emails in PHP with attachments and such. 
  7. *  
  8. * Written By Jacob Wyke - jacob@redvodkajelly.com - www.redvodkajelly.com 
  9. *  
  10. * LICENSE 
  11. * ——- 
  12. * Feel free to use this as you wish, just give me credit where credits due and drop me an email telling me what your using it for so I can check out all the cool ways its been used. 
  13. * 
  14. * USAGE 
  15. * —– 
  16. * 
  17. *   $objEmail = new RVJ_mail(); 
  18. * 
  19. *   $objEmail->addUser("jacob@redvodkajelly.com"); 
  20. *   $objEmail->setFrom("Frozensheep Ltd <admin@frozensheep.com>"); 
  21. *   $objEmail->setHTML(); 
  22. *   //$objEmail->setPlain(); 
  23. *   $objEmail->setPriority(3); 
  24. *   $objEmail->addReadConfirmationEmail("admin@frozensheep.com"); 
  25. *   $objEmail->addAttachment("logo.gif", ‘logo.gif’, ‘image/gif’); 
  26. *   $objEmail->addAttachment("word.doc", ‘word.doc’, ‘application/msword’); 
  27. *   $objEmail->addAttachment("excel.xls", ‘excel.xls’, ‘application/vnd.ms-excel’); 
  28. *   $objEmail->setSubject("Testing new class"); 
  29. *   $objEmail->setContent("hey <b>dude</b>"); 
  30. *   $objEmail->send(); 
  31. * 
  32. */ 
  33.  
  34. class RVJ_mail { 
  35.     
  36.    var $arrTo = array(); 
  37.    var $arrCC = array(); 
  38.    var $arrBCC = array(); 
  39.    var $strContent = ""; 
  40.    var $strSubject = ""; 
  41.    var $arrHeader = array(); 
  42.    var $arrAttachments = array(); 
  43.    var $numPriority = 3; 
  44.    var $strCharSet = "iso-8859-1"; 
  45.    var $strContentType = "text/plain"; 
  46.    var $strEncoding = "8bit"; 
  47.  
  48.    /* 
  49.    * 
  50.    *   @Method:      addUser 
  51.    *   @Parameters:   1 
  52.    *   @Param-1:      strAddress - String - Holds an email address 
  53.    *   @Description:   Adds a user to send the email to 
  54.    * 
  55.    */     
  56.    function addUser($strAddress){ 
  57.       if($this->emailCheck($strAddress)){             
  58.          $this->arrTo[] = $strAddress; 
  59.          return 1; 
  60.       }else{ 
  61.          return 0; 
  62.       } 
  63.    } 
  64.  
  65.    /* 
  66.    * 
  67.    *   @Method:      removeUser 
  68.    *   @Parameters:   1 
  69.    *   @Param-1:      strAddress - String - Holds an email address 
  70.    *   @Description:   Removes an address from the array 
  71.    * 
  72.    */     
  73.    function removeUser($strAddress){ 
  74.       //create array or arrays to check 
  75.       $arrVars = array(’arrTo’, ‘arrCC’, ‘arrBCC’); 
  76.       foreach($arrVars as $resVars){ 
  77.          //sees if the item exists in the array 
  78.          $numKey = array_search($strAddress, $this->{$resVars}); 
  79.          if(isset($numKey)){ 
  80.             //remove the email address 
  81.             $this->{$resVars}[$numKey] = "";                         
  82.          } 
  83.          unset($numKey); 
  84.       } 
  85.    } 
  86.  
  87.    /* 
  88.    * 
  89.    *   @Method:      addCC 
  90.    *   @Parameters:   1 
  91.    *   @Param-1:      strAddress - String - Holds an email address 
  92.    *   @Description:   Adds a CC user to send to 
  93.    * 
  94.    */        
  95.    function addCC($strAddress){ 
  96.       if($this->emailCheck($strAddress)){    
  97.          $this->arrCC[] = $strAddress; 
  98.          return 1; 
  99.       }else{ 
  100.          return 0; 
  101.       } 
  102.    } 
  103.     
  104.    /* 
  105.    * 
  106.    *   @Method:      addBCC 
  107.    *   @Parameters:   1 
  108.    *   @Param-1:      strAddress - String - Holds an email address 
  109.    *   @Description:   Adds a BCC user to send to 
  110.    * 
  111.    */     
  112.    function addBCC($strAddress){ 
  113.       if($this->emailCheck($strAddress)){ 
  114.          $this->arrBCC[] = $strAddress; 
  115.          return 1; 
  116.       }else{ 
  117.          return 0; 
  118.       } 
  119.    } 
  120.  
  121.    /* 
  122.    * 
  123.    *   @Method:      addReplyTo 
  124.    *   @Parameters:   1 
  125.    *   @Param-1:      strEmail - String - Holds the reply-to email address 
  126.    *   @Description:   Adds a reply-to email address 
  127.    * 
  128.    */     
  129.    function addReplyTo($strEmail){ 
  130.       if($this->emailCheck($strEmail)){ 
  131.          $this->addHeader("Reply-to: $strEmail"); 
  132.       } 
  133.    } 
  134.  
  135.  
  136.    /* 
  137.    * 
  138.    *   @Method:      setContent 
  139.    *   @Parameters:   1 
  140.    *   @Param-1:      strText - String - Holds the email content 
  141.    *   @Description:   Adds the content of the email 
  142.    * 
  143.    */     
  144.    function setContent($strText){ 
  145.       $this->strContent = $strText; 
  146.    } 
  147.  
  148.    /* 
  149.    * 
  150.    *   @Method:      setSubject 
  151.    *   @Parameters:   1 
  152.    *   @Param-1:      strText - String - Holds the email subject 
  153.    *   @Description:   Adds the email subject 
  154.    * 
  155.    */        
  156.    function setSubject($strText){ 
  157.       $this->strSubject = $strText; 
  158.    } 
  159.  
  160.    /* 
  161.    * 
  162.    *   @Method:      setFrom 
  163.    *   @Parameters:   1 
  164.    *   @Param-1:      strText - String - Holds the details of who the email is from 
  165.    *   @Description:   Adds the sender info to the headers 
  166.    * 
  167.    */        
  168.    function setFrom($strText){ 
  169.       $this->addHeader("From: $strText"); 
  170.    } 
  171.  
  172.    /* 
  173.    * 
  174.    *   @Method:      setHTML 
  175.    *   @Parameters:   0 
  176.    *   @Description:   Sets the email to allow html 
  177.    * 
  178.    */        
  179.    function setHTML(){    
  180.       $this->strContentType = "text/html";    
  181.    } 
  182.  
  183.    /* 
  184.    * 
  185.    *   @Method:      setPlain 
  186.    *   @Parameters:   0 
  187.    *   @Description:   Sets the email to plain text 
  188.    * 
  189.    */        
  190.    function setPlain(){    
  191.       $this->strContentType = "text/plain";       
  192.    } 
  193.  
  194.    /* 
  195.    * 
  196.    *   @Method:      setPriority 
  197.    *   @Parameters:   1 
  198.    *   @Param-1:      numPriority - Number - The email priority 
  199.    *   @Description:   Sets the email priority from 1 - Urgent to 5 - not so 
  200.    * 
  201.    */        
  202.    function setPriority($numPriority){ 
  203.       $this->numPriority = $numPriority; 
  204.    }    
  205.  
  206.    /* 
  207.    * 
  208.    *   @Method:      addReadConfirmationEmail 
  209.    *   @Parameters:   1 
  210.    *   @Param-1:      strEmail - String - Email address to send read confirmation to 
  211.    *   @Description:   Ensures that a confirmation email is sent when read 
  212.    * 
  213.    */        
  214.    function addReadConfirmationEmail($strEmail){ 
  215.       if($this->emailCheck($strEmail)){ 
  216.          $this->addHeader("Disposition-Notification-To: <$strEmail>"); 
  217.       } 
  218.    } 
  219.     
  220.    /* 
  221.    * 
  222.    *   @Method:      addHeader 
  223.    *   @Parameters:   1 
  224.    *   @Param-1:      strText - String - Holds the header details 
  225.    *   @Description:   Adds the header details 
  226.    * 
  227.    */        
  228.    function addHeader($strText){ 
  229.       $this->arrHeader[] = $strText; 
  230.    } 
  231.  
  232.    /* 
  233.    * 
  234.    *   @Method:      addAttachment 
  235.    *   @Parameters:   3 
  236.    *   @Param-1:      strFile - String - The file that you want to attach 
  237.    *   @Param-1:      strName - String - The name of the attachment you want displayed 
  238.    *   @Param-1:      strType - String - The MIME type of the file 
  239.    *   @Description:   Adds an attachment to be sent with the email 
  240.    * 
  241.    */        
  242.    function addAttachment($strFile, $strName, $strType){ 
  243.       //check to make sure the file exists 
  244.       if(file_exists($strFile)){ 
  245.          $this->arrAttachments[] = array(’path’ => $strFile, ‘name’ => $strName, ‘type’ => $strType); 
  246.       } 
  247.    } 
  248.     
  249.    /* 
  250.    * 
  251.    *   @Method:      send 
  252.    *   @Parameters:   0 
  253.    *   @Description:   Sends the email to all the required people 
  254.    * 
  255.    */     
  256.    function send(){ 
  257.       //get all the emails in a string to use 
  258.       $strTo = implode(", ", $this->arrTo); 
  259.        
  260.       //add any CC addresses if needed 
  261.       if($this->arrCC){ 
  262.          $this->addHeader("Cc: ".implode(", ", $this->arrCC)); 
  263.       } 
  264.  
  265.       //add any BCC addresses if needed 
  266.       if($this->arrBCC){ 
  267.          $this->addHeader("Bcc: ".implode(", ", $this->arrBCC)); 
  268.       } 
  269.        
  270.       //append any attachments to the end of the content 
  271.       if(count($this->arrAttachments)){ 
  272.          $this->appendAttachments(); 
  273.       } 
  274.        
  275.       //add the additional headers 
  276.       $this->addAdditionalHeaders(); 
  277.        
  278.       //implode the headers as they need to be in a single string 
  279.       $strHeader = implode("\r\n", $this->arrHeader); 
  280.        
  281.       //send the email 
  282.       mail($strTo, $this->strSubject, $this->strContent, $strHeader); 
  283.    } 
  284.  
  285.    /* 
  286.    * 
  287.    *   @Method:      appendAttachments 
  288.    *   @Parameters:   0 
  289.    *   @Description:   Appends any attachments to the end of the email content 
  290.    * 
  291.    */     
  292.    function appendAttachments(){ 
  293.       //create a unique boundary value 
  294.       $strBoundary = "H2O-".time(); 
  295.        
  296.       //add the boundary to the headers 
  297.       $this->addHeader("Content-Type: multipart/alternitive; boundary=$strBoundary"); 
  298.        
  299.       //if there is content to the email already we need to add the boundary and content type 
  300.       if($this->strContent){ 
  301.          $strContent = "–$strBoundary\r\n"; 
  302.          $strContent .= "Content-Transfer-Encoding: {$this->strEncoding}\r\n"; 
  303.          $strContent .= "Content-type: {$this->strContentType}; charset={$this->strCharSet}\r\n\r\n"; 
  304.           
  305.          $this->strContent = $strContent.$this->strContent."\r\n\r\n\r\n"; 
  306.       } 
  307.        
  308.       //loop through all the attachments 
  309.       foreach($this->arrAttachments as $arrFile){ 
  310.          //read the content of the file into a string and base64 encode and split into the correct chunk size 
  311.          $strData = chunk_split(base64_encode(implode("", file($arrFile['path'])))); 
  312.           
  313.          //add the attachments       
  314.          $strAttachment = "–$strBoundary\r\n"; 
  315.          $strAttachment .= "Content-Transfer-Encoding: base64\r\n"; 
  316.          $strAttachment .= "Content-Type: {$arrFile['type']}; name={$arrFile['name']}\r\n"; 
  317.          $strAttachment .= "Content-Disposition: attachment; filename={$arrFile['name']}\r\n\r\n"; 
  318.          $strAttachment .= "$strData\r\n"; 
  319.           
  320.          //add the attachment to the email content 
  321.          $this->strContent .= $strAttachment; 
  322.           
  323.          unset($strAttachment); 
  324.       } 
  325.        
  326.       //add the closing boundary    
  327.       $this->strContent .= "–$strBoundary–"; 
  328.    } 
  329.  
  330.    /* 
  331.    * 
  332.    *   @Method:      addAdditionalHeaders 
  333.    *   @Parameters:   0 
  334.    *   @Description:   Adds additional headers for content type and priority etc 
  335.    * 
  336.    */     
  337.    function addAdditionalHeaders(){ 
  338.       $this->addHeader("MIME-Version: 1.0"); 
  339.        
  340.       //add the content type and charset if there are no attachments 
  341.       if(!count($this->arrAttachments)){ 
  342.          $this->addHeader("Content-type: {$this->strContentType}; charset={$this->strCharSet}");       
  343.       } 
  344.        
  345.       //add the priority 
  346.       $this->addHeader("X-Priority: $this->numPriority");    
  347.    } 
  348.     
  349.    /* 
  350.    * 
  351.    *   @Method:      emailCheck 
  352.    *   @Parameters:   1 
  353.    *   @Param-1:      strAddress - String - Holds an email address 
  354.    *   @Description:   Checks to ensure that the email address is valid 
  355.    * 
  356.    */        
  357.    function emailCheck($strAddress){ 
  358.       if(ereg("^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$", $strAddress)){ 
  359.          return 1; 
  360.       }else{ 
  361.          return 0; 
  362.       } 
  363.    } 
  364. } 
  365.  
  366. ?>