User:Acook

From MediaWiki.org
Jump to: navigation, search

Welcome to my userpage.


I will finish my extension later - I didn't want to save the page yet, below is the rough draft.



MediaWiki extensions manual - list
Crystal Clear action run.png
EmailUsers

Release status: beta

Implementation Special page
Description Easily email registered users or groups of users of your Wiki.
Author(s) Andy Cook (AcookTalk)
Last version 0.0.1
MediaWiki 1.8.0+
License No license specified
Download No link

Contents

[edit] What can this extension do?

[edit] Usage

[edit] Download instructions

Please cut and paste the code found below and place it in $IP/extension/EmailUsers/EmailUsers.php. Note: $IP stands for the root directory of your MediaWiki installation, the same directory that holds LocalSettings.php.

[edit] Installation

To install this extension, add the following to LocalSettings.php:

#add configuration parameters here
#setup user rights here
include ("$IP/extensions/EmailUsers/EmailUsers.php");

[edit] Configuration parameters

[edit] User rights

[edit] Code

Copy and paste this into EmailUsers.php and place it in your EmailUsers folder.

<?php
# Extension:EmailUsers
# - Licenced under LGPL (http://www.gnu.org/copyleft/lesser.html)
# - Started: 2007-10-16 (based on EmailArticle (http://www.organicdesign.co.nz/Extension:EmailArticle.php))
# - IF YOU WOULD LIKE TO TAKE THE TIME TO CLEAN IT UP, PLEASE EMAIL ME (There's a lot left over from EmailArticle.php)
 
if (!defined('MEDIAWIKI')) die('Not an entry point.');
 
 
 
$wgEmailUsersGroup           = 'sysop';            # Users must belong to this group to send emails (empty string means anyone can send)
$wgEmailUsersAllowRemoteAddr = array($_SERVER['SERVER_ADDR'],'127.0.0.1'); # Allow anonymous sending from these addresses
$wgEmailUsersAllowAllUsers   = true;              # Whether to allow sending to all users (the "user" group)
$wgPhpMailerClass              = dirname(__FILE__).'/class.phpmailer.php'; # From http://phpmailer.sourceforge.net/
 
if ($wgEmailUsersGroup) $wgGroupPermissions['sysop'][$wgEmailUsersGroup] = true;
 
$wgExtensionFunctions[] = 'wfSetupEmailUsers';
 
 
$wgExtensionCredits['specialpage'][] = array(
        'name'        => 'Email Users',
        'author'      => 'Andy Cook',
        'description' => 'Send a mass email to users or groups of your Wiki',
        'url'         => 'http://cookandy.com/2007/10/16/yet-another-mediawiki-extension-email-users/',
        'version'     => '0.0.1 (very, very, beta)'
        );
 
 
 
# If form has been posted, include the phpmailer class
if (isset($_REQUEST['ea_send'])) require_once($wgPhpMailerClass);
 
 
 
# Define a new class based on the SpecialPage class
require_once("$IP/includes/SpecialPage.php");
class SpecialEmailUsers extends SpecialPage {
 
