/**
* Send mail
*
* @params CakeEmail $email
* @return array
*/
public function send(CakeEmail $email)
{
$post = array();
$post_preprocess = array_merge($email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc', 'subject')), array('text' => $email->message(CakeEmail::MESSAGE_TEXT), 'html' => $email->message(CakeEmail::MESSAGE_HTML)));
foreach ($post_preprocess as $k => $v) {
if (!empty($v)) {
$post[strtolower($k)] = $v;
}
}
$ch = curl_init('https://api.mailgun.net/v2/' . $this->_config['mailgun_domain'] . '/messages');
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_USERPWD, 'api:' . $this->_config['api_key']);
curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
$response = curl_exec($ch);
if ($response === false) {
throw new SocketException("Curl had an error. Message: " . curl_error($ch), 500);
}
$http_status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
if ($http_status != 200) {
throw new SocketException("Mailgun request failed. Status: {$http_status}, Response: {$response}", 500);
}
curl_close($ch);
return array('headers' => $this->_headersToString($email->getHeaders(), PHP_EOL), 'message' => implode(PHP_EOL, $email->message()));
}
/**
* Sends out email via Mandrill
*
* @return array Return the Mandrill
*/
public function send(CakeEmail $email)
{
$this->_Email = $email;
$this->_config = $this->_Email->config() + (array) Configure::read('Mandrill');
if (empty($this->_config['apiKey'])) {
throw new InternalErrorException('No API key');
}
if (empty($this->_config['uri'])) {
$this->_config['uri'] = static::API_URL;
}
$include = ['from', 'to', 'cc', 'bcc', 'replyTo', 'subject'];
$this->_headers = $this->_Email->getHeaders($include);
$message = $this->_buildMessage();
$request = ['header' => ['Accept' => 'application/json', 'Content-Type' => 'application/json']];
$template = $this->_Email->template();
if ($template['template'] && !empty($this->_config['useTemplate'])) {
$messageUri = $this->_config['uri'] . "messages/send-template.json";
} else {
$messageUri = $this->_config['uri'] . "messages/send.json";
}
// Perform the http connection
$returnMandrill = $this->_post($messageUri, $message, $request);
// Parse mandrill results
$result = json_decode($returnMandrill, true);
if (!empty($this->_config['log'])) {
CakeLog::write('mandrill', print_r($result, true));
}
$headers = $this->_headersToString($this->_headers);
return array_merge(['Mandrill' => $result], ['headers' => $headers, 'message' => $message]);
}
/**
* Sends out email via Mandrill
*
* @param CakeEmail $email
* @return array
*/
public function send(CakeEmail $email)
{
// CakeEmail
$this->_cakeEmail = $email;
$from = $this->_cakeEmail->from();
list($fromEmail) = array_keys($from);
$fromName = $from[$fromEmail];
$this->_config = $this->_cakeEmail->config();
$this->_headers = $this->_cakeEmail->getHeaders();
$message = array('html' => $this->_cakeEmail->message('html'), 'text' => $this->_cakeEmail->message('text'), 'subject' => mb_decode_mimeheader($this->_cakeEmail->subject()), 'from_email' => $fromEmail, 'from_name' => $fromName, 'to' => array(), 'headers' => array('Reply-To' => $fromEmail), 'important' => false, '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, 'tags' => null, 'subaccount' => null);
$message = array_merge($message, $this->_headers);
foreach ($this->_cakeEmail->to() as $email => $name) {
$message['to'][] = array('email' => $email, 'name' => $name, 'type' => 'to');
}
foreach ($this->_cakeEmail->cc() as $email => $name) {
$message['to'][] = array('email' => $email, 'name' => $name, 'type' => 'cc');
}
foreach ($this->_cakeEmail->bcc() as $email => $name) {
$message['to'][] = array('email' => $email, 'name' => $name, 'type' => 'bcc');
}
$attachments = $this->_cakeEmail->attachments();
if (!empty($attachments)) {
$message['attachments'] = array();
foreach ($attachments as $file => $data) {
$message['attachments'][] = array('type' => $data['mimetype'], 'name' => $file, 'content' => base64_encode(file_get_contents($data['file'])));
}
}
$params = array('message' => $message, "async" => false, "ip_pool" => null, "send_at" => null);
return $this->_exec($params);
}
/**
* Sends out email via Mandrill
*
* @return array Return the Mandrill
*/
public function send(CakeEmail $email)
{
// CakeEmail
$this->_cakeEmail = $email;
$this->_config = $this->_cakeEmail->config();
$this->_headers = $this->_cakeEmail->getHeaders(array('from', 'to', 'cc', 'bcc', 'replyTo', 'subject'));
// Setup connection
$this->__mandrillConnection =& new HttpSocket();
// Build message
$message = $this->__buildMessage();
// Build request
$request = $this->__buildRequest();
if (isset($this->_config['mandrillTemplate']) && !empty($this->_config['mandrillTemplate'])) {
$message_send_uri = $this->_config['uri'] . "messages/send-template.json";
} else {
$message_send_uri = $this->_config['uri'] . "messages/send.json";
}
// Send message
try {
$returnMandrill = $this->__mandrillConnection->post($message_send_uri, json_encode($message), $request);
// Return data
$result = json_decode($returnMandrill, true);
$headers = $this->_headersToString($this->_headers);
return array_merge(array('Mandrill' => $result), array('headers' => $headers, 'message' => $message));
} catch (Exception $e) {
return false;
}
}
/**
* Sends out email via SparkPost
*
* @param CakeEmail $email
* @return array
*/
public function send(CakeEmail $email)
{
// CakeEmail
$this->_cakeEmail = $email;
$this->_config = $this->_cakeEmail->config();
$this->_headers = $this->_cakeEmail->getHeaders();
// Not allowed by SparkPost
unset($this->_headers['Content-Type']);
unset($this->_headers['Content-Transfer-Encoding']);
unset($this->_headers['MIME-Version']);
unset($this->_headers['X-Mailer']);
$from = $this->_cakeEmail->from();
list($fromEmail) = array_keys($from);
$fromName = $from[$fromEmail];
$message = ['html' => $this->_cakeEmail->message('html'), 'text' => $this->_cakeEmail->message('text'), 'from' => ['name' => $fromName, 'email' => $fromEmail], 'subject' => mb_decode_mimeheader($this->_cakeEmail->subject()), 'recipients' => [], 'transactional' => true];
foreach ($this->_cakeEmail->to() as $email => $name) {
$message['recipients'][] = ['address' => ['email' => $email, 'name' => $name], 'tags' => $this->_headers['tags']];
}
foreach ($this->_cakeEmail->cc() as $email => $name) {
$message['recipients'][] = ['address' => ['email' => $email, 'name' => $name], 'tags' => $this->_headers['tags']];
}
foreach ($this->_cakeEmail->bcc() as $email => $name) {
$message['recipients'][] = ['address' => ['email' => $email, 'name' => $name], 'tags' => $this->_headers['tags']];
}
unset($this->_headers['tags']);
$attachments = $this->_cakeEmail->attachments();
if (!empty($attachments)) {
$message['attachments'] = array();
foreach ($attachments as $file => $data) {
if (!empty($data['contentId'])) {
$message['inlineImages'][] = array('type' => $data['mimetype'], 'name' => $data['contentId'], 'data' => base64_encode(file_get_contents($data['file'])));
} else {
$message['attachments'][] = array('type' => $data['mimetype'], 'name' => $file, 'data' => base64_encode(file_get_contents($data['file'])));
}
}
}
$message = array_merge($message, $this->_headers);
// Load SparkPost configuration settings
$config = ['key' => $this->_config['sparkpost']['api_key']];
if (isset($this->_config['sparkpost']['timeout'])) {
$config['timeout'] = $this->_config['sparkpost']['timeout'];
}
// Set up HTTP request adapter
$httpAdapter = new Ivory\HttpAdapter\Guzzle6HttpAdapter($this->__getClient());
// Create SparkPost API accessor
$sparkpost = new SparkPost\SparkPost($httpAdapter, $config);
// Send message
try {
return $sparkpost->transmission->send($message);
} catch (SparkPost\APIResponseException $e) {
// TODO: Determine if BRE is the best exception type
throw new BadRequestException(sprintf('SparkPost API error %d (%d): %s (%s)', $e->getAPICode(), $e->getCode(), ucfirst($e->getAPIMessage()), $e->getAPIDescription()));
}
}
/**
* Sends out email via SendGrid
*
* @return bool
*/
public function send(CakeEmail $email)
{
// CakeEmail
$this->_cakeEmail = $email;
$this->_config = $this->_cakeEmail->config();
if (empty($this->_config['count']) || $this->_config['count'] > 500) {
$this->_config['count'] = 500;
}
$this->_headers = $this->_cakeEmail->getHeaders();
$this->_recipients = $email->to();
$this->_replyTo = $email->replyTo();
return $this->_sendPart();
}
/**
* Prepares the data array.
*
* @return void
*/
protected function _prepareData()
{
$headers = $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'subject'));
if ($headers['Sender'] == '') {
$headers['Sender'] = $headers['From'];
}
$headers = $this->_headersToString($headers);
$message = implode("\r\n", $this->_cakeEmail->message());
$this->_data = array('Data' => base64_encode($headers . "\r\n\r\n" . $message . "\r\n\r\n\r\n."));
$this->_dataOptions = array('Source' => key($this->_cakeEmail->from()), 'Destinations' => array());
$this->_dataOptions['Destinations'] += array_keys($this->_cakeEmail->to());
$this->_dataOptions['Destinations'] += array_keys($this->_cakeEmail->cc());
$this->_dataOptions['Destinations'] += array_keys($this->_cakeEmail->bcc());
$this->_content = array('headers' => $headers, 'message' => $message);
}
/**
* Send mail
*
* @param CakeEmail $email CakeEmail
* @return array
*/
public function send(CakeEmail $email)
{
$headers = $email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'subject'));
$headers = $this->_headersToString($headers);
$message = implode("\r\n", (array) $email->message());
return array('headers' => $headers, 'message' => $message);
}
/**
* Prepares the data array.
* Adds headers and content
*
* @return void
*/
protected function _prepareData()
{
$this->_data = array();
if (count($this->_cakeEmail->cc()) > 0) {
throw new CakeException('Postageapp transport does not support cc');
}
if (count($this->_cakeEmail->bcc()) > 0) {
throw new CakeException('Postageapp transport does not support bcc');
}
if (count($this->_cakeEmail->sender()) > 0) {
throw new CakeException('Postageapp transport does not support sender');
}
$headers = $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'returnPath', 'to', 'subject'));
$this->_data['recipients'] = $headers['To'];
$map = array('From', 'Subject', 'Reply-To', 'X-Mailer', 'MIME-Version', 'Content-Transfer-Encoding');
foreach ($map as $header) {
if (!empty($headers[$header])) {
$this->_addHeader($header, $headers[$header]);
}
}
$emailFormat = $this->_cakeEmail->emailFormat();
if ($emailFormat == 'both' || $emailFormat == 'text') {
$this->_data['content']['text/plain'] = $this->_cakeEmail->message('text');
}
if ($emailFormat == 'both' || $emailFormat == 'html') {
$this->_data['content']['text/html'] = $this->_cakeEmail->message('html');
}
}
/**
* Send email via Mailgun
*
* @param CakeEmail $email
* @return array
* @throws Exception
*/
public function send(CakeEmail $email)
{
if (Configure::read('Mailgun.preventManyToRecipients') !== false && count($email->to()) > 1) {
throw new Exception('More than one "to" recipient not allowed (set Mailgun.preventManyToRecipients = false to disable check)');
}
$mgClient = new Mailgun($this->_config['mg_api_key']);
$headersList = array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc', 'subject');
$params = [];
foreach ($email->getHeaders($headersList) as $header => $value) {
if (isset($this->_paramMapping[$header]) && !empty($value)) {
$key = $this->_paramMapping[$header];
$params[$key] = $value;
}
}
$params['text'] = $email->message(CakeEmail::MESSAGE_TEXT);
$params['html'] = $email->message(CakeEmail::MESSAGE_HTML);
$attachments = array();
foreach ($email->attachments() as $name => $info) {
$attachments['attachment'][] = '@' . $info['file'];
}
try {
$result = $mgClient->sendMessage($this->_config['mg_domain'], $params, $attachments);
if ($result->http_response_code != 200) {
throw new Exception($result->http_response_body->message);
}
} catch (Exception $e) {
throw $e;
}
return $result;
}
/**
* testPostmarkSend method
*
* @return void
*/
public function testPostmarkSend()
{
$this->email->config('postmark');
$this->email->template('default', 'default');
$this->email->emailFormat('html');
$this->email->from(array('*****@*****.**' => 'Your Name'));
$this->email->to(array('*****@*****.**' => 'Recipient'));
$this->email->cc(array('*****@*****.**' => 'Recipient'));
$this->email->bcc(array('*****@*****.**' => 'Recipient'));
$this->email->subject('Test Postmark');
$this->email->addHeaders(array('Tag' => 'my tag'));
$this->email->attachments(array('cake.icon.png' => array('file' => WWW_ROOT . 'img' . DS . 'cake.icon.png')));
$sendReturn = $this->email->send();
$headers = $this->email->getHeaders(array('to'));
$this->assertEqual($sendReturn['To'], $headers['To']);
$this->assertEqual($sendReturn['ErrorCode'], 0);
$this->assertEqual($sendReturn['Message'], 'OK');
}
/**
* Send Data
*
* @return void
* @throws SocketException
*/
protected function _sendData()
{
$this->_smtpSend('DATA', '354');
$headers = $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'subject'));
$headers = $this->_headersToString($headers);
$message = implode("\r\n", $this->_cakeEmail->message());
$this->_smtpSend($headers . "\r\n\r\n" . $message . "\r\n\r\n\r\n.");
$this->_content = array('headers' => $headers, 'message' => $message);
}
/**
* Send
*
* A bit of a misnomer, because this actually just adds it to a CakeResque
* queue. The actual sending of the email will be performed later by a worker.
*
* @params CakeEmail $email
* @return array
*/
public function send(CakeEmail $email)
{
// Take a copy of the existing configuration.
$config = array('headers' => $email->getHeaders(), 'from' => $email->from(), 'sender' => $email->sender(), 'replyTo' => $email->replyTo(), 'readReceipt' => $email->readReceipt(), 'returnPath' => $email->returnPath(), 'to' => $email->to(), 'cc' => $email->cc(), 'bcc' => $email->bcc(), 'subject' => $email->subject(), 'viewRender' => $email->viewRender(), 'viewVars' => $email->viewVars(), 'emailFormat' => $email->emailFormat(), 'messageId' => $email->messageId(), 'attachments' => $email->attachments());
// unset($config['config']['transport']);
$template = $email->template();
$config['template'] = $template['template'];
$config['layout'] = $template['layout'];
// Clean it up to avoid errors.
$config = array_filter($config, function ($v) {
return (bool) $v;
});
debug($config);
// Include a message, if they sent one via plain text.
$message = $email->message(CakeEmail::MESSAGE_HTML) ? null : $email->message(CakeEmail::MESSAGE_TEXT);
// Drop it in a queue.
Resque::enqueue('email', 'ResqueEmail.EmailShell', array('send', $config, $message));
return array('headers' => $email->getHeaders(), 'message' => $email->message());
}
/**
* Send
*
* @param CakeEmail $email objeto mail
* @return array
* @throws SocketException
*/
public function send(CakeEmail $email)
{
$http = new HttpSocket();
$url = 'https://api.mailgun.net/v2/' . $this->_config['mailgun_domain'] . '/messages';
$post = array();
$postPreprocess = array_merge($email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc', 'subject')), array('text' => $email->message(CakeEmail::MESSAGE_TEXT), 'html' => $email->message(CakeEmail::MESSAGE_HTML)));
foreach ($postPreprocess as $k => $v) {
if (!empty($v)) {
$post[strtolower($k)] = $v;
}
}
$request = array('auth' => array('method' => 'Basic', 'user' => 'api', 'pass' => $this->_config['api_key']));
$response = $http->post($url, $post, $request);
if ($response === false) {
throw new SocketException("Mailgun BasicTransport error, no response", 500);
}
$httpStatus = $response->code;
if ($httpStatus != 200) {
throw new SocketException("Mailgun request failed. Status: {$httpStatus}, Response: {$response->body}", 500);
}
return array('headers' => $this->_headersToString($email->getHeaders(), PHP_EOL), 'message' => implode(PHP_EOL, $email->message()));
}
/**
* Sends out email via Mandrill
*
* @param $email
* @return array Return the Mandrill
*/
public function send(CakeEmail $email)
{
//todo:check restricted_emails
$this->_cakeEmail = $email;
$this->_config = $this->_cakeEmail->config();
$this->_headers = $this->_cakeEmail->getHeaders(array('from', 'to', 'cc', 'bcc', 'replyTo', 'subject'));
// Setup connection
$this->__mandrillConnection =& new HttpSocket();
$message = $this->__buildMessage();
$request = array('header' => array('Accept' => 'application/json', 'Content-Type' => 'application/json'));
if ($this->_cakeEmail->template()['template']) {
$message_send_uri = $this->_config['uri'] . "messages/send-template.json";
} else {
$message_send_uri = $this->_config['uri'] . "messages/send.json";
}
//perform the http connection
$returnMandrill = $this->__mandrillConnection->post($message_send_uri, json_encode($message), $request);
//parse mandrill results
$result = json_decode($returnMandrill, true);
$headers = $this->_headersToString($this->_headers);
return array_merge(array('Mandrill' => $result), array('headers' => $headers, 'message' => $message));
}
/**
* Sends out email via Postmark
*
* @return array Return the Postmark
*/
public function send(CakeEmail $email)
{
// CakeEmail
$this->_cakeEmail = $email;
$this->_config = $this->_cakeEmail->config();
$this->_headers = $this->_cakeEmail->getHeaders(array('from', 'to', 'cc', 'bcc', 'replyTo', 'subject'));
// Setup connection
$this->__postmarkConnection =& new HttpSocket();
// Build message
$message = $this->__buildMessage();
// Build request
$request = $this->__buildRequest();
// Send message
$returnPostmark = $this->__postmarkConnection->post($this->_config['uri'], json_encode($message), $request);
// Return data
$result = json_decode($returnPostmark, true);
$headers = $this->_headersToString($this->_headers);
if ($this->_cakeEmail->emailFormat() === 'html') {
$message = $message['HtmlBody'];
} else {
$message = $message['TextBody'];
}
return array_merge(array('Postmark' => $result), array('headers' => $headers, 'message' => $message));
}
/**
* Prepares the data array.
* Adds headers and content
*
* @return void
*/
protected function _prepareData()
{
$this->_data = array();
$headers = $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'returnPath', 'to', 'cc', 'bcc', 'subject'));
$map = array('From', 'To', 'Cc', 'Bcc', 'Subject');
foreach ($map as $header) {
if (!empty($headers[$header])) {
$this->_data[$header] = $headers[$header];
}
}
if (!empty($headers['Reply-To'])) {
$this->_data['ReplyTo'] = $headers['Reply-To'];
}
$tag = false;
if (isset($headers['X-Tag'])) {
$tag = $headers['X-Tag'];
} elseif (isset($this->_config['tag'])) {
$tag = $this->_config['tag'];
}
if ($tag !== false) {
$this->_data['Tag'] = $this->_config['tag'];
}
$map = array('X-Mailer', 'MIME-Version', 'Content-Transfer-Encoding');
foreach ($map as $header) {
if (!empty($headers[$header])) {
$this->_addHeader($header, $headers[$header]);
}
}
$emailFormat = $this->_cakeEmail->emailFormat();
if ($emailFormat == 'both' || $emailFormat == 'text') {
$this->_data['TextBody'] = $this->_cakeEmail->message('text');
}
if ($emailFormat == 'both' || $emailFormat == 'html') {
$this->_data['HtmlBody'] = $this->_cakeEmail->message('html');
}
}
/**
* Send mail
*
* @param CakeEmail $email CakeEmail
* @return array
* @throws SocketException When mail cannot be sent.
*/
public function send(CakeEmail $email)
{
$eol = PHP_EOL;
if (isset($this->_config['eol'])) {
$eol = $this->_config['eol'];
}
$headers = $email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc'));
$to = $headers['To'];
unset($headers['To']);
$headers = $this->_headersToString($headers, $eol);
$message = implode($eol, $email->message());
$params = isset($this->_config['additionalParameters']) ? $this->_config['additionalParameters'] : null;
$this->_mail($to, $email->subject(), $message, $headers, $params);
return array('headers' => $headers, 'message' => $message);
}
/**
* Send mail
*
* @params object $email CakeEmail
* @return boolean
*/
public function send(CakeEmail $email)
{
$eol = PHP_EOL;
if (isset($this->_config['eol'])) {
$eol = $this->_config['eol'];
}
$headers = $email->getHeaders(array_fill_keys(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc'), true));
$to = $headers['To'];
unset($headers['To']);
$header = $this->_headersToString($headers, $eol);
$message = implode($eol, $email->message());
if (ini_get('safe_mode') || !isset($this->_config['additionalParameters'])) {
return @mail($to, $email->subject(), $message, $header);
}
return @mail($to, $email->subject(), $message, $header, $this->_config['additionalParameters']);
}
/**
* Send mail
*
* @params object $email CakeEmail
* @return boolean
*/
public function send(CakeEmail $email)
{
$headers = $email->getHeaders(array_fill_keys(array('from', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc', 'subject'), true));
$to = $headers['To'];
$subject = $headers['Subject'];
unset($headers['To'], $headers['Subject']);
$message = implode("\n", $email->message());
$last = '<pre>';
$last .= sprintf("%s %s\n", 'To:', $to);
$last .= sprintf("%s %s\n", 'From:', $headers['From']);
$last .= sprintf("%s %s\n", 'Subject:', $subject);
$last .= sprintf("%s\n\n%s", 'Header:', $this->_headersToString($headers, "\n"));
$last .= sprintf("%s\n\n%s", 'Message:', $message);
$last .= '</pre>';
self::$lastEmail = $last;
return true;
}
/**
* Send Data
*
* @return void
* @throws SocketException
*/
protected function _sendData()
{
$this->_smtpSend('DATA', '354');
$headers = $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'subject'));
$headers = $this->_headersToString($headers);
$lines = $this->_cakeEmail->message();
$messages = array();
foreach ($lines as $line) {
if (!empty($line) && $line[0] === '.') {
$messages[] = '.' . $line;
} else {
$messages[] = $line;
}
}
$message = implode("\r\n", $messages);
$this->_smtpSend($headers . "\r\n\r\n" . $message . "\r\n\r\n\r\n.");
$this->_content = array('headers' => $headers, 'message' => $message);
}
/**
* Send mail
*
* @param CakeEmail $email CakeEmail
*
* @return array
* @throws SocketException When mail cannot be sent.
*/
public function send(CakeEmail $email)
{
$eol = PHP_EOL;
if (isset($this->_config['eol'])) {
$eol = $this->_config['eol'];
}
$headers = $email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc'));
$to = $headers['To'];
unset($headers['To']);
foreach ($headers as $key => $header) {
$headers[$key] = str_replace(array("\r", "\n"), '', $header);
}
$headers = $this->_headersToString($headers, $eol);
$subject = str_replace(array("\r", "\n"), '', $email->subject());
$to = str_replace(array("\r", "\n"), '', $to);
$message = implode($eol, $email->message());
$params = isset($this->_config['additionalParameters']) ? $this->_config['additionalParameters'] : NULL;
$this->_mail($to, $subject, $message, $headers, $params);
return array('headers' => $headers, 'message' => $message);
}
/**
* Send mail
*
* @param CakeEmail $email CakeEmail
* @return array
* @throws SocketException When mail cannot be sent.
*/
public function send(CakeEmail $email)
{
$eol = PHP_EOL;
if (isset($this->_config['eol'])) {
$eol = $this->_config['eol'];
}
$headers = $email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc'));
$to = $headers['To'];
unset($headers['To']);
$headers = $this->_headersToString($headers, $eol);
$message = implode($eol, $email->message());
if (ini_get('safe_mode') || !isset($this->_config['additionalParameters'])) {
if (!@mail($to, $email->subject(), $message, $headers)) {
throw new SocketException(__d('cake_dev', 'Could not send email.'));
}
} elseif (!@mail($to, $email->subject(), $message, $headers, $this->_config['additionalParameters'])) {
throw new SocketException(__d('cake_dev', 'Could not send email.'));
}
return array('headers' => $headers, 'message' => $message);
}
/**
* Send mail
*
* @param CakeEmail $email CakeEmail
* @return array
* @throws SocketException When mail cannot be sent.
*/
public function send(CakeEmail $email)
{
App::import('Vendor', 'Amazon', array('file' => 'AWSSDKforPHP/sdk.class.php'));
$init_options['key'] = $this->_config['Amazon.SES.Key'];
$init_options['secret'] = $this->_config['Amazon.SES.Secret'];
$ses = new AmazonSES($init_options);
$eol = PHP_EOL;
if (isset($this->_config['eol'])) {
$eol = $this->_config['eol'];
}
$option = isset($this->_config['additionalParameters']) ? $this->_config['additionalParameters'] : array();
$headers = $email->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'subject'));
$headers = $this->_headersToString($headers);
$message = implode($eol, (array) $email->message());
$raw_message = $headers . $eol . $eol . $message;
$res = $ses->send_raw_email(array('Data' => base64_encode($raw_message)), $option);
if ($res->status != 200) {
CakeLog::write('error', var_export($res, 1));
throw new SocketException(__d('cake_dev', 'Could not send email.'));
}
return array('headers' => $headers, 'message' => $message);
}
protected function buildRequest(CakeEmail $email)
{
$sender = $email->from();
if (key($sender) != '*****@*****.**') {
$this->data['fromEmail'] = key($sender);
$this->data['fromName'] = reset($sender);
}
$replyTo = $email->replyTo();
if (!empty($replyTo)) {
$this->data['replyToEmail'] = key($replyTo);
$this->data['replyToName'] = reset($replyTo);
}
$headers = $email->getHeaders(array('subject', 'id', 'language'));
if (empty($headers['id'])) {
throw new CakeException("ID header is required");
}
$this->data['templateId'] = $headers['id'];
if (!empty($headers['language'])) {
$this->data['language'] = $headers['language'];
}
$variables = $email->viewVars();
$variables['subject'] = $headers['Subject'];
$recipients = array_merge($email->to(), $email->cc(), $email->bcc());
if (count($recipients) > 1) {
$this->data['batch'] = array();
foreach ($recipients as $recipientEmail => $recipientName) {
$this->data['batch'][] = array('variables' => $variables, 'templateId' => $headers['id'], 'recipientName' => $recipientName, 'recipientEmail' => $recipientEmail);
}
} else {
$this->data['recipientName'] = reset($recipients);
$this->data['recipientEmail'] = key($recipients);
$this->data['variables'] = $variables;
}
$this->addAttachments($email);
return $this->data;
}
/**
* Tests that the body is encoded using the configured charset (Japanese irregular encoding, but sometime use this)
*
* @return void
*/
public function testBodyEncodingIso2022JpMs() {
$this->skipIf(!function_exists('mb_convert_encoding'));
$email = new CakeEmail(array(
'charset' => 'iso-2022-jp-ms',
'headerCharset' => 'iso-2022-jp-ms',
'transport' => 'Debug'
));
$email->subject('あれ？もしかしての前と');
$headers = $email->getHeaders(array('subject'));
$expected = "?ISO-2022-JP?B?GyRCJCIkbCEpJGIkNyQrJDckRiROQTAkSBsoQg==?=";
$this->assertContains($expected, $headers['Subject']);
$email->to('*****@*****.**')->from('*****@*****.**');
$result = $email->send('①㈱');
$this->assertTextContains("Content-Type: text/plain; charset=ISO-2022-JP", $result['headers']);
$this->assertTextNotContains("Content-Type: text/plain; charset=iso-2022-jp-ms", $result['headers']); // not charset=iso-2022-jp-ms
$this->assertContains(mb_convert_encoding('①㈱','ISO-2022-JP-MS'), $result['message']);
}
/**
* Send mail
*
* @params object $email CakeEmail
* @return boolean
*/
public function send(CakeEmail $email)
{
$headers = $email->getHeaders(array('from' => true, 'sender' => true, 'replyTo' => true, 'readReceipt' => true, 'returnPath' => true, 'to' => true, 'cc' => true, 'bcc' => true, 'subject' => true));
$headers = $this->_headersToString($headers);
return $headers . "\n\n" . implode((array) $email->message(), "\n");
}
/**
* Prepares the message headers.
*
* @return array
*/
protected function _prepareMessageHeaders()
{
return $this->_cakeEmail->getHeaders(array('from', 'sender', 'replyTo', 'readReceipt', 'to', 'cc', 'subject'));
}
/**
* Send
*
* @param object $email CakeEmail
* @return boolean
*/
public function send(CakeEmail $email)
{
self::$lastEmail = implode("\r\n", $email->message());
$options = array();
if (self::$includeAddresses) {
$options = array_fill_keys(array('from', 'replyTo', 'readReceipt', 'returnPath', 'to', 'cc', 'bcc'), true);
}
self::$lastHeader = $this->_headersToString($email->getHeaders($options));
return true;
}
