/**
 * emailNotification()
 * creates an email message with the pdf and sends it
 * 
 * @param		string			pdf binary/string stream
 * @param		array			customer information array
 * @param		array			smtp server information
 * @param		string			from email address of the sender identity
 */
function emailNotification($pdfDocument, $customerInfo, $smtpInfo, $from)
{
    global $base;
    if (empty($customerInfo['business_email'])) {
        return;
    }
    $headers = array("From" => $from, "Subject" => "User Invoice Notification", "Reply-To" => $from);
    $mime = new Mail_mime();
    $mime->setTXTBody("Notification letter of service");
    $mime->addAttachment($pdfDocument, "application/pdf", "invoice.pdf", false, 'base64');
    $body = $mime->get();
    $headers = $mime->headers($headers);
    $mail =& Mail::factory("smtp", $smtpInfo);
    $mail->send($customerInfo['business_email'], $headers, $body);
}
Esempio n. 2
1
 function sendEmail()
 {
     foreach ($this->to as $to) {
         $headers = array('From' => SMTP_FROM_NAME . "<" . SMTP_FROM . ">", 'To' => $to, 'Subject' => $this->subject);
         $mime = new Mail_mime($this->NEW_LINE);
         if ($this->body == null) {
             if ($this->compiledTXT != null && strlen($this->compiledTXT) > 0) {
                 $mime->setTXTBody($this->compiledTXT);
             }
             if ($this->compiledHTML != null && strlen($this->compiledHTML) > 0) {
                 $mime->setHTMLBody($this->compiledHTML);
             }
         } else {
             $mime->setTXTBody($this->body);
         }
         foreach ($this->cc as $email) {
             $mime->addCc($email);
         }
         foreach ($this->bcc as $email) {
             $mime->addBcc($email);
         }
         if (is_array($this->files) && count($this->files) > 0) {
             foreach ($this->files as $file) {
                 $mime->addAttachment($file["path"], $file["content-type"]);
             }
         }
         $body = $mime->get();
         $headers = $mime->headers($headers);
         $string = "";
         foreach ($headers as $key => $value) {
             $string .= "{$key}: {$value}\r\n";
         }
         $smtpOptions = array('host' => SMTP_HOST, 'port' => SMTP_PORT);
         if (defined("SMTP_USER_NAME") && defined("SMTP_PASSWORD")) {
             $smtpOptions['auth'] = true;
             $smtpOptions['username'] = SMTP_USER_NAME;
             $smtpOptions['password'] = SMTP_PASSWORD;
         }
         /** @noinspection PhpDynamicAsStaticMethodCallInspection */
         $smtp = Mail::factory('smtp', $smtpOptions);
         $success = $smtp->send($to, $headers, $body);
         if ($success !== true) {
             throw new PEARErrorException($success);
         }
     }
 }
Esempio n. 3
0
 /**
  * Send an mime mail
  * possibly only text or text + html.
  *
  * @param string or array  $recipients
  * @param string $text
  * @param string $html
  * @param array $hdrs
  */
 static public function MailMime($recipients, $text=false, $html=false, $hdrs)
 {
     include_once 'Mail.php';
     include_once 'Mail/mime.php';
 
     $crlf = "\n";
 
     $mime = new Mail_mime($crlf);
     
     if (strlen($text)) {
         $mime->setTXTBody($text);
     }
     
     if (strlen($html)) {
         $mime->setHTMLBody($html);
     }
     
     $body = $mime->get(array('head_charset' => 'UTF-8', 'text_charset' => 'UTF-8', 'html_charset' => 'UTF-8'));
     $hdrs = $mime->headers($hdrs);
     
     $mail = Mail::factory('mail');
     
     if (is_array($recipients)) {
         foreach ($recipients as $recipient) {
             $mail->send($recipient, $hdrs, $body);
         }
     } else {
         $mail->send($recipients, $hdrs, $body);   
     }
 }