        var $recipients = array();
        var $title;
        var $subject;
        var $header;
        var $cat;
        var $group;
        var $list;
        var $textonly;
 
 
# Constructor
 function SpecialEmailUsers() {
                global $wgEmailUsersGroup;
              global $wgMessageCache;
              $wgMessageCache->addMessages(array('emailusers' => 'Email Users')); 
                SpecialPage::SpecialPage('EmailUsers',$wgEmailUsersGroup);
                }
 
 
        # Override SpecialPage::execute($param = '')
 function execute($param) {
                global $wgOut,$wgUser,$wgGroupPermissions,$wgSitename,$wgEmailUsersAllowAllUsers;
                $db =& wfGetDB(DB_SLAVE);
                $param = str_replace('_',' ',$param);
                $this->setHeaders();
 
                # Get info from request or set to defaults
         $this->title    = isset($_REQUEST['ea_title'])    ? $_REQUEST['ea_title']    : '$param';
                $this->subject  = isset($_REQUEST['ea_subject'])  ? $_REQUEST['ea_subject']  : '';
                $this->header   = isset($_REQUEST['ea_header'])   ? $_REQUEST['ea_header']   : '';
                $this->cat      = isset($_REQUEST['ea_cat'])      ? $_REQUEST['ea_cat']      : '';
                $this->group    = isset($_REQUEST['ea_group'])    ? $_REQUEST['ea_group']    : '';
                $this->list     = isset($_REQUEST['ea_list'])     ? $_REQUEST['ea_list']     : '';
                $this->textonly = isset($_REQUEST['ea_textonly']) ? $_REQUEST['ea_textonly'] : false;
 
 
                # Bail if no article title to send has been specified
         if ($this->title) $wgOut->addWikiText(wfMsg('ea_heading',$this->title));
 
 
                # If the send button was clicked, attempt to send and exit
         if (isset($_REQUEST['ea_send'])) return $this->send();
 
                # Render form
         $special = Title::makeTitle(NS_SPECIAL,'EmailUsers');
                $wgOut->addHTML(wfElement('form',array(
                        'class'  => 'EmailUsers',
                        'action' => $special->getLocalURL('action=submit'),
                        'method' => 'POST'
                        ),null));
                $wgOut->addHTML('<fieldset><legend>'.wfMsg('ea_selectrecipients').'</legend>');
                $wgOut->addHTML('<table style="padding:0;margin:0;border:none;">');
 
 
                # Allow selection of a group
         $groups = '<option/>';
                foreach (array_keys($wgGroupPermissions) as $group) if ($group != '*') {
                        $selected = $group == $this->group ? ' selected' : '';
                        if ($wgEmailUsersAllowAllUsers || $group != 'user') $groups .= "<option$selected>$group</option>";
                        }
                $wgOut->addHTML("<tr><td>From group:</td><td><select name=\"ea_group\">$groups</select></td></tr>\n");
                $wgOut->addHTML('</table>');
 
                # Addition of named list
         $wgOut->addWikiText(wfMsg('ea_selectlist'));
                $wgOut->addHTML("<textarea name=\"ea_list\" rows=\"2\">{$this->list}</textarea><br />\n");
                $wgOut->addHTML('</fieldset>');
 
                $wgOut->addHTML('<fieldset><legend>'.wfMsg('ea_compose').'</legend>');
 
                # Subject
         $wgOut->addWikiText(wfMsg('ea_subject'));
                $wgOut->addHTML(wfElement('input',array('type' => 'text', 'name' => 'ea_subject', 'value' => $this->subject, 'style' => "width:100%")));
 
                # Header
         $wgOut->addWikiText(wfMsg('ea_header'));
                $wgOut->addHTML("<textarea name=\"ea_header\" rows=\"30\">{$this->header}</textarea><br />\n");
 
 
 
                $wgOut->addHTML("</fieldset>");
 
                # Submit buttons & hidden values
         $wgOut->addHTML(wfElement('input',array('type' => 'submit','name' => 'ea_send', 'value' => wfMsg('ea_send'))));
                $wgOut->addHTML(wfElement('input',array('type' => 'submit','name' => 'ea_show', 'value' => wfMsg('ea_show'))));
                $wgOut->addHTML(wfElement('input',array('type' => 'hidden','name' => 'ea_title','value' => $this->title)));
 
                $wgOut->addHTML('</form>');
 
                # If the show button was clicked, render the list
         if (isset($_REQUEST['ea_show'])) return $this->send(false);
                }
 
 
        # Send the message to the recipients (or just list them if arg = false)
 function send($send = true) {
                global $wgOut,$wgUser,$wgParser,$wgServer,$wgScript,$wgArticlePath,$wgScriptPath,
                        $wgEmailUsersGroup,$wgEmailUsersAllowRemoteAddr,$wgEmailUsersAllowAllUsers;
 
                # Set error and bail if user not in postmaster group, and request not from trusted address
         if ($wgEmailUsersGroup && !in_array($wgEmailUsersGroup,$wgUser->getGroups()) && !in_array($_SERVER['REMOTE_ADDR'],$wgEmailUsersAllowRemoteAddr)) {
                        $wgOut->addWikiText(wfMsg('ea_error',$this->title,'Permission denied'));
                        return false;
                        }
 
                $db       = &wfGetDB(DB_SLAVE);
                $title    = Title::newFromText($this->title);
                $opt      = new ParserOptions;
 
                # Get contact article titles from selected cat
         if ($this->cat) {
                        $cl     = $db->tableName('categorylinks');
                        $result = $db->query("SELECT cl_from FROM $cl WHERE cl_to = '{$this->cat}' ORDER BY cl_sortkey");
                        while ($row = mysql_fetch_row($result)) $this->addRecipient(Title::newFromID($row[0]));
                        }
 
                # Get email addresses from users in selected group
         if ($this->group && ($wgEmailUsersAllowAllUsers || $this->group != 'user')) {
                        $u  = str_replace('`','',$db->tableName('user'));
                        $ug = str_replace('`','',$db->tableName('user_groups'));
                        if ($this->group == 'user') $sql = "SELECT user_email FROM $u WHERE user_email != ''";
                        else $sql = "SELECT $u.user_email FROM $u,$ug WHERE $ug.ug_user = $u.user_id AND $ug.ug_group = '{$this->group}'";
                        $result = $db->query($sql);
                        if ($result instanceof ResultWrapper) $result = $result->result;
                        while ($row = $db->fetchRow($result)) $this->addRecipient($row[0]);
                        }
 
                # Recipients from list (expand templates in wikitext)
         $list = $wgParser->preprocess($this->list,$title,$opt);
                foreach (preg_split("/[\\x00-\\x1f,;*]+/",$list) as $item) $this->addRecipient($item);
 
                # Compose the wikitext content of the article to send

                if ($this->header) $message = "{$this->header}\n\n$message";
 
                # Convert the message text to html unless textonly
         if ($this->textonly == '') {
 
                        # Parse the wikitext using absolute URL's for local article links
                 $tmp           = array($wgArticlePath,$wgScriptPath,$wgScript);
                        $wgArticlePath = $wgServer.$wgArticlePath;
                        $wgScriptPath  = $wgServer.$wgScriptPath;
                       $wgScript      = $wgServer.$wgScript;
                        $message       = $wgParser->parse($message,$title,$opt,true,true)->getText();
                        list($wgArticlePath,$wgScriptPath,$wgScript) = $tmp;
 
 
 
                        # Create a html wrapper for the message
                 $head    = "<head></head>";
                        $message = "<html>$head<body style=\"margin:10px\"><div id=\"#bodyContent\">$message</div></body></html>";
 
                        }
 
                # Send message or list recipients
         $count = count($this->recipients);
                if ($count > 0) {
 
                        # Set up new mailer instance if sending
                 if ($send) {
                                $mail           = new PHPMailer();
                                $mail->From     = $wgUser->isValidEmailAddr($wgUser->getEmail()) ? $wgUser->getEmail() : "wiki@$wgServer";
                                $mail->FromName = User::whoIsReal($wgUser->getId());
                                $mail->Subject  = $this->subject;
                                $mail->Body     = $message;
                                $mail->IsHTML(!$this->textonly);
                                }
                        else $msg = wfMsg('ea_listrecipients',$count);
 
                        # Loop through recipients sending or adding to list
                 foreach ($this->recipients as $recipient) $send ? $mail->AddAddress($recipient) : $msg .= "\n*[mailto:$recipient $recipient]";
 
                        if ($send) {
                                if ($state = $mail->Send()) $msg = wfMsg('ea_sent',$this->title,$count,$wgUser->getName());
                                else $msg = wfMsg('ea_error',$this->title,$mail->ErrorInfo);
                                }
                        else $state = $count;
                        }
                else $msg = wfMsg('ea_error',$this->title,wfMsg('ea_norecipients'));
 
                $wgOut->addWikiText($msg);
                return $state;
                }
 
