/**
* Send mail, similar to PHP's mail
*
* A true return value does not automatically mean that the user received the
* email successfully. It just only means that the method used was able to
* process the request without any errors.
*
* Using the two 'wp_mail_from' and 'wp_mail_from_name' hooks allow from
* creating a from address like 'Name <*****@*****.**>' when both are set. If
* just 'wp_mail_from' is set, then just the email address will be used with no
* name.
*
* The default content type is 'text/plain' which does not allow using HTML.
* However, you can set the content type of the email by using the
* 'wp_mail_content_type' filter.
*
* The default charset is based on the charset used on the blog. The charset can
* be set using the 'wp_mail_charset' filter.
*
* @since 1.2.1
* @uses apply_filters() Calls 'wp_mail' hook on an array of all of the parameters.
* @uses apply_filters() Calls 'wp_mail_from' hook to get the from email address.
* @uses apply_filters() Calls 'wp_mail_from_name' hook to get the from address name.
* @uses apply_filters() Calls 'wp_mail_content_type' hook to get the email content type.
* @uses apply_filters() Calls 'wp_mail_charset' hook to get the email charset
*
* @param string|array $to Array or comma-separated list of email addresses to send message.
* @param string $subject Email subject
* @param string $message Message contents
* @param string|array $headers Optional. Additional headers.
* @param string|array $attachments Optional. Files to attach.
* @return bool Whether the email contents were sent successfully.
*/
function wp_mail($to, $subject, $message, $headers = '', $attachments = array())
{
$sendgrid = new SendGrid(get_option('sendgrid_user'), get_option('sendgrid_pwd'));
$mail = new SendGrid\Mail();
$method = get_option('sendgrid_api');
// Compact the input, apply the filters, and extract them back out
extract(apply_filters('wp_mail', compact('to', 'subject', 'message', 'headers', 'attachments')));
// prepare attachments
$attached_files = array();
if (!empty($attachments)) {
if (!is_array($attachments)) {
$pos = strpos(',', $attachments);
if (false !== $pos) {
$attachments = preg_split('/,\\s*/', $attachments);
} else {
$attachments = explode("\n", str_replace("\r\n", "\n", $attachments));
}
}
if (is_array($attachments)) {
foreach ($attachments as $attachment) {
if (file_exists($attachment)) {
$attached_files[] = $attachment;
}
}
}
}
// Headers
$cc = array();
$bcc = array();
if (empty($headers)) {
$headers = array();
} else {
if (!is_array($headers)) {
// Explode the headers out, so this function can take both
// string headers and an array of headers.
$tempheaders = explode("\n", str_replace("\r\n", "\n", $headers));
} else {
$tempheaders = $headers;
}
$headers = array();
// If it's actually got contents
if (!empty($tempheaders)) {
// Iterate through the raw headers
foreach ((array) $tempheaders as $header) {
if (false === strpos($header, ':')) {
if (false !== stripos($header, 'boundary=')) {
$parts = preg_split('/boundary=/i', trim($header));
$boundary = trim(str_replace(array("'", '"'), '', $parts[1]));
}
continue;
}
// Explode them out
list($name, $content) = explode(':', trim($header), 2);
// Cleanup crew
$name = trim($name);
$content = trim($content);
switch (strtolower($name)) {
// Mainly for legacy -- process a From: header if it's there
case 'from':
if (false !== strpos($content, '<')) {
// So... making my life hard again?
$from_name = substr($content, 0, strpos($content, '<') - 1);
$from_name = str_replace('"', '', $from_name);
$from_name = trim($from_name);
$from_email = substr($content, strpos($content, '<') + 1);
$from_email = str_replace('>', '', $from_email);
$from_email = trim($from_email);
} else {
$from_email = trim($content);
}
break;
case 'content-type':
if (false !== strpos($content, ';')) {
list($type, $charset) = explode(';', $content);
$content_type = trim($type);
if (false !== stripos($charset, 'charset=')) {
$charset = trim(str_replace(array('charset=', '"'), '', $charset));
} elseif (false !== stripos($charset, 'boundary=')) {
$boundary = trim(str_replace(array('BOUNDARY=', 'boundary=', '"'), '', $charset));
$charset = '';
}
} else {
$content_type = trim($content);
}
break;
case 'cc':
$cc = array_merge((array) $cc, explode(',', $content));
foreach ($cc as $key => $recipient) {
$cc[$key] = trim($recipient);
}
break;
case 'bcc':
$bcc = array_merge((array) $bcc, explode(',', $content));
foreach ($bcc as $key => $recipient) {
$bcc[$key] = trim($recipient);
}
break;
case 'reply-to':
$replyto = $content;
break;
default:
// Add it to our grand headers array
$headers[trim($name)] = trim($content);
break;
}
}
}
}
// From email and name
// If we don't have a name from the input headers
if (!isset($from_name)) {
$from_name = get_option('sendgrid_from_name');
}
/* If we don't have an email from the input headers default to wordpress@$sitename
* Some hosts will block outgoing mail from this address if it doesn't exist but
* there's no easy alternative. Defaulting to admin_email might appear to be another
* option but some hosts may refuse to relay mail from an unknown domain. See
* http://trac.wordpress.org/ticket/5007.
*/
if (!isset($from_email)) {
$from_email = trim(get_option('sendgrid_from_email'));
if (!$from_email) {
// Get the site domain and get rid of www.
$sitename = strtolower($_SERVER['SERVER_NAME']);
if ('www.' == substr($sitename, 0, 4)) {
$sitename = substr($sitename, 4);
}
$from_email = "wordpress@{$sitename}";
}
}
// Plugin authors can override the potentially troublesome default
$from_email = apply_filters('wp_mail_from', $from_email);
$from_name = apply_filters('wp_mail_from_name', $from_name);
// Set destination addresses
if (!is_array($to)) {
$to = explode(',', $to);
}
// Add any CC and BCC recipients
if (!empty($cc)) {
foreach ((array) $cc as $key => $recipient) {
// Break $recipient into name and address parts if in the format "Foo <*****@*****.**>"
if (preg_match('/(.*)<(.+)>/', $recipient, $matches)) {
if (count($matches) == 3) {
$cc[$key] = trim($matches[2]);
}
}
}
}
if (!empty($bcc)) {
foreach ((array) $bcc as $key => $recipient) {
// Break $recipient into name and address parts if in the format "Foo <*****@*****.**>"
if (preg_match('/(.*)<(.+)>/', $recipient, $matches)) {
if (3 == count($matches)) {
$bcc[$key] = trim($matches[2]);
}
}
}
}
if ('api' == $method and (count($cc) or count($bcc))) {
foreach ((array) $to as $key => $recipient) {
// Break $recipient into name and address parts if in the format "Foo <*****@*****.**>"
if (preg_match('/(.*)<(.+)>/', $recipient, $matches)) {
if (3 == count($matches)) {
$to[$key] = trim($matches[2]);
}
}
}
}
// Set Content-Type and charset
// If we don't have a content-type from the input headers
if (!isset($content_type)) {
$content_type = 'text/plain';
}
$content_type = apply_filters('wp_mail_content_type', $content_type);
$mail->setTos($to)->setSubject($subject)->setText($message)->setCategory(SENDGRID_CATEGORY)->setFrom($from_email);
$categories = explode(',', get_option('sendgrid_categories'));
foreach ($categories as $category) {
$mail->addCategory($category);
}
// send HTML content
if ('text/plain' !== $content_type) {
$mail->setHtml($message);
}
// set from name
if ($from_email) {
$mail->setFromName($from_name);
}
// set from cc
if (count($cc)) {
$mail->setCcs($cc);
}
// set from bcc
if (count($bcc)) {
$mail->setBccs($bcc);
}
if (!isset($replyto)) {
$replyto = trim(get_option('sendgrid_reply_to'));
}
$reply_to_found = preg_match('/.*<(.*)>.*/i', $replyto, $result);
if ($reply_to_found) {
$replyto = $result[1];
}
$mail->setReplyTo($replyto);
// add attachemnts
if (count($attached_files)) {
$mail->setAttachments($attached_files);
}
// Send!
try {
if ('api' == $method) {
return $sendgrid->web->send($mail);
} elseif ('smtp' == $method) {
if (class_exists('Swift')) {
return $sendgrid->smtp->send($mail);
} else {
return 'Error: Swift Class not loaded. Please activate Swift plugin or use API.';
}
}
} catch (Exception $e) {
return $e->getMessage();
}
return false;
}
public function testSendResponse()
{
$sendgrid = new SendGrid("foo", "bar");
$message = new SendGrid\Mail();
$message->setFrom('*****@*****.**')->setSubject('foobar subject')->setText('foobar text')->addTo('*****@*****.**');
$response = $sendgrid->web->send($message);
$this->assertEquals("{\"message\": \"error\", \"errors\": [\"Bad username / password\"]}", $response);
}
public function testAddToWithDeprectedMailClass()
{
$mail = new SendGrid\Mail();
$mail->addTo('*****@*****.**');
$this->assertEquals(array('*****@*****.**'), $mail->getTos());
$mail->addTo('*****@*****.**');
$this->assertEquals(array('*****@*****.**', '*****@*****.**'), $mail->getTos());
}
public function testEmailTextBodyAttachments()
{
$_mapToSwift = new ReflectionMethod('SendGrid\\Smtp', '_mapToSwift');
$_mapToSwift->setAccessible(true);
$sendgrid = new SendGrid("foo", "bar");
$message = new SendGrid\Mail();
$message->setFrom('*****@*****.**')->setFromName('John Doe')->setSubject('foobar subject')->setText('foobar text')->addTo('*****@*****.**');
$swift_message = $_mapToSwift->invoke($sendgrid->smtp, $message);
$this->assertEquals(count($swift_message->getChildren()), 0);
}
public function testConstruction()
{
$sendgrid = new SendGrid("foo", "bar");
$smtp = $sendgrid->smtp;
$this->assertEquals(new SendGrid\Smtp("foo", "bar"), $smtp);
$message = new SendGrid\Mail();
$message->setFrom('*****@*****.**')->setSubject('foobar subject')->setText('foobar text')->addTo('*****@*****.**')->addAttachment("mynewattachment.jpg");
$this->assertEquals(get_class($smtp), 'SendGrid\\Smtp');
$this->setExpectedException('Swift_TransportException');
$smtp->send($message);
}
public static function SendEmail($sTo, $sSubject, $sTemplate, $sVariable)
{
global $sPanelURL;
global $sPanelMode;
global $sTitle;
global $locale;
$sEmail = Templater::AdvancedParse('/email/' . $sTemplate, $locale->strings, array("EmailVars" => array("entry" => $sVariable)));
$sMail = Core::GetSetting('mail');
$sMail = $sMail->sValue;
if ($sMail == 1) {
$sSendGridUser = Core::GetSetting('mail_username');
$sSendGridPass = Core::GetSetting('mail_password');
$sSendGridUser = $sSendGridUser->sValue;
$sSendGridPass = $sSendGridPass->sValue;
if (!empty($sSendGridUser) && !empty($sSendGridPass)) {
$sGrid = new SendGrid($sSendGridUser, $sSendGridPass);
$sMail = new SendGrid\Mail();
$sMail->addTo($sTo)->setFrom("noreply@{$sPanelURL->sValue}")->setSubject($sSubject)->setHtml($sEmail);
$sGrid->web->send($sMail);
return true;
} else {
return $sReturn = array("content" => "Unfortunately Send Grid is incorrectly configured!");
}
} elseif ($sMail == 2) {
$sMandrillUser = Core::GetSetting('mail_username');
$sMandrillPass = Core::GetSetting('mail_password');
$sMandrillUser = $sMandrillUser->sValue;
$sMandrillPass = $sMandrillPass->sValue;
try {
$sMandrill = new Mandrill($sMandrillPass);
$sMessage = array('html' => $sEmail, 'subject' => $sSubject, 'from_email' => "noreply@{$sPanelURL->sValue}", 'from_name' => "{$sTitle->sValue}", 'to' => array(array('email' => $sTo, 'type' => 'to')), 'important' => true, 'track_opens' => null, 'track_clicks' => null, 'auto_text' => null, 'auto_html' => null, 'inline_css' => null, 'url_strip_qs' => null, 'preserve_recipients' => null, 'view_content_link' => null, 'tracking_domain' => null, 'signing_domain' => null, 'return_path_domain' => null, 'merge' => true);
$sAsync = false;
$sIPPool = 'Main Pool';
$sSendAt = NULL;
$sResult = $sMandrill->messages->send($sMessage, $sAsync, $sIPPool, $sSendAt);
} catch (Exception $e) {
return $sReturn = array("content" => "Mandril Error: {$e}");
}
return true;
} else {
$sHeaders = "MIME-Version: 1.0" . "\r\n";
$sHeaders .= "Content-type:text/html;charset=iso-8859-1" . "\r\n";
$sHeaders .= 'From: <noreply@' . $sPanelURL->sValue . '>' . "\r\n";
if (mail($sTo, $sSubject, $sEmail, $sHeaders)) {
return true;
} else {
return $sReturn = array("content" => "Unfortunatly the email failed to send, please check your server's sendmail settings.");
}
}
}
/**
* https://github.com/sendgrid/sendgrid-php/blob/master/examples/helpers/mail/example.php
*/
function send(array $params = [], &$error_message = '')
{
require_php_lib('sendgrid');
$error_message = null;
try {
$sg = new \SendGrid($this->key);
$from = new SendGrid\Email($params['name_from'], $params['email_from']);
$subject = $params['subject'];
$to = new SendGrid\Email($params['name_to'], $params['email_to']);
$text_content = new SendGrid\Content('text/plain', $params['text']);
$mail = new SendGrid\Mail($from, $subject, $to, $text_content);
$html_content = new SendGrid\Content('text/html', $params['html']);
$mail->addContent($html_content);
if ($params['reply_to']) {
$reply_to = new SendGrid\ReplyTo($params['reply_to']);
$mail->setReplyTo($reply_to);
}
if ($this->PARENT->ALLOW_ATTACHMENTS) {
foreach ((array) $params['attaches'] as $name => $file) {
$attachment = new SendGrid\Attachment();
$attachment->setContent(file_get_contents($file));
$attachment->setFilename($name);
$mail->addAttachment($attachment);
}
}
$response = $sg->client->mail()->send()->post($mail);
} catch (Exception $e) {
$error_message = 'A sendgrid error occurred: ' . get_class($e) . ' - ' . $e->getMessage();
}
if (@$error_message && DEBUG_MODE && $this->PARENT->MAIL_DEBUG_ERROR) {
trigger_error($error_message, E_USER_WARNING);
}
if (is_callable($params['on_after_send'])) {
$callback = $params['on_after_send'];
$callback($mail, $params, $result, $error_message, $this->PARENT);
}
$this->PARENT->_last_error_message = $error_message;
return $response && !$error_message ? true : false;
}
function sendPlain($to, $from, $subject, $plainContent, $attachedFiles = false, $customheaders = false)
{
$mail = new SendGrid\Mail(SENDGRIDMAILER_USERNAME, SENDGRIDMAILER_PASSWORD);
$sendgrid = $this->instantiate();
if (!$from) {
$from = SENDGRIDMAILER_MAIL;
}
$from_name = preg_replace('/"*(.*)"*\\<(.*)\\>/i', '$1', $from);
if ($from_name) {
$from = preg_replace('/"*(.*)"*\\<(.*)\\>/i', '$2', $from);
}
$mail->addTo($to)->setFromName($from_name)->setFrom($from)->setSubject($subject)->setText($plainContent);
$response = $sendgrid->web->send($mail);
SS_Log::log("{$to} | {$from} | {$from_name} | " . json_encode($response), SS_Log::INFO);
if ($response->message == "error") {
return false;
}
if ($response->message == "success") {
return true;
}
return false;
}
function _cdashsendgrid($to, $subject, $body)
{
global $CDASH_EMAIL_FROM, $CDASH_EMAIL_REPLY, $CDASH_SENDGRID_API_KEY;
$sg = new \SendGrid($CDASH_SENDGRID_API_KEY);
$mail = new SendGrid\Mail();
$mail->setFrom(new SendGrid\Email(null, $CDASH_EMAIL_FROM));
$mail->setSubject($subject);
$mail->setReplyTo(new SendGrid\Email(null, $CDASH_EMAIL_REPLY));
$mail->addContent(new SendGrid\Content('text/plain', $body));
foreach (explode(', ', $to) as $recipient) {
$personalization = new SendGrid\Personalization();
$personalization->addTo(new SendGrid\Email(null, $recipient));
$mail->addPersonalization($personalization);
}
$response = $sg->client->mail()->send()->post($mail);
if ($response->statusCode() === 202) {
return true;
} else {
add_log('Failed to send email via sendgrid status code: ' . $response->statusCode(), '_cdashsendgrid', LOG_ERR);
return false;
}
}
public function testUseHeaders()
{
$mail = new SendGrid\Mail();
$mail->addTo('*****@*****.**')->addBcc('*****@*****.**')->setFrom('*****@*****.**')->setSubject('Subject')->setHtml('Hello You');
$this->assertFalse($mail->useHeaders());
$mail->removeBcc('*****@*****.**');
$this->assertTrue($mail->useHeaders());
$mail->addCc('*****@*****.**');
$this->assertFalse($mail->useHeaders());
$mail->removeCc('*****@*****.**')->setRecipientsinHeader(true);
$this->assertTrue($mail->useHeaders());
$mail->setRecipientsinHeader(false);
$this->assertFalse($mail->useHeaders());
$mail->addBcc('*****@*****.**')->addAttachment('attachment.ext');
$this->assertTrue($mail->useHeaders());
}
/**
*
* @param $tos an array containing to addresses, is required.
* @param from : sender's email address, is required
* @param fromName : human friendly sender's name
* @param subject required
* @param text - text content of mail, is required
* @param html - html content of mail, is required
*
* @return return value of zero indicates success
* A non zero return value indicates failure.
*
*/
static function sendViaWeb($tos, $from, $fromName, $subject, $text, $html)
{
$mode = Config::getInstance()->get_value("sendgrid.mail.mode");
if (strcmp($mode, "production") != 0) {
$recipients = implode($tos, ",");
$message = sprintf("\n\n **** mail to %s **** \n %s \n\n", $recipients, $text);
Logger::getInstance()->info($message);
return;
}
$login = Config::getInstance()->get_value("sendgrid.login");
$password = Config::getInstance()->get_value("sendgrid.password");
if (empty($login) || empty($password) || empty($tos) || empty($from) || empty($text) || empty($html)) {
//bad input
return self::BAD_INPUT_ERROR;
}
// SendGrid PHP LIB path should be included before
// webgloo libraries for this to work
$sendgrid = new \SendGrid($login, $password);
$mail = new \SendGrid\Mail();
$fromName = empty($fromName) ? $from : $fromName;
$mail->setTos($tos)->setFrom($from)->setFromName($fromName)->setSubject($subject)->setText($text)->setHtml($html);
/*
* response handling.
* CURLOPT_RETURNTRANSFER option is set in SendGrid/Web#send()
* that method will return the result on success, FALSE on failure
*
* @see http://docs.sendgrid.com/documentation/api/web-api/#responseserror
* {"message":"error","errors":[]}
*
* @see http://docs.sendgrid.com/documentation/api/web-api/#responsessuccess
* {"message":"success"}
*
*/
$response = $sendgrid->web->send($mail);
if ($response === FALSE) {
//problem with curl transport
$message = " Error communicating with sendgrid mail endpoint";
Logger::getInstance()->error($message);
return self::CURL_ERROR;
}
//parse response json
$responseObj = json_decode($response);
if (!is_object($responseObj) || !property_exists($responseObj, "message")) {
//bad json from sendgrid
$message = sprintf("Sendgrid mail api response :: [[%s]] is malformed", $response);
Logger::getInstance()->error($message);
return self::MALFORMED_RESPONSE;
}
$message = $responseObj->message;
if (strcasecmp($message, "error") == 0) {
//sendgrid returned error.
//get errors array
$message = " Sendgrid mail api returned error";
Logger::getInstance()->error($message);
foreach ($responseObj->errors as $error) {
Logger::getInstance()->error($error);
}
return self::SENDGRID_ERROR;
}
if (strcasecmp($message, "success") == 0) {
//success
return 0;
}
return self::UNKNOWN_ERROR;
}
include 'email_validation.php';
$name = stripslashes($_POST['name']);
$email = trim($_POST['email']);
$subject = stripslashes($_POST['subject']);
$message = stripslashes($_POST['message']);
$error = '';
// Check name
if (!$name) {
$error .= 'Please enter your name.<br />';
}
// Check email
if (!$email) {
$error .= 'Please enter an e-mail address.<br />';
}
if ($email && !ValidateEmail($email)) {
$error .= 'Please enter a valid e-mail address.<br />';
}
// Check message (length)
if (!$message || strlen($message) < 10) {
$error .= "Please enter your message. It should have at least 10 characters.<br />";
}
if (!$error) {
$mail = new SendGrid\Mail();
$mail->addTo('*****@*****.**')->setFrom($email)->setFromName($name)->setSubject($subject)->setText($message);
if ($sendgrid->smtp->send($mail)) {
echo 'OK';
}
} else {
echo '<div class="notification_error">' . $error . '</div>';
}
}
* - Upload it to a web host and load mywebhost.com/sendnotifications.php
* in a web browser.
* - Download a local server like WAMP, MAMP or XAMPP. Point the web root
* directory to the folder containing this file, and load
* localhost:8888/sendnotifications.php in a web browser.
*/
// Step 1: Download the Twilio-PHP library from twilio.com/docs/libraries,
// and move it into the folder containing this file.
require "Services/Twilio.php";
// Step 2: set our AccountSid and AuthToken from www.twilio.com/user/account
$AccountSid = "ACeca28c70e4a3d5d4bea2e1be2f608876";
$AuthToken = "474465c0bacbb4f013c39ef1da106cc6";
// Step 3: instantiate a new Twilio Rest Client
$client = new Services_Twilio($AccountSid, $AuthToken);
// Step 4: make an array of people we know, to send them a message.
// Feel free to change/add your own phone number and name here.
$people = array($phone => $name);
// Step 5: Loop over all our friends. $number is a phone number above, and
// $name is the name next to it
foreach ($people as $number => $name) {
$sms = $client->account->sms_messages->create("408-514-5160", $number, "Hey " . $name . ", " . $descript . "\n-From " . $user);
}
}
include 'sendgrid-php-master/SendGrid_loader.php';
$sendgrid = new SendGrid('YeshRam', 'yeshrameshiscool');
$mail = new SendGrid\Mail();
$mail->addTo($email)->setFrom($yremail)->setSubject('Message From ' . $user . ' with TwilioAndSendgrid Script')->setText($descript)->setHtml('<strong>' . $descript . '</strong>');
$sendgrid->web->send($mail);
?>
</body>
</html>