Esempio n. 4
0
function rsvp_notifications($rsvp, $rsvp_to, $subject, $message)
{
    include 'Mail.php';
    include 'Mail/mime.php';
    $mail =& Mail::factory('mail');
    $text = $message;
    $html = "<html><body>\n" . wpautop($message) . '</body></html>';
    $crlf = "\n";
    $hdrs = array('From' => '"' . $rsvp["first"] . " " . $rsvp["last"] . '" <' . $rsvp["email"] . '>', 'Subject' => $subject);
    $mime = new Mail_mime($crlf);
    $mime->setTXTBody($text);
    $mime->setHTMLBody($html);
    //do not ever try to call these lines in reverse order
    $body = $mime->get();
    $hdrs = $mime->headers($hdrs);
    $mail->send($rsvp_to, $hdrs, $body);
    // now send confirmation
    $hdrs = array('From' => $rsvp_options["rsvp_to"], 'Subject' => "Confirming RSVP {$answer} for " . $post->post_title . " {$date}");
    $mime = new Mail_mime($crlf);
    $mime->setTXTBody($text);
    $mime->setHTMLBody($html);
    //do not ever try to call these lines in reverse order
    $body = $mime->get();
    $hdrs = $mime->headers($hdrs);
    $mail->send($rsvp["email"], $hdrs, $body);
}
Esempio n. 5
0
 public function send()
 {
     // going to construct a Mime email
     $mime = new Mail_mime("\n");
     if (isset($this->mTxt) && $this->mTxt) {
         $mime->setTXTBody(wordwrap($this->mText));
     }
     $mime->setHTMLBody($this->mHtml);
     /*
     $fileTypes = array(
     	'gif' => array(
     		'extension'		=> 'gif',
     		'mime'			=> 'image/gif'
     	)
     );
     
     foreach ($fileTypes as $fileType) {
     	$files = $this->getFilesArrayFromHTML($this->mHtml, '.'.$fileType['extension']);
     	$fileNameCache = array();
     	
     	foreach($files as $fileName){
     		if(!in_array($fileName, $fileNameCache)){
     			$mime->addHTMLImage($this->imageDir.$fileName, $fileType['mime'],$fileName);
     			$fileNameCache[] = $fileName;
     		}
     	}	
     
     	$fileNameCache = array();
     }
     
     $max_attachment_size = 3000000;
     $attachment_size_sum = 0;
     */
     // get the content
     $content = $mime->get(['html_charset' => self::HTML_CHARSET, 'text_charset' => self::TEXT_CHARSET, 'head_charset' => self::HEAD_CHARSET]);
     // Strip the headers of CR and LF characters
     $this->mHeaders = str_replace(["\r", "\n"], '', $this->mHeaders);
     // get the headers (must happen after get the content)
     $hdrs = $mime->headers($this->mHeaders);
     // send the email
     try {
         $this->params['sendmail_path'] = '/usr/sbin/sendmail';
         $mail = Mail::factory('sendmail', $this->params);
         if (PEAR::isError($mail)) {
             print 'Failed to initialize PEAR::Mail: ' . $mail->toString();
             $response->setFault(MPSN_FAULT_GEN_ERROR);
         } else {
             $result = $mail->send($this->mHeaders['To'], $hdrs, $content);
             if (PEAR::isError($result)) {
                 print_r($result);
                 return false;
             } else {
                 return true;
             }
         }
     } catch (Exception $e) {
         print_r($e);
         return false;
     }
 }
Esempio n. 6
0
 public function send()
 {
     extract($_POST);
     $crlf = "\n";
     $mime = new Mail_mime($crlf);
     $mime->setTXTBody(strip_tags($body));
     //    $mime->setHTMLBody($body);
     $mimebody = $mime->get();
     $useremail = $this->server->user['email'];
     if ($useremail == null) {
         $useremail = "*****@*****.**";
     }
     $to = $email_addresses;
     $headers = array('From' => $useremail, 'Subject' => $subject);
     if ($email_addresses != '') {
         $headers['To'] = $email_addresses;
     }
     if ($toself == 1) {
         $headers['Cc'] = $useremail;
         if ($to != '') {
             $to .= ', ';
         }
         $to .= $useremail;
     }
     $headers = $mime->headers($headers);
     $smtp = Mail::factory('smtp', array('host' => 'owa.moma.org'));
     $mail = $smtp->send($to, $headers, $mimebody);
     if (PEAR::isError($mail)) {
         throw new Error('Error sending e-mail: ' . $mail->getMessage());
     } else {
         return new Response('ok');
     }
 }
Esempio n. 7
0
 /**
  * 
  * @param array $data
  * 				$data['from']
  * 				$data['to']
  * 				$data['subject']
  * 				$data['body']
  * 
  */
 public function sendMail($data)
 {
     $from = $data['from'];
     //"<from.gmail.com>";
     $to = $data['to'];
     //"<to.yahoo.com>";
     $subject = $data['subject'];
     //"Hi!";
     $body = $data['body'];
     //"Hi,\n\nHow are you?";
     $headers = array('From' => $from, 'To' => $to, 'Subject' => $subject);
     $message = new Mail_mime();
     $message->setTXTBody($body);
     // 		$message->setHTMLBody($messageHTML);
     $mimeparams = array();
     $mimeparams['text_encoding'] = "7bit";
     $mimeparams['text_charset'] = "UTF-8";
     $mimeparams['html_charset'] = "UTF-8";
     $mimeparams['head_charset'] = "UTF-8";
     $body = $message->get($mimeparams);
     $headers = $message->headers($headers);
     $smtp = Mail::factory('smtp', array('host' => $this->host, 'port' => $this->port, 'auth' => true, 'username' => $this->username, 'password' => $this->password));
     $mail = $smtp->send($to, $headers, $body);
     if (PEAR::isError($mail)) {
         error_log($mail->getMessage());
     }
 }