        # Add a recipient the list
 # - accepts title objects for article containing email address, or string of actual address
 function addRecipient($recipient) {
                if (is_object($recipient) && $recipient->exists()) {
                        $article = new Article($recipient);
                        if (preg_match('/[a-z0-9_.-]+@[a-z0-9_.-]+/i',$article->getContent(),$emails)) $recipient = $emails[0];
                        else $recipient = '';
                        }
                if ($valid = User::isValidEmailAddr($recipient)) $this->recipients[] = $recipient;
                return $valid;
                }
 
        }
 
# Called from $wgExtensionFunctions array when initialising extensions
function wfSetupEmailUsers() {
        global $wgLanguageCode,$wgMessageCache;
 
        # Add the messages used by the specialpage
 if ($wgLanguageCode == 'en') {
                $wgMessageCache->addMessages(array(
                        'EmailUsers'        => "EmailUsers",
                        'ea_heading'          => "=== Send an email to users of your Wiki. ===\nUse the form below to send a mass email to selected users or groups.",
                        'ea_norecipients'     => "No valid email addresses found!",
                        'ea_listrecipients'   => "=== List of $1 recipients ===",
                        'ea_error'            => "'''Error sending email:''' ''$2''",
                        'ea_sent'             => "Your email has successfully been sent to '''$2''' recipient(s).<br><br>[[Special:EmailUsers|Send another email]] or return to the [[Main_Page|Main Page]].",
                        'ea_selectrecipients' => "Select recipients",
                        'ea_compose'          => "Compose content",
                        'ea_selectlist'       => "Send to additional recipients\n"
                                               . "*''separate email addresses with a semicolon (;)  '''No Spaces'''",
                        'ea_show'             => "Show recipients",
                        'ea_send'             => "Send!",
                        'ea_subject'          => "Enter a subject line for the email (HTML allowed)",
                        'ea_header'           => "Body of your email",
                        ));
                }
 
        # Add the specialpage to the environment
 SpecialPage::addPage(new SpecialEmailUsers());
        }
?>

Copy and paste this into class.phpmailer.php and place it in your EmailUsers folder.

<?
// PHPMailer - PHP email class
// Source: http://phpmailer.sourceforge.net
// Class for sending email using either
// sendmail, PHP mail(), or SMTP.  Methods are
// based upon the standard AspEmail(tm) classes.
//
// Copyright (C) 2001 - 2003  Brent R. Matzelle
//
// License: LGPL, see LICENSE
 
/**
 * PHPMailer - PHP email transport class
 * @package PHPMailer
 * @author Brent R. Matzelle
 * @copyright 2001 - 2003 Brent R. Matzelle
 */
class PHPMailer
{
        var $Priority         = 3;
        var $CharSet          = "utf-8"; 
        var $ContentType              = "html"; 
        var $Encoding         = "7bit";
        var $ErrorInfo                = "";
        var $From                     = "root@localhost";
        var $FromName         = "Root User";
        var $Sender                   = "";
        var $Subject          = "";
        var $Body                     = "";
        var $AltBody          = "";
        var $WordWrap         = 0;
        var $Mailer                   = "sendmail";
        var $Sendmail         = "/usr/sbin/sendmail";
        var $PluginDir                = "";
        var $Version          = "1.73";
        var $ConfirmReadingTo  = "";
        var $Hostname         = "";
 
        /**#@+
        * @access private
        */
        var $smtp                     = NULL;
        var $to                       = array();
        var $cc                       = array();
        var $bcc                      = array();
        var $ReplyTo          = array();
        var $attachment       = array();
        var $CustomHeader     = array();
        var $message_type     = "";
        var $boundary         = array();
        var $language         = array();
        var $error_count      = 0;
        var $LE                       = "\n";
        /**#@-*/
 
        /////////////////////////////////////////////////
        // VARIABLE METHODS
        /////////////////////////////////////////////////
 
        /**
        * Sets message type to HTML.  
        * @param bool $bool
        * @return void
        */
        function IsHTML($bool) {
                if($bool == true)
                        $this->ContentType = "text/html";
                else
                        $this->ContentType = "text/plain";
        }
 
        /**
        * Sets Mailer to send message using SMTP.
        * @return void
        */
        function IsSMTP() {
                $this->Mailer = "smtp";
        }
 
        /**
        * Sets Mailer to send message using PHP mail() function.
        * @return void
        */
        function IsMail() {
                $this->Mailer = "mail";
        }
 
        /**
        * Sets Mailer to send message using the $Sendmail program.
        * @return void
        */
        function IsSendmail() {
                $this->Mailer = "sendmail";
        }
 
        /**
        * Sets Mailer to send message using the qmail MTA. 
        * @return void
        */
        function IsQmail() {
                $this->Sendmail = "/var/qmail/bin/sendmail";
                $this->Mailer = "sendmail";
        }
 
 
        /////////////////////////////////////////////////
        // RECIPIENT METHODS
        /////////////////////////////////////////////////
 
        /**
        * Adds a "To" address.  
        * @param string $address
        * @param string $name
        * @return void
        */
        function AddAddress($address, $name = "") {
                $cur = count($this->to);
                $this->to[$cur][0] = trim($address);
                $this->to[$cur][1] = $name;
        }
 
        /**
        * Adds a "Cc" address. Note: this function works
        * with the SMTP mailer on win32, not with the "mail"
        * mailer.  
        * @param string $address
        * @param string $name
        * @return void
        */
        function AddCC($address, $name = "") {
                $cur = count($this->cc);
                $this->cc[$cur][0] = trim($address);
                $this->cc[$cur][1] = $name;
        }
 
        /**
        * Adds a "Bcc" address. Note: this function works
        * with the SMTP mailer on win32, not with the "mail"
        * mailer.  
        * @param string $address
        * @param string $name
        * @return void
        */
        function AddBCC($address, $name = "") {
                $cur = count($this->bcc);
                $this->bcc[$cur][0] = trim($address);
                $this->bcc[$cur][1] = $name;
        }
 
        /**
        * Adds a "Reply-to" address.  
        * @param string $address
        * @param string $name
        * @return void
        */
        function AddReplyTo($address, $name = "") {
                $cur = count($this->ReplyTo);
                $this->ReplyTo[$cur][0] = trim($address);
                $this->ReplyTo[$cur][1] = $name;
        }
 
 
        /////////////////////////////////////////////////
        // MAIL SENDING METHODS
        /////////////////////////////////////////////////
 