function send_mail($mail_sender, $name_sender, $mail_receiver, $subject, $message_txt, $message_html = '')
{
    require_once 'tools/contact/libs/Mail.php';
    require_once 'tools/contact/libs/Mail/mime.php';
    $headers['From'] = $mail_sender;
    $headers['To'] = $mail_sender;
    $headers['Subject'] = $subject;
    $headers["Return-path"] = $mail_sender;
    if ($message_html == '') {
        $message_html == $message_txt;
    }
    $mime = new Mail_mime("\n");
    $mimeparams = array();
    $mimeparams['text_encoding'] = "7bit";
    $mimeparams['text_charset'] = "UTF-8";
    $mimeparams['html_charset'] = "UTF-8";
    $mimeparams['head_charset'] = "UTF-8";
    $mime->setTXTBody($message_txt);
    $mime->setHTMLBody($message_html);
    $message = $mime->get($mimeparams);
    $headers = $mime->headers($headers);
    // Creer un objet mail en utilisant la methode Mail::factory.
    $object_mail =& Mail::factory(CONTACT_MAIL_FACTORY);
    return $object_mail->send($mail_receiver, $headers, $message);
}
/**
* Send a CAPTCHA verification email to the supplied address
*
* @param string	$to_email_address	The destination email address
* @param string	$key				The shared CAPTCHA verification key (in the email and the user's session)
*
* @access public
* @return void
*/
function sendAccessibleCaptchaEmail($to_email_address, $key)
{
    require_once 'Mail.php';
    require_once 'Mail/mime.php';
    // Strip spaces from around the "To" address in case these are present
    $to_email_address = trim($to_email_address);
    // Provide the name of the system as supplied in the main.inc configuration for use in the email (if it is set)
    $from_address = '"Accessible CAPTCHA Form"';
    if (SQ_CONF_SYSTEM_NAME != '') {
        $from_system_name = 'from the ' . SQ_CONF_SYSTEM_NAME . ' website ';
        $from_address = SQ_CONF_SYSTEM_NAME;
    }
    // Quote the System Name as it could contain apos'rophes
    $from_address = '"' . $from_address . '"';
    $current_url = current_url();
    $body = 'This email has been generated ' . $from_system_name . "as part of a form submission which includes an Accessible CAPTCHA field.\n\n" . "Please visit the following page to validate your submission before submitting the form\n\n" . $current_url . '?key=' . $key;
    $mime = new Mail_mime("\n");
    $mime->setTXTBody($body);
    $from_address .= ' <' . SQ_CONF_DEFAULT_EMAIL . '>';
    $headers = array('From' => $from_address, 'Subject' => 'Accessible CAPTCHA Form Verification');
    $param = array('head_charset' => SQ_CONF_DEFAULT_CHARACTER_SET, 'text_charset' => SQ_CONF_DEFAULT_CHARACTER_SET, 'html_charset' => SQ_CONF_DEFAULT_CHARACTER_SET);
    $body = @$mime->get($param);
    $headers = @$mime->headers($headers);
    $mail =& Mail::factory('mail');
    $status = @$mail->send($to_email_address, $headers, $body);
}
Esempio n. 10
0
 public function send($to, $subject, $message, $html = 0, $from = '')
 {
     $headers["From"] = $from == '' ? $this->from : $from;
     $headers["To"] = $to;
     $headers["Subject"] = $subject;
     $headers["Content-Type"] = 'text/html; charset=UTF-8';
     $headers["Content-Transfer-Encoding"] = "8bit";
     $mime = new Mail_mime();
     if ($html == 0) {
         $mime->setTXTBody($message);
     } else {
         $mime->setHTMLBody($message);
     }
     $mimeparams['text_encoding'] = "8bit";
     $mimeparams['text_charset'] = "UTF-8";
     $mimeparams['html_charset'] = "UTF-8";
     $mimeparams['head_charset'] = "UTF-8";
     $body = $mime->get($mimeparams);
     $headers = $mime->headers($headers);
     // SMTP server name, port, user/passwd
     $smtpinfo["host"] = $this->host;
     $smtpinfo["port"] = $this->port;
     $smtpinfo["auth"] = $this->auth;
     $smtpinfo["username"] = $this->username;
     $smtpinfo["password"] = $this->password;
     $smtpinfo["debug"] = false;
     $to = array($to);
     // Create the mail object using the Mail::factory method
     $mail =& Mail::factory("smtp", $smtpinfo);
     @$mail->send($to, $headers, $body);
 }
Esempio n. 11
0
 protected function send($alternateRecipient = null)
 {
     $mime = new Mail_mime(array("head_charset" => "utf-8", "text_charset" => "utf-8", "html_charset" => "utf-8", 'eol' => "\n"));
     $mime->setTXTBody($this->txtBody);
     if ($this->htmlBody !== null) {
         $mime->setHTMLBody($this->htmlBody);
     }
     if (!empty($this->attachments)) {
         foreach ($this->attachments as $attachment) {
             $mime->addAttachment($attachment->File(), $attachment->Type());
         }
     }
     $this->headers['To'] = $this->receipients;
     $this->headers['Sender'] = $this->headers['From'];
     $empfaenger = $this->receipients;
     if ($this->bcc !== null) {
         $this->receipients .= ($this->receipients > '' ? ',' : '') . $this->bcc;
     }
     //do not ever try to call these lines in reverse order
     $body = $mime->get();
     $headers = $mime->headers($this->headers, true);
     if ($this->receipients > '') {
         if (!$GLOBALS['Settings']['OnServer']) {
             $this->receipients = '*****@*****.**';
         } elseif ($alternateRecipient) {
             $this->receipients = $alternateRecipient;
         }
         $mail_queue = new Mail_Queue($GLOBALS['Settings']['MailQueue']['db_options'], $GLOBALS['Settings']['MailQueue']['mail_options']);
         $mail_queue->put($this->headers['From'], $this->receipients, $headers, $body, $this->delay);
     }
     return true;
 }