        /**
        * Creates message and assigns Mailer. If the message is
        * not sent successfully then it returns false.  Use the ErrorInfo
        * variable to view description of the error.  
        * @return bool
        */
        function Send() {
                $header = "";
                $body = "";
                $result = true;
 
                if((count($this->to) + count($this->cc) + count($this->bcc)) < 1)
                {
                        $this->SetError($this->Lang("provide_address"));
                        return false;
                }
 
                // Set whether the message is multipart/alternative
                if(!empty($this->AltBody))
                        $this->ContentType = "multipart/alternative";
 
                $this->error_count = 0; // reset errors
                $this->SetMessageType();
                $header .= $this->CreateHeader();
                $body = $this->CreateBody();
                if (!$body) return;
 
                # Send using mail()
         $to = "";
                for($i = 0; $i < count($this->to); $i++)
                {
                        if($i != 0) { $to .= ", "; }
                        $to .= $this->to[$i][0];
                }
 
                if ($this->Sender != "" && strlen(ini_get("safe_mode"))< 1)
                {
                        $old_from = ini_get("sendmail_from");
                        ini_set("sendmail_from", $this->Sender);
                        $params = sprintf("-oi -f %s", $this->Sender);
                        $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, 
                                                $header, $params);
                }
                else
                        $rt = @mail($to, $this->EncodeHeader($this->Subject), $body, $header);
 
                if (isset($old_from))
                        ini_set("sendmail_from", $old_from);
 
                if(!$rt)
                {
                        $this->SetError($this->Lang("instantiate"));
                        return false;
                }
 
                return true;
        }
 
        # Sets the language for all class error messages.  Returns false 
 function SetLanguage($lang_type, $lang_path = "language/") {
                $PHPMAILER_LANG = array();
                $PHPMAILER_LANG["provide_address"] = 'You must provide at least one recipient email address.';
                $PHPMAILER_LANG["mailer_not_supported"] = ' mailer is not supported.';
                $PHPMAILER_LANG["execute"] = 'Could not execute: ';
                $PHPMAILER_LANG["instantiate"] = 'Could not instantiate mail function.';
                $PHPMAILER_LANG["authenticate"] = 'SMTP Error: Could not authenticate.';
                $PHPMAILER_LANG["from_failed"] = 'The following From address failed: ';
                $PHPMAILER_LANG["recipients_failed"] = 'SMTP Error: The following recipients failed: ';
                $PHPMAILER_LANG["data_not_accepted"] = 'SMTP Error: Data not accepted.';
                $PHPMAILER_LANG["connect_host"] = 'SMTP Error: Could not connect to SMTP host.';
                $PHPMAILER_LANG["file_access"] = 'Could not access file: ';
                $PHPMAILER_LANG["file_open"] = 'File Error: Could not open file: ';
                $PHPMAILER_LANG["encoding"] = 'Unknown encoding: ';
                $this->language = $PHPMAILER_LANG;
                return true;
        }
 
        /////////////////////////////////////////////////
        // MESSAGE CREATION METHODS
        /////////////////////////////////////////////////
 
        /**
        * Creates recipient headers.  
        * @access private
        * @return string
        */
        function AddrAppend($type, $addr) {
                $addr_str = $type . ": ";
                $addr_str .= $this->AddrFormat($addr[0]);
                if(count($addr) > 1)
                {
                        for($i = 1; $i < count($addr); $i++)
                                $addr_str .= ", " . $this->AddrFormat($addr[$i]);
                }
                $addr_str .= $this->LE;
 
                return $addr_str;
        }
 
        /**
        * Formats an address correctly. 
        * @access private
        * @return string
        */
        function AddrFormat($addr) {
                if(empty($addr[1]))
                        $formatted = $addr[0];
                else
                {
                        $formatted = $this->EncodeHeader($addr[1], 'phrase') . " <" . 
                                                $addr[0] . ">";
                }
 
                return $formatted;
        }
 
        /**
        * Wraps message for use with mailers that do not
        * automatically perform wrapping and for quoted-printable.
        * Original written by philippe.  
        * @access private
        * @return string
        */
        function WrapText($message, $length, $qp_mode = false) {
                $soft_break = ($qp_mode) ? sprintf(" =%s", $this->LE) : $this->LE;
 
                $message = $this->FixEOL($message);
                if (substr($message, -1) == $this->LE)
                        $message = substr($message, 0, -1);
 
                $line = explode($this->LE, $message);
                $message = "";
                for ($i=0 ;$i < count($line); $i++)
                {
                $line_part = explode(" ", $line[$i]);
                $buf = "";
                for ($e = 0; $e<count($line_part); $e++)
                {
                        $word = $line_part[$e];
                        if ($qp_mode and (strlen($word) > $length))
                        {
                                $space_left = $length - strlen($buf) - 1;
                                if ($e != 0)
                                {
                                        if ($space_left > 20)
                                        {
                                                $len = $space_left;
                                                if (substr($word, $len - 1, 1) == "=")
                                                $len--;
                                                elseif (substr($word, $len - 2, 1) == "=")
                                                $len -= 2;
                                                $part = substr($word, 0, $len);
                                                $word = substr($word, $len);
                                                $buf .= " " . $part;
                                                $message .= $buf . sprintf("=%s", $this->LE);
                                        }
                                        else
                                        {
                                                $message .= $buf . $soft_break;
                                        }
                                        $buf = "";
                                }
                                while (strlen($word) > 0)
                                {
                                        $len = $length;
                                        if (substr($word, $len - 1, 1) == "=")
                                                $len--;
                                        elseif (substr($word, $len - 2, 1) == "=")
                                                $len -= 2;
                                        $part = substr($word, 0, $len);
                                        $word = substr($word, $len);
 
                                        if (strlen($word) > 0)
                                                $message .= $part . sprintf("=%s", $this->LE);
                                        else
                                                $buf = $part;
                                }
                        }
                        else
                        {
                                $buf_o = $buf;
                                $buf .= ($e == 0) ? $word : (" " . $word); 
 
                                if (strlen($buf) > $length and $buf_o != "")
                                {
                                        $message .= $buf_o . $soft_break;
                                        $buf = $word;
                                }
                        }
                }
                $message .= $buf . $this->LE;
                }
 
                return $message;
        }
 
        /**
        * Set the body wrapping.
        * @access private
        * @return void
        */
        function SetWordWrap() {
                if($this->WordWrap < 1)
                        return;
 
                switch($this->message_type)
                {
                case "alt":
                        // fall through
                case "alt_attachments":
                        $this->AltBody = $this->WrapText($this->AltBody, $this->WordWrap);
                        break;
                default:
                        $this->Body = $this->WrapText($this->Body, $this->WordWrap);
                        break;
                }
        }
 
        /**
        * Assembles message header.  
        * @access private
        * @return string
        */
        function CreateHeader() {
                $result = "";
 
                // Set the boundaries
                $uniq_id = md5(uniqid(time()));
                $this->boundary[1] = "b1_" . $uniq_id;
                $this->boundary[2] = "b2_" . $uniq_id;
 
                $result .= $this->HeaderLine("Date", $this->RFCDate());
                if($this->Sender == "")
                        $result .= $this->HeaderLine("Return-Path", trim($this->From));
                else
                        $result .= $this->HeaderLine("Return-Path", trim($this->Sender));
 
                // To be created automatically by mail()
                if($this->Mailer != "mail")
                {
                        if(count($this->to) > 0)
                                $result .= $this->AddrAppend("To", $this->to);
                        else if (count($this->cc) == 0)
                                $result .= $this->HeaderLine("To", "undisclosed-recipients:;");
                        if(count($this->cc) > 0)
                                $result .= $this->AddrAppend("Cc", $this->cc);
                }
 
                $from = array();
                $from[0][0] = trim($this->From);
                $from[0][1] = $this->FromName;
                $result .= $this->AddrAppend("From", $from); 
 
                // sendmail and mail() extract Bcc from the header before sending
                if((($this->Mailer == "sendmail") || ($this->Mailer == "mail")) && (count($this->bcc) > 0))
                        $result .= $this->AddrAppend("Bcc", $this->bcc);
 
                if(count($this->ReplyTo) > 0)
                        $result .= $this->AddrAppend("Reply-to", $this->ReplyTo);
 
                // mail() sets the subject itself
                if($this->Mailer != "mail")
                        $result .= $this->HeaderLine("Subject", $this->EncodeHeader(trim($this->Subject)));
 
                $result .= sprintf("Message-ID: <%s@%s>%s", $uniq_id, $this->ServerHostname(), $this->LE);
                $result .= $this->HeaderLine("X-Priority", $this->Priority);
                $result .= $this->HeaderLine("X-Mailer", "PHPMailer [version " . $this->Version . "]");
 
                if($this->ConfirmReadingTo != "")
                {
                        $result .= $this->HeaderLine("Disposition-Notification-To", 
                                        "<" . trim($this->ConfirmReadingTo) . ">");
                }
 
                // Add custom headers
                for($index = 0; $index < count($this->CustomHeader); $index++)
                {
                        $result .= $this->HeaderLine(trim($this->CustomHeader[$index][0]), 
                                        $this->EncodeHeader(trim($this->CustomHeader[$index][1])));
                }
                $result .= $this->HeaderLine("MIME-Version", "1.0");
 
                switch($this->message_type)
                {
                        case "plain":
                                $result .= $this->HeaderLine("Content-Transfer-Encoding", $this->Encoding);
                                $result .= sprintf("Content-Type: %s; charset=\"%s\"",
                                                                        $this->ContentType, $this->CharSet);
                                break;
                        case "attachments":
                                // fall through
                        case "alt_attachments":
                                if($this->InlineImageExists())
                                {
                                        $result .= sprintf("Content-Type: %s;%s\ttype=\"text/html\";%s\tboundary=\"%s\"%s", 
                                                                        "multipart/related", $this->LE, $this->LE, 
                                                                        $this->boundary[1], $this->LE);
                                }
                                else
                                {
                                        $result .= $this->HeaderLine("Content-Type", "multipart/mixed;");
                                        $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
                                }
                                break;
                        case "alt":
                                $result .= $this->HeaderLine("Content-Type", "multipart/alternative;");
                                $result .= $this->TextLine("\tboundary=\"" . $this->boundary[1] . '"');
                                break;
                }
 
                if($this->Mailer != "mail")
                        $result .= $this->LE.$this->LE;
 
                return $result;
        }
 
        /**
        * Assembles the message body.  Returns an empty string on failure.
        * @access private
        * @return string
        */
        function CreateBody() {
                $result = "";
 
                $this->SetWordWrap();
 
                switch($this->message_type)
                {
                        case "alt":
                                $result .= $this->GetBoundary($this->boundary[1], "", 
                                                                                        "text/plain", "");
                                $result .= $this->EncodeString($this->AltBody, $this->Encoding);
                                $result .= $this->LE.$this->LE;
                                $result .= $this->GetBoundary($this->boundary[1], "", 
                                                                                        "text/html", "");
 
                                $result .= $this->EncodeString($this->Body, $this->Encoding);
                                $result .= $this->LE.$this->LE;
 
                                $result .= $this->EndBoundary($this->boundary[1]);
                                break;
                        case "plain":
                                $result .= $this->EncodeString($this->Body, $this->Encoding);
                                break;
                        case "attachments":
                                $result .= $this->GetBoundary($this->boundary[1], "", "", "");
                                $result .= $this->EncodeString($this->Body, $this->Encoding);
                                $result .= $this->LE;
 
                                $result .= $this->AttachAll();
                                break;
                        case "alt_attachments":
                                $result .= sprintf("--%s%s", $this->boundary[1], $this->LE);
                                $result .= sprintf("Content-Type: %s;%s" .
                                                                "\tboundary=\"%s\"%s",
                                                                "multipart/alternative", $this->LE, 
                                                                $this->boundary[2], $this->LE.$this->LE);
 
                                // Create text body
                                $result .= $this->GetBoundary($this->boundary[2], "", 
                                                                                        "text/plain", "") . $this->LE;
 
                                $result .= $this->EncodeString($this->AltBody, $this->Encoding);
                                $result .= $this->LE.$this->LE;
 
                                // Create the HTML body
                                $result .= $this->GetBoundary($this->boundary[2], "", 
                                                                                        "text/html", "") . $this->LE;
 
                                $result .= $this->EncodeString($this->Body, $this->Encoding);
                                $result .= $this->LE.$this->LE;
 
                                $result .= $this->EndBoundary($this->boundary[2]);
 
                                $result .= $this->AttachAll();
                                break;
                }
                if($this->IsError())
                        $result = "";
 
                return $result;
        }
 
        /**
        * Returns the start of a message boundary.
        * @access private
        */
        function GetBoundary($boundary, $charSet, $contentType, $encoding) {
                $result = "";
                if($charSet == "") { $charSet = $this->CharSet; }
                if($contentType == "") { $contentType = $this->ContentType; }
                if($encoding == "") { $encoding = $this->Encoding; }
 
                $result .= $this->TextLine("--" . $boundary);
                $result .= sprintf("Content-Type: %s; charset = \"%s\"", 
                                                        $contentType, $charSet);
                $result .= $this->LE;
                $result .= $this->HeaderLine("Content-Transfer-Encoding", $encoding);
                $result .= $this->LE;
 
                return $result;
        }
 
        /**
        * Returns the end of a message boundary.
        * @access private
        */
        function EndBoundary($boundary) {
                return $this->LE . "--" . $boundary . "--" . $this->LE; 
        }
 
        /**
        * Sets the message type.
        * @access private
        * @return void
        */
        function SetMessageType() {
                if(count($this->attachment) < 1 && strlen($this->AltBody) < 1)
                        $this->message_type = "plain";
                else
                {
                        if(count($this->attachment) > 0)
                                $this->message_type = "attachments";
                        if(strlen($this->AltBody) > 0 && count($this->attachment) < 1)
                                $this->message_type = "alt";
                        if(strlen($this->AltBody) > 0 && count($this->attachment) > 0)
                                $this->message_type = "alt_attachments";
                }
        }
 
        /**
        * Returns a formatted header line.
        * @access private
        * @return string
        */
        function HeaderLine($name, $value) {
                return $name . ": " . $value . $this->LE;
        }
 
        /**
        * Returns a formatted mail line.
        * @access private
        * @return string
        */
        function TextLine($value) {
                return $value . $this->LE;
        }
 
        /////////////////////////////////////////////////
        // ATTACHMENT METHODS
        /////////////////////////////////////////////////
 
        /**
        * Adds an attachment from a path on the filesystem.
        * Returns false if the file could not be found
        * or accessed.
        * @param string $path Path to the attachment.
        * @param string $name Overrides the attachment name.
        * @param string $encoding File encoding (see $Encoding).
        * @param string $type File extension (MIME) type.
        * @return bool
        */
        function AddAttachment($path, $name = "", $encoding = "base64", 
                                                $type = "application/octet-stream") {
                if(!@is_file($path))
                {
                        $this->SetError($this->Lang("file_access") . $path);
                        return false;
                }
 
                $filename = basename($path);
                if($name == "")
                        $name = $filename;
 
                $cur = count($this->attachment);
                $this->attachment[$cur][0] = $path;
                $this->attachment[$cur][1] = $filename;
                $this->attachment[$cur][2] = $name;
                $this->attachment[$cur][3] = $encoding;
                $this->attachment[$cur][4] = $type;
                $this->attachment[$cur][5] = false; // isStringAttachment
                $this->attachment[$cur][6] = "attachment";
                $this->attachment[$cur][7] = 0;
 
                return true;
        }
 
        /**
        * Attaches all fs, string, and binary attachments to the message.
        * Returns an empty string on failure.
        * @access private
        * @return string
        */
        function AttachAll() {
                // Return text of body
                $mime = array();
 
                // Add all attachments
                for($i = 0; $i < count($this->attachment); $i++)
                {
                        // Check for string attachment
                        $bString = $this->attachment[$i][5];
                        if ($bString)
                                $string = $this->attachment[$i][0];
                        else
                                $path = $this->attachment[$i][0];
 
                        $filename      = $this->attachment[$i][1];
                        $name          = $this->attachment[$i][2];
                        $encoding      = $this->attachment[$i][3];
                        $type          = $this->attachment[$i][4];
                        $disposition = $this->attachment[$i][6];
                        $cid           = $this->attachment[$i][7];
 
                        $mime[] = sprintf("--%s%s", $this->boundary[1], $this->LE);
                        $mime[] = sprintf("Content-Type: %s; name=\"%s\"%s", $type, $name, $this->LE);
                        $mime[] = sprintf("Content-Transfer-Encoding: %s%s", $encoding, $this->LE);
 
                        if($disposition == "inline")
                                $mime[] = sprintf("Content-ID: <%s>%s", $cid, $this->LE);
 
                        $mime[] = sprintf("Content-Disposition: %s; filename=\"%s\"%s", 
                                                        $disposition, $name, $this->LE.$this->LE);
 
                        // Encode as string attachment
                        if($bString)
                        {
                                $mime[] = $this->EncodeString($string, $encoding);
                                if($this->IsError()) { return ""; }
                                $mime[] = $this->LE.$this->LE;
                        }
                        else
                        {
                                $mime[] = $this->EncodeFile($path, $encoding);                          
                                if($this->IsError()) { return ""; }
                                $mime[] = $this->LE.$this->LE;
                        }
                }
 
                $mime[] = sprintf("--%s--%s", $this->boundary[1], $this->LE);
 
                return join("", $mime);
        }
 
        /**
        * Encodes attachment in requested format.  Returns an
        * empty string on failure.
        * @access private
        * @return string
        */
        function EncodeFile ($path, $encoding = "base64") {
                if(!@$fd = fopen($path, "rb"))
                {
                        $this->SetError($this->Lang("file_open") . $path);
                        return "";
                }
                $magic_quotes = get_magic_quotes_runtime();
                set_magic_quotes_runtime(0);
                $file_buffer = fread($fd, filesize($path));
                $file_buffer = $this->EncodeString($file_buffer, $encoding);
                fclose($fd);
                set_magic_quotes_runtime($magic_quotes);
 
                return $file_buffer;
        }
 
        /**
        * Encodes string to requested format. Returns an
        * empty string on failure.
        * @access private
        * @return string
        */
        function EncodeString ($str, $encoding = "base64") {
                $encoded = "";
                switch(strtolower($encoding)) {
                case "base64":
                        // chunk_split is found in PHP >= 3.0.6
                        $encoded = chunk_split(base64_encode($str), 76, $this->LE);
                        break;
                case "7bit":
                case "8bit":
                        $encoded = $this->FixEOL($str);
                        if (substr($encoded, -strlen($this->LE)) != $this->LE)
                                $encoded .= $this->LE;
                        break;
                case "binary":
                        $encoded = $str;
                        break;
                case "quoted-printable":
                        $encoded = $this->EncodeQP($str);
                        break;
                default:
                        $this->SetError($this->Lang("encoding") . $encoding);
                        break;
                }
                return $encoded;
        }
 
        /**
        * Encode a header string to best of Q, B, quoted or none.  
        * @access private
        * @return string
        */
        function EncodeHeader ($str, $position = 'text') {
        $x = 0;
 
        switch (strtolower($position)) {
                case 'phrase':
                if (!preg_match('/[\200-\377]/', $str)) {
                        // Can't use addslashes as we don't know what value has magic_quotes_sybase.
                        $encoded = addcslashes($str, "\0..\37\177\\\"");
 
                        if (($str == $encoded) && !preg_match('/[^A-Za-z0-9!#$%&\'*+\/=?^_`{|}~ -]/', $str))
                        return ($encoded);
                        else
                        return ("\"$encoded\"");
                }
                $x = preg_match_all('/[^\040\041\043-\133\135-\176]/', $str, $matches);
                break;
                case 'comment':
                $x = preg_match_all('/[()"]/', $str, $matches);
                // Fall-through
                case 'text':
                default:
                $x += preg_match_all('/[\000-\010\013\014\016-\037\177-\377]/', $str, $matches);
                break;
        }
 
        if ($x == 0)
                return ($str);
 
        $maxlen = 75 - 7 - strlen($this->CharSet);
        // Try to select the encoding which should produce the shortest output
        if (strlen($str)/3 < $x) {
                $encoding = 'B';
                $encoded = base64_encode($str);
                $maxlen -= $maxlen % 4;
                $encoded = trim(chunk_split($encoded, $maxlen, "\n"));
        } else {
                $encoding = 'Q';
                $encoded = $this->EncodeQ($str, $position);
                $encoded = $this->WrapText($encoded, $maxlen, true);
                $encoded = str_replace("=".$this->LE, "\n", trim($encoded));
        }
 
        $encoded = preg_replace('/^(.*)$/m', " =?".$this->CharSet."?$encoding?\\1?=", $encoded);
        $encoded = trim(str_replace("\n", $this->LE, $encoded));
 
        return $encoded;
        }
 
        /**
        * Encode string to quoted-printable.  
        * @access private
        * @return string
        */
        function EncodeQP ($str) {
                $encoded = $this->FixEOL($str);
                if (substr($encoded, -strlen($this->LE)) != $this->LE)
                        $encoded .= $this->LE;
 
                // Replace every high ascii, control and = characters
                $encoded = preg_replace('/([\000-\010\013\014\016-\037\075\177-\377])/e',
                                "'='.sprintf('%02X', ord('\\1'))", $encoded);
                // Replace every spaces and tabs when it's the last character on a line
                $encoded = preg_replace("/([\011\040])".$this->LE."/e",
                                "'='.sprintf('%02X', ord('\\1')).'".$this->LE."'", $encoded);
 
                // Maximum line length of 76 characters before CRLF (74 + space + '=')
                $encoded = $this->WrapText($encoded, 74, true);
 
                return $encoded;
        }
 
        /**
        * Encode string to q encoding.  
        * @access private
        * @return string
        */
        function EncodeQ ($str, $position = "text") {
                // There should not be any EOL in the string
                $encoded = preg_replace("[\r\n]", "", $str);
 
                switch (strtolower($position)) {
                case "phrase":
                        $encoded = preg_replace("/([^A-Za-z0-9!*+\/ -])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
                        break;
                case "comment":
                        $encoded = preg_replace("/([\(\)\"])/e", "'='.sprintf('%02X', ord('\\1'))", $encoded);
                case "text":
                default:
                        // Replace every high ascii, control =, ? and _ characters
                        $encoded = preg_replace('/([\000-\011\013\014\016-\037\075\077\137\177-\377])/e',
                                "'='.sprintf('%02X', ord('\\1'))", $encoded);
                        break;
                }
 
                // Replace every spaces to _ (more readable than =20)
                $encoded = str_replace(" ", "_", $encoded);
 
                return $encoded;
        }
 
        /**
        * Adds a string or binary attachment (non-filesystem) to the list.
        * This method can be used to attach ascii or binary data,
        * such as a BLOB record from a database.
        * @param string $string String attachment data.
        * @param string $filename Name of the attachment.
        * @param string $encoding File encoding (see $Encoding).
        * @param string $type File extension (MIME) type.
        * @return void
        */
        function AddStringAttachment($string, $filename, $encoding = "base64", 
                                                                $type = "application/octet-stream") {
                // Append to $attachment array
                $cur = count($this->attachment);
                $this->attachment[$cur][0] = $string;
                $this->attachment[$cur][1] = $filename;
                $this->attachment[$cur][2] = $filename;
                $this->attachment[$cur][3] = $encoding;
                $this->attachment[$cur][4] = $type;
                $this->attachment[$cur][5] = true; // isString
                $this->attachment[$cur][6] = "attachment";
                $this->attachment[$cur][7] = 0;
        }
 
        /**
        * Adds an embedded attachment.  This can include images, sounds, and 
        * just about any other document.  Make sure to set the $type to an 
        * image type.  For JPEG images use "image/jpeg" and for GIF images 
        * use "image/gif".
        * @param string $path Path to the attachment.
        * @param string $cid Content ID of the attachment.  Use this to identify 
        *               the Id for accessing the image in an HTML form.
        * @param string $name Overrides the attachment name.
        * @param string $encoding File encoding (see $Encoding).
        * @param string $type File extension (MIME) type.  
        * @return bool
        */
        function AddEmbeddedImage($path, $cid, $name = "", $encoding = "base64", 
                                                        $type = "application/octet-stream") {
 
                if(!@is_file($path))
                {
                        $this->SetError($this->Lang("file_access") . $path);
                        return false;
                }
 
                $filename = basename($path);
                if($name == "")
                        $name = $filename;
 
                // Append to $attachment array
                $cur = count($this->attachment);
                $this->attachment[$cur][0] = $path;
                $this->attachment[$cur][1] = $filename;
                $this->attachment[$cur][2] = $name;
                $this->attachment[$cur][3] = $encoding;
                $this->attachment[$cur][4] = $type;
                $this->attachment[$cur][5] = false; // isStringAttachment
                $this->attachment[$cur][6] = "inline";
                $this->attachment[$cur][7] = $cid;
 
                return true;
        }
 
        /**
        * Returns true if an inline attachment is present.
        * @access private
        * @return bool
        */
        function InlineImageExists() {
                $result = false;
                for($i = 0; $i < count($this->attachment); $i++)
                {
                        if($this->attachment[$i][6] == "inline")
                        {
                                $result = true;
                                break;
                        }
                }
 
                return $result;
        }
 
        /////////////////////////////////////////////////
        // MESSAGE RESET METHODS
        /////////////////////////////////////////////////
 
        /**
        * Clears all recipients assigned in the TO array.  Returns void.
        * @return void
        */
        function ClearAddresses() {
                $this->to = array();
        }
 
        /**
        * Clears all recipients assigned in the CC array.  Returns void.
        * @return void
        */
        function ClearCCs() {
                $this->cc = array();
        }
 
        /**
        * Clears all recipients assigned in the BCC array.  Returns void.
        * @return void
        */
        function ClearBCCs() {
                $this->bcc = array();
        }
 
        /**
        * Clears all recipients assigned in the ReplyTo array.  Returns void.
        * @return void
        */
        function ClearReplyTos() {
                $this->ReplyTo = array();
        }
 
        /**
        * Clears all recipients assigned in the TO, CC and BCC
        * array.  Returns void.
        * @return void
        */
        function ClearAllRecipients() {
                $this->to = array();
                $this->cc = array();
                $this->bcc = array();
        }
 
        /**
        * Clears all previously set filesystem, string, and binary
        * attachments.  Returns void.
        * @return void
        */
        function ClearAttachments() {
                $this->attachment = array();
        }
 
        /**
        * Clears all custom headers.  Returns void.
        * @return void
        */
        function ClearCustomHeaders() {
                $this->CustomHeader = array();
        }
 
 
        /////////////////////////////////////////////////
        // MISCELLANEOUS METHODS
        /////////////////////////////////////////////////
 
        /**
        * Adds the error message to the error container.
        * Returns void.
        * @access private
        * @return void
        */
        function SetError($msg) {
                $this->error_count++;
                $this->ErrorInfo = $msg;
        }
 
        /**
        * Returns the proper RFC 822 formatted date. 
        * @access private
        * @return string
        */
        function RFCDate() {
                $tz = date("Z");
                $tzs = ($tz < 0) ? "-" : "+";
                $tz = abs($tz);
                $tz = ($tz/3600)*100 + ($tz%3600)/60;
                $result = sprintf("%s %s%04d", date("D, j M Y H:i:s"), $tzs, $tz);
 
                return $result;
        }
 
        /**
        * Returns the appropriate server variable.  Should work with both 
        * PHP 4.1.0+ as well as older versions.  Returns an empty string 
        * if nothing is found.
        * @access private
        * @return mixed
        */
        function ServerVar($varName) {
                global $HTTP_SERVER_VARS;
                global $HTTP_ENV_VARS;
 
                if(!isset($_SERVER))
                {
                        $_SERVER = $HTTP_SERVER_VARS;
                        if(!isset($_SERVER["REMOTE_ADDR"]))
                                $_SERVER = $HTTP_ENV_VARS; // must be Apache
                }
 
                if(isset($_SERVER[$varName]))
                        return $_SERVER[$varName];
                else
                        return "";
        }
 
        /**
        * Returns the server hostname or 'localhost.localdomain' if unknown.
        * @access private
        * @return string
        */
        function ServerHostname() {
                if ($this->Hostname != "")
                        $result = $this->Hostname;
                elseif ($this->ServerVar('SERVER_NAME') != "")
                        $result = $this->ServerVar('SERVER_NAME');
                else
                        $result = "localhost.localdomain";
 
                return $result;
        }
 
        /**
        * Returns a message in the appropriate language.
        * @access private
        * @return string
        */
        function Lang($key) {
                if(count($this->language) < 1)
                        $this->SetLanguage("en"); // set the default language
 
                if(isset($this->language[$key]))
                        return $this->language[$key];
                else
                        return "Language string failed to load: " . $key;
        }
 
        /**
        * Returns true if an error occurred.
        * @return bool
        */
        function IsError() {
                return ($this->error_count > 0);
        }
 
        /**
        * Changes every end of line from CR or LF to CRLF.  
        * @access private
        * @return string
        */
        function FixEOL($str) {
                $str = str_replace("\r\n", "\n", $str);
                $str = str_replace("\r", "\n", $str);
                $str = str_replace("\n", $this->LE, $str);
                return $str;
        }
 
        /**
        * Adds a custom header. 
        * @return void
        */
        function AddCustomHeader($custom_header) {
                $this->CustomHeader[] = explode(":", $custom_header, 2);
        }
}
 
?>

[edit] See also

-->

Personal tools
Namespaces
Variants
Actions
Site
Support
Download
Development
Communication
Print/export
Toolbox