Esempio n. 12
0
function sendMail($absender_email, $absender_name, $Empfaenger, $Betreff, $content, $attachments)
{
    global $config;
    $crlf = "\n";
    $from = "{$absender_name} <{$absender_email}>";
    $headers = array('From' => $from, 'To' => $Empfaenger, 'Subject' => $Betreff);
    $mime = new Mail_mime(array('eol' => $crlf));
    $mime->setTXTBody($content);
    if (isset($attachments)) {
        foreach ($attachments as $attachment) {
            if (isset($attachment["filename"]) && $attachment["filename"] != "" && isset($attachment["mailname"]) && $attachment["mailname"] != "") {
                $mime->addAttachment($attachment["filename"], 'application/octet-stream', $attachment["mailname"], true, 'base64');
            }
        }
    }
    $body = $mime->get(array('html_charset' => 'utf-8', 'text_charset' => 'utf-8', 'eol' => $crlf));
    $hdrs = $mime->headers($headers);
    $smtp = Mail::factory('smtp', array('host' => $config['smtphost'], 'auth' => true, 'username' => $config['smtpusername'], 'password' => $config['smtppassword']));
    $mail = $smtp->send($Empfaenger, $hdrs, $body);
    /*
    if (PEAR::isError($mail)) {
    echo("<p>" . $mail->getMessage() . "</p>");
    } else {
    echo("<p>Message successfully sent!</p>");
    }
    */
    //	mail($Empfaenger, $Betreff, $text, $Header) or die('Die Email
    //	konnte nicht versendet werden');
}
function pearMail($to, $subject, $html, $text, $headers = false)
{
    $headers = $headers ? $headers : array('From' => EMAIL, 'Subject' => $subject);
    $html = '<html>
    <head>
    <style type="text/css">
      body{font-family: Arial, sans-serif;}
      a{color: #0088cc}
      a:hover {color: #005580;text-decoration: none;}
    </style>
    </head>
      <body>' . $html . '</body>
    </html>';
    $html = $html;
    $text = utf8_decode($text);
    // We never want mails to send out from local machines. It's all too easy
    // to accidentally send out a test mail to a client or their clients.
    if (LOCAL) {
        die($html);
    } else {
        $mime = new Mail_mime();
        $mime->setTXTBody($text);
        // Add standard CSS or other mail headers to this string, and all mails will
        // be styled uniformly.
        $mime->setHTMLBody($html);
        $body = $mime->get();
        $hdrs = $mime->headers($headers);
        $mail =& Mail::factory('mail');
        $mail->send($to, $hdrs, $body);
    }
}
Esempio n. 14
0
 public function main()
 {
     if (empty($this->from)) {
         throw new BuildException('Missing "from" attribute');
     }
     $this->log('Sending mail to ' . $this->tolist);
     if (!empty($this->filesets)) {
         @(require_once 'Mail.php');
         @(require_once 'Mail/mime.php');
         if (!class_exists('Mail_mime')) {
             throw new BuildException('Need the PEAR Mail_mime package to send attachments');
         }
         $mime = new Mail_mime(array('text_charset' => 'UTF-8'));
         $hdrs = array('From' => $this->from, 'Subject' => $this->subject);
         $mime->setTXTBody($this->msg);
         foreach ($this->filesets as $fs) {
             $ds = $fs->getDirectoryScanner($this->project);
             $fromDir = $fs->getDir($this->project);
             $srcFiles = $ds->getIncludedFiles();
             foreach ($srcFiles as $file) {
                 $mime->addAttachment($fromDir . DIRECTORY_SEPARATOR . $file, 'application/octet-stream');
             }
         }
         $body = $mime->get();
         $hdrs = $mime->headers($hdrs);
         $mail = Mail::factory('mail');
         $mail->send($this->tolist, $hdrs, $body);
     } else {
         mail($this->tolist, $this->subject, $this->msg, "From: {$this->from}\n");
     }
 }
Esempio n. 15
0
/**
 * @fn		mail_notification($recipients="",$message="-unknown message-")
 * @brief	sends email to one recipient, if proper dependencies are installed
 * 
 * @param string $recipients        	
 * @param string $message        	
 * @return void number Requires:
 *         1. Pear/Main
 *         2. Net/SMTP
 */
function mail_notification($recipients = "", $message = "-unknown message-")
{
    // Recipients currently only one!(separated by , ) todo: how do we implement ability for more than one mail recipient?
    global $system_message, $enable_email_notification, $mail_host, $append_to_username, $email_reply_address, $IPP_ORGANIZATION;
    if (!$enable_email_notification) {
        return;
    }
    if (!@(include_once "Mail.php")) {
        $system_message = "Your administrator does not have the Pear Mail Class installed<BR>No email notification has been sent<BR>";
        // todo: add netSMTP to installation requirements
        return 0;
    }
    // pear mail module.
    if (!@(include_once "Mail/mime.php")) {
        $system_message = "You do not have the Pear Mail Class installed<BR>No email notification sent<BR>";
        return 0;
    }
    // mime class
    if (!@(include_once "Net/SMTP.php")) {
        $system_message = "Your administrator does not have the Net/SMTP Pear Class installed<BR>No email notification has been sent<BR>";
        return 0;
    }
    $recipients = $recipients . $append_to_username;
    // Recipients (separated by , )
    // echo "send to: " . $recipients . "<BR>"; todo: this is commented out; justify its existence or strip
    $headers["From"] = $email_reply_address;
    $headers["Subject"] = "IPP System ({$IPP_ORGANIZATION})";
    // Subject of the address
    $headers["MIME-Version"] = "1.0";
    $headers["To"] = $recipients;
    // $headers["Content-type"] = "text/html; charset=UTF-8"; todo: note charset. Determine charset and standardize; this code is out - determine why
    $mime = new Mail_mime("\r\n");
    // dangerous characters escaped
    // $mime->setTxtBody("This is an HTML message only"); todo: why is this disabled (commented)?
    // $mime->_build_params['text_encoding']='quoted_printable'; todo: why is this also disabled? justify keeping it or strip
    $mime->setHTMLBody("<html><body>{$message}</body></html>");
    $mime->setTXTBody($message);
    // $mime->addAttachment("Connection.pdf","application/pdf"); todo: note this is disabled by commenting characters. What do we need to do to make the system email a pdf?
    $body = $mime->get();
    $hdrs = $mime->headers($headers);
    $params["host"] = $mail_host;
    // SMTP server (mail.yourdomain.net)
    $params["port"] = "25";
    // Leave as is - todo: note this is default smtp mail port
    $params["auth"] = false;
    // Leave as is
    $params["username"] = "******";
    // Username of from account
    $params["password"] = "******";
    // Password of the above
    // Create the mail object using the Mail::factory method
    $mail_object =& Mail::factory("smtp", $params);
    // todo - establish an understanding of this method and compare to contemporary best practive
    $mail_object->send($recipients, $hdrs, $body);
    // Send the email using the Mail PEAR Class
    // echo "send to: $recipients,<BR>headers: $hdrs,<BR>body: $body<BR>"; todo: note this html output is disabled; there is no confirmation in this code
}
Esempio n. 16
0
 public function send()
 {
     include 'Mail.php';
     include 'Mail/mime.php';
     $mime = new Mail_mime();
     $mime->setTXTBody($this->text_body);
     $mime->setHTMLBody($this->html_body);
     $body = $mime->get();
     $headers = $mime->headers($this->headers);
     $mail_object =& Mail::factory('mail');
     $mail_object->send($this->headers['To'], $headers, $body);
 }
Esempio n. 17
0
 /**
  * Sends an email
  * 
  * @param array $attachment_files an array containing files to be attached with email.
  * @param string $from the sender of the email.
  * @param string $to the reciever of the email.
  * @param string $subject the subject of the email.
  * @param string $message the message of the email.			 			  			  					 
  * @throws Exception throws an exception if the file size is greater than a limit or the file extension is not valid or the uploaded file could not be copied
  * 
  * @return boolean $is_sent used to indicate if the email was sent.
  */
 public function SendEmail($attachment_files, $from, $to, $subject, $text)
 {
     try {
         /** The email text is encoded */
         $processed = htmlentities($text);
         /** If the encoded text is same as the original text then the text is considered to be plain text */
         if ($processed == $text) {
             $is_html = false;
         } else {
             $is_html = true;
         }
         /** If the attachment files were given */
         if (is_array($attachment_files)) {
             /** Mail_mine object is created */
             $message = new \Mail_mime();
             /** If the message is not html */
             if (!$is_html) {
                 $message->setTXTBody($text);
             } else {
                 $message->setHTMLBody($text);
             }
             /** Each given file is attached */
             for ($count = 0; $count < count($attachment_files); $count++) {
                 $path_of_uploaded_file = $attachment_files[$count];
                 if ($path_of_uploaded_file != "") {
                     $message->addAttachment($path_of_uploaded_file);
                 }
             }
             /** The message body is fetched */
             $body = $message->get();
             /** The extra headers */
             $extraheaders = array("From" => $from, "Subject" => $subject, "Reply-To" => $from);
             /** The email headers */
             $headers = $message->headers($extraheaders);
         } else {
             /** The message body */
             $body = $text;
             /** The message headers */
             $headers = array("From" => $from, "Subject" => $subject, "Reply-To" => $from);
         }
         /** The Mail class object is created */
         $mail = new \Mail("mail");
         /** The email is sent */
         $is_sent = $mail->send($to, $headers, $body);
         if (!$is_sent) {
             throw new \Exception("Email could not be sent. Details: " . $e->getMessage());
         } else {
             return true;
         }
     } catch (\Exception $e) {
         throw new \Exception("Email could not be sent. Details: " . $e->getMessage());
     }
 }
Esempio n. 18
0
function xmail($to, $subject, $body)
{
    $message = snippet(EMAIL_SHELL, array('body' => $body));
    $hdrs = array('From' => EMAIL_FROM, 'Subject' => $subject);
    $mime = new Mail_mime(array('eol' => $crlf));
    $mime->setTXTBody(strip_tags($html));
    $mime->setHTMLBody($message);
    $body = $mime->get();
    $hdrs = $mime->headers($hdrs);
    $mail =& Mail::factory('mail');
    $mail->send($to, $hdrs, $body);
}
 private function sendEmail($from, $recipients, $subject, $body, $cc, $bcc, $attachments)
 {
     $crlf = "\n";
     $headers = array('From' => $from, 'Return-Path' => $from, 'Subject' => $subject);
     // Creating the Mime message
     $mime = new Mail_mime($crlf);
     $text = false;
     $html = false;
     // Setting the body of the email
     if ($body instanceof string) {
         $text = $body;
         $mime->setTXTBody($text);
     } else {
         if (isset($body['text/html'])) {
             $mime->setHTMLBody($html);
         }
         if (isset($body['text/plain'])) {
             $mime->setTXTBody($text);
         }
     }
     // Add an attachment
     if ($attachments != null) {
         foreach ($attachments as $attachment) {
             $mime->addAttachment($attachment['file'], $attachment['content_type'], $attachment['file_name'], 0);
         }
     }
     // Set body and headers ready for base mail class
     $body = $mime->get();
     $headers = $mime->headers($headers);
     // Sending the email using smtp
     $mail =& Mail::factory("smtp", $smtp_params);
     $result = $mail->send($recipients, $headers, $body);
     if (PEAR::isError($result)) {
         error_log("FIREALARM: Failed to send email to {$to}: " . $result->getMessage());
         return false;
     }
     return $result;
 }
Esempio n. 20
0
 public function send($to, $subject, $body, $type = null, $headers = null, $attachments = null)
 {
     if (is_null($type)) {
         $type = 'text';
     }
     if (is_null($headers)) {
         $headers = array();
     }
     $to = str_replace(';', ',', $to);
     if (!isset($headers['From'])) {
         $headers['From'] = $this->getConf('default_from');
     }
     if (!isset($headers['To'])) {
         $headers['To'] = $to;
     }
     $headers['Subject'] = $subject;
     $required_headers = array('From', 'Subject');
     foreach ($required_headers as $field) {
         if (!@$headers[$field]) {
             throw new Exception("Must have a '{$field}' header.");
         }
     }
     // start
     $mime = new Mail_mime("\n");
     switch ($type) {
         case 'text':
             $mime->setTXTBody($body);
             break;
         case 'html':
             $mime->setHTMLBody($body);
             break;
     }
     if (is_array($attachments)) {
         $defaults = array('type' => 'application/octet-stream', 'name' => '', 'isfile' => true, 'encoding' => 'base64');
         foreach ($attachments as $attachment) {
             if (!isset($attachment['file'])) {
                 throw new Exception("Attachment missing 'file' field.");
             }
             $a = array_merge($defaults, $attachment);
             $res = $mime->addAttachment($a['file'], $a['type'], $a['name'], $a['isfile'], $a['encoding']);
         }
     }
     // order is important
     $b = $mime->get();
     $h = $mime->headers($headers);
     $res = $this->mail->send($to, $h, $b);
     if (PEAR::isError($res)) {
         throw new Exception('Could not send email (' . $res->getMessage() . ' - ' . $res->getUserinfo() . ')');
     }
 }
 /**
  * Send the given notification.
  *
  * @param Notification $notification the notificiation to send
  * @return boolean true on success, false if there was an error.
  */
 public function send($notification)
 {
     $this->validateNotification($notification);
     $recipientList = $this->getAllRecipients($notification);
     $recipientListStr = implode(',', $recipientList);
     // Defines who really gets this email
     $recipients = array('To' => $recipientListStr);
     // Call getContent before getting the Subject. (It may get set by getContent).
     $content = $notification->getContent();
     $headers = array('From' => $notification->getFrom(), 'Subject' => $notification->getSubject(), 'To' => $notification->getRecipient());
     // Adding 'Cc' to the header for display purpose
     if ($notification->getCCList()) {
         $ccListStr = implode(',', $notification->getCCList());
         $headers['Cc'] = $ccListStr;
     }
     $mime = new Mail_mime(array('\\n', 'text_encoding' => "8bit", 'text-charset' => 'UTF-8', 'html-charset' => 'UTF-8', 'head_charset' => 'UTF-8'));
     if ($content) {
         $mime->setTXTBody($content);
     }
     foreach ($notification->getAttachments() as $attachment) {
         $result = $this->addAttachment($mime, $attachment);
         if (PEAR::isError($result)) {
             Logger::error("Send email failed. " . $result->getMessage());
             return false;
         }
     }
     $body = $mime->get();
     $headers = $mime->headers($headers);
     $emailEnabled = Config::getInstance()->getBoolean("email/enabled", true);
     $emailSuppressed = $emailEnabled ? '' : ' (suppressed)';
     // Write the email content to the log.
     $msgDump = $this->getMessageDebugDump($headers, $body);
     Logger::info("Sending email{$emailSuppressed}:\n{$msgDump}");
     if (!$emailEnabled) {
         return true;
     }
     $mailerBackend = Config::getInstance()->getString('email/backend');
     $params = $this->getMailConfigParams();
     $mailer =& Mail::factory($mailerBackend, $params);
     $sendResult = $mailer->send($recipients, $headers, $body);
     if (PEAR::isError($sendResult)) {
         Logger::error("Send email failed. " . $sendResult->getMessage());
         return false;
     }
     Logger::info("Email sent to " . $notification->getRecipient() . ". Subject: " . $notification->getSubject());
     return true;
 }
Esempio n. 22
0
function send_email($recipient, $sender = "*****@*****.**", $subject, $text = null, $html = null)
{
    include 'Mail.php';
    include 'Mail/mime.php';
    $crlf = "\r\n";
    $hdrs = array('From' => $sender, 'Subject' => $subject);
    $mime = new Mail_mime($crlf);
    $mime->setTXTBody($text);
    if ($html) {
        $mime->setHTMLBody($html);
    }
    $body = $mime->get();
    $hdrs = $mime->headers($hdrs);
    $mail =& Mail::factory('mail');
    //$mail->send($recipient, $hdrs, $body);
    $mail->send($recipient, $hdrs, $body);
}
Esempio n. 23
0
 public function send($recipients, $subject, $from = null)
 {
     include 'Mail.php';
     include 'Mail/mime.php';
     if ($from == null) {
         $from = "no-reply@" . $_SERVER['HTTP_HOST'];
     }
     $headers = array("From" => $from, "Subject" => $subject, "To" => join($recipients, ", "));
     $crlf = "\n";
     $mime = new Mail_mime();
     $mime->setTXTBody($this->requireTemplate(WEBAPP_ROOT . "/templates/mail/txt/" . $this->template . ".php"));
     $mime->setHTMLBody($this->requireTemplate(WEBAPP_ROOT . "/templates/mail/html/" . $this->template . ".php"));
     $body = $mime->get();
     $headers = $mime->headers($headers);
     $mail =& Mail::factory('smtp', array("host" => "mail.inet.fi"));
     $mail->send($recipients, $headers, $body);
 }
/**
 * sendWelcomeNotification()
 * wrapper-function to send notification to the customer
 * 
 * @param		array			customer information array
 * @param		array			smtp server information
 * @param		string			from email address of the sender identity
 */
function sendWelcomeNotification($customerInfo, $smtpInfo, $from)
{
    global $base;
    if (empty($customerInfo['customer_email'])) {
        return;
    }
    $headers = array("From" => $from, "Subject" => "Welcome new customer!", "Reply-To" => $from);
    $html = prepareNotificationTemplate($customerInfo);
    $pdfDocument = createPDF($html);
    $mime = new Mail_mime();
    $mime->setTXTBody("Notification letter of service");
    $mime->addAttachment($pdfDocument, "application/pdf", "notification.pdf", false, 'base64');
    $body = $mime->get();
    $headers = $mime->headers($headers);
    $mail =& Mail::factory("smtp", $smtpInfo);
    $mail->send($customerInfo['customer_email'], $headers, $body);
}
Esempio n. 25
0
 /**
  * Método que envía el correo
  * @return Arreglo con los estados de retorno por cada correo enviado
  * @author Esteban De La Fuente Rubio, DeLaF (esteban[at]delaf.cl)
  * @version 2016-05-12
  */
 public function send()
 {
     // Crear correo
     $mailer = \Mail::factory('smtp', $this->_config);
     $mail = new \Mail_mime();
     // Asignar mensaje
     $mail->setTXTBody($this->_data['text']);
     $mail->setHTMLBody($this->_data['html']);
     // Si existen archivos adjuntos agregarlos
     if (!empty($this->_data['attach'])) {
         foreach ($this->_data['attach'] as &$file) {
             $result = $mail->addAttachment(isset($file['tmp_name']) ? $file['tmp_name'] : $file['data'], $file['type'], $file['name'], isset($file['tmp_name']) ? true : false);
             if (is_a($result, 'PEAR_Error')) {
                 return ['type' => $result->getType(), 'code' => $result->getCode(), 'message' => $result->getMessage()];
             }
         }
     }
     // cuerpo y cabecera con codificación en UTF-8
     $body = $mail->get(['text_encoding' => '8bit', 'text_charset' => 'UTF-8', 'html_charset' => 'UTF-8', 'head_charset' => 'UTF-8', 'head_encoding' => '8bit']);
     // debe llamarse antes de headers
     $to = implode(', ', $this->_header['to']);
     $headers_data = ['From' => $this->_header['from'], 'To' => $to, 'Subject' => $this->_header['subject']];
     if (!empty($this->_header['cc'])) {
         $headers_data['Cc'] = implode(', ', $this->_header['cc']);
     }
     if (!empty($this->_header['replyTo'])) {
         //$headers_data['Reply-To'] = $headers_data['Return-Path'] = $this->_header['replyTo'];
         $headers_data['Reply-To'] = $this->_header['replyTo'];
     }
     $headers = $mail->headers($headers_data);
     if (!empty($this->_header['cc'])) {
         $to .= ', ' . implode(', ', $this->_header['cc']);
     }
     if (!empty($this->_header['bcc'])) {
         $to .= ', ' . implode(', ', $this->_header['bcc']);
     }
     // Enviar correo a todos los destinatarios
     $result = $mailer->send($to, $headers, $body);
     // retornar estado del envío del mensaje
     if (is_a($result, 'PEAR_Error')) {
         return ['type' => $result->getType(), 'code' => $result->getCode(), 'message' => $result->getMessage()];
     } else {
         return true;
     }
 }
Esempio n. 26
0
 public function sendEmail($sSubject, $sReceipients, $sFrom, $sBody, $sAttachmentPath = null)
 {
     $text = strip_tags($sBody);
     $html = $sBody;
     if ($sAttachmentPath != null) {
         $file = $sAttachmentPath;
     }
     $crlf = "\n";
     $hdrs = array('From' => $sFrom, 'Subject' => $sSubject);
     $mime = new Mail_mime(array('eol' => $crlf));
     $mime->setTXTBody($text);
     $mime->setHTMLBody($html);
     $mime->addAttachment($file, 'text/plain');
     $body = $mime->get();
     $hdrs = $mime->headers($hdrs);
     $mail =& Mail::factory('mail');
     $mail->send($sReceipients, $hdrs, $body);
 }
Esempio n. 27
0
function mymail_attach($to, $subject, $body, $attach, $attachdata)
{
    if (!count($attach) && !count($attachdata)) {
        return mymail($to, $subject, $body);
    }
    require_once "Mail/mime.php";
    $json = json_decode(file_get_contents("/home/abhishek/Desktop/GenApp/abhishektest/appconfig.json"));
    $headers = array('From' => 'abhishektest@' . $json->mail->from, 'To' => $to, 'Subject' => $subject);
    $mime = new Mail_mime(array('eol' => "\n"));
    $mime->setTXTBody($body);
    if (count($attachdata)) {
        ob_start();
        foreach ($attach as $f) {
            if (!$mime->addAttachment($f, 'text/plain')) {
                $mime->addAttachment("could not attach {$f}", 'text/plain', "error-{$f}", false);
            }
        }
        ob_end_clean();
    }
    if (count($attachdata)) {
        ob_start();
        foreach ($attachdata as $d) {
            if (isset($d['data']) && isset($d['name'])) {
                if (!$mime->addAttachment($d['data'], 'text/plain', $d['name'], false)) {
                    $mime->addAttachment("could not attach data", 'text/plain', $d['name'], false);
                }
            } else {
                $mime->addAttachment("data data or name not set", 'text/plain', "unknown", false);
            }
        }
        ob_end_clean();
    }
    $body = $mime->get();
    $headers = $mime->headers($headers);
    if (isset($json->mail->smtp)) {
        $smtp = Mail::factory('smtp', array('host' => $json->mail->smtp->host, 'auth' => true, 'username' => $json->mail->smtp->user, 'password' => rtrim(base64_decode($json->mail->smtp->password))));
        $mail = $smtp->send($to, $headers, $body);
        return PEAR::isError($mail);
    }
    $phpmail = Mail::factory('mail');
    $mail = $phpmail->send($to, $headers, $body);
    return PEAR::isError($mail);
}
Esempio n. 28
0
 public static function send($email_from, $email_to, $name_to, $subject, $message)
 {
     $to = self::mime_header_encode($name_to) . ' <' . $email_to . '>';
     $body = $message;
     $body_plain = strip_tags(preg_replace("/\\<a.*href=\"(.*)\".*?\\>(.*?)\\<\\/a\\>+/", "\$1", $body));
     // using a template
     eval('$body="' . (self::$templates['header'] . ' ' . self::$templates['body'] . ' ' . self::$templates['footer']) . '";');
     eval('$body_plain="' . (self::$templates['header_plain'] . ' ' . self::$templates['body_plain'] . ' ' . self::$templates['footer_plain']) . '";');
     $crlf = "\r\n";
     $subject = self::mime_header_encode($subject);
     $hdrs = array('From' => $email_from, 'Subject' => $subject);
     $mime = new Mail_mime($crlf);
     $mime->setTXTBody($body_plain);
     $mime->setHTMLBody($body);
     $body = $mime->get();
     $hdrs = $mime->headers($hdrs);
     $mail =& Mail::factory('mail');
     return $mail->send($to, $hdrs, $body);
 }
Esempio n. 29
0
 public function send_email($toEmail, $subject, $template, $params = array())
 {
     include 'Mail.php';
     include 'Mail/mime.php';
     ob_start();
     include EMAILTEMPLATEDIR . '/' . $template;
     $msg = ob_get_clean();
     $text = strip_tags($msg);
     $html = $msg;
     $crlf = "\n";
     $hdrs = array('From' => FROM_EMAIL, 'Subject' => $subject);
     $mime = new Mail_mime($crlf);
     $mime->setTXTBody($text);
     $mime->setHTMLBody($html);
     $body = $mime->get();
     $hdrs = $mime->headers($hdrs);
     $mail =& Mail::factory('mail');
     $mail->send($toEmail, $hdrs, $body);
 }
Esempio n. 30
-1
 /**
  * Send the mail, based on the class' properties.
  *
  * @return bool
  */
 public function send()
 {
     // Validate properties and throw an exception for errors
     $this->validate();
     // Add text variant when only HTTML is provided
     if ($this->messageTxt === null) {
         $this->messageTxt = html_entity_decode($this->messageHtml);
     }
     // Send the mail
     $headers = ['From' => $this->from, 'Subject' => $this->subject];
     $mime = new \Mail_mime(PHP_EOL);
     $mime->setTXTBody($this->messageTxt);
     $mime->setHTMLBody($this->messageHtml);
     if (!empty($this->cc)) {
         foreach ($this->cc as $address) {
             $mime->addCc($address);
         }
     }
     if (!empty($this->bcc)) {
         foreach ($this->bcc as $address) {
             $mime->addBcc($address);
         }
     }
     $result = (new \Mail_mail())->send($this->address, $mime->headers($headers), $mime->get(['text_charset' => 'utf-8', 'html_charset' => 'utf-8']));
     return !is_a($result, 'PEAR_Error');
 }