PHP CakeEmail::cc方法代码示例

 /**
  * 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);
 }

 /**
  * 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');
     }
 }

 /**
  * 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()));
     }
 }

 /**
  * Saves a lead into the leads table
  * @param  array  $data
  * @param  string $type The lead type - usually the page type
  * @return boolean
  */
 public function saveLead($data = array(), $type = null)
 {
     if (!$data || !$type) {
         throw new NotFoundException(__('Invalid data or type'));
     }
     $data['Lead']['type'] = $type;
     $this->create();
     $result = $this->save($data);
     if (!$result) {
         throw new LogicException(__('There was a problem, please review the errors below and try again.'));
     }
     $this->Setting = ClassRegistry::init('Setting');
     $siteEmail = $this->Setting->get('siteEmail');
     $siteName = $this->Setting->get('siteName');
     $ccEmails = $this->Setting->get('siteEmailsCc');
     if ($siteEmail) {
         App::uses('CakeEmail', 'Network/Email');
         $email = new CakeEmail();
         $email->from(array($result['Lead']['email'] => $result['Lead']['name']));
         $email->to($siteEmail);
         if ($ccEmails) {
             $email->cc($ccEmails);
         }
         $email->subject(__('%s - The %s form has been submitted', $siteName, $result['Lead']['type']));
         $email->template('newLead');
         $email->emailFormat('both');
         $email->viewVars(array('lead' => $result, 'siteName' => $siteName));
         $email->send();
     }
     return true;
 }

 public function sendEmail($to = NULL, $subject = NULL, $data = NULL, $template = NULL, $format = 'text', $cc = NULL, $bcc = NULL)
 {
     $Email = new CakeEmail();
     $Email->from(array(Configure::read('Email_From_Email') => Configure::read('Email_From_Name')));
     //$Email->config(Configure::read('TRANSPORT'));
     $Email->config('default');
     $Email->template($template);
     if ($to != NULL) {
         $Email->to($to);
     }
     if ($cc != NULL) {
         $Email->cc($cc);
     }
     if ($bcc != NULL) {
         $Email->bcc($bcc);
     }
     $Email->subject($subject);
     $Email->viewVars($data);
     $Email->emailFormat($format);
     if ($Email->send()) {
         return true;
     } else {
         return false;
     }
 }

 public function SendQueryMail($userData, $productData)
 {
     $sendArr = array();
     $sendArr['Name'] = $userData['name'];
     $sendArr['chef'] = $productData['User']['first_name'];
     $sendArr['phone'] = $userData['phone'];
     $sendArr['query'] = $userData['query'];
     $sendArr['useremail'] = base64_decode($userData['email']);
     $sendArr['queryfor'] = $userData['queryfor'];
     $sendArr['product'] = $productData['Product']['name'];
     $sendArr['price'] = $productData['Product']['price'];
     $sendArr['orderby'] = $userData['orderBy'];
     $sendArr['pick'] = $userData['pickupBy'];
     $sendmail = array($productData['User']['email'], base64_decode($userData['email']));
     $email = new CakeEmail('smtp');
     $email->from(array('support@yumplate.com' => 'YumPlate Support'));
     $email->sender('contact@yumadmin.com');
     $email->cc(Configure::read('Settings.SUPPORT_EMAIL'));
     $email->to($sendmail);
     //$email->to('pravendra.kumar@webenturetech.com');
     $email->template('askmail');
     $email->emailFormat('html');
     $email->viewVars(array('sendArr' => $sendArr));
     $email->subject('Ask the Cook');
     $body = " ";
     try {
         $result = $email->send();
     } catch (Exception $ex) {
         //pr($ex);die;
         // we could not send the email, ignore it
         return false;
     }
     return true;
 }

 public function _sendMails($to, $sub = '', $contents = '', $attachments = null, $cc = null, $bcc = null)
 {
     //prd($contents);
     if (empty($from)) {
         $from = strtolower(Configure::read('Site.email'));
     }
     $Email = new CakeEmail();
     $Email->config('smtp');
     $Email->emailFormat('html');
     $Email->subject($sub);
     $Email->template('default', 'default');
     $Email->to($to);
     $Email->from(array($from => $sub));
     $Email->replyTo('mail-noreply@meocart.com', "Meocart Team");
     if (!empty($cc)) {
         $Email->cc($cc);
     }
     if (!empty($bcc)) {
         $Email->bcc($bcc);
     }
     if (!empty($attachments) && $attachments != '' && is_array($attachments)) {
         $Email->attachments($attachments);
     }
     $Email->viewVars(array('content' => $contents));
     try {
         if ($Email->send()) {
             return true;
         }
         return false;
     } catch (Exception $e) {
         return $e->getMessage();
     }
 }

 /**
  * Prepares the recipient email addresses.
  *
  * @return array
  */
 protected function _prepareRecipientAddresses()
 {
     $to = $this->_cakeEmail->to();
     $cc = $this->_cakeEmail->cc();
     $bcc = $this->_cakeEmail->bcc();
     return array_merge(array_keys($to), array_keys($cc), array_keys($bcc));
 }

 /**
  * testPostmarkSend method
  *
  * @return void
  */
 public function testPostmarkSend()
 {
     $this->email->config('postmark');
     $this->email->template('default', 'default');
     $this->email->emailFormat('html');
     $this->email->from(array('yourpostmark@mail.com' => 'Your Name'));
     $this->email->to(array('recipient@domain.com' => 'Recipient'));
     $this->email->cc(array('recipient@domain.com' => 'Recipient'));
     $this->email->bcc(array('recipient@domain.com' => '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 emails
  *
  * @return void
  * @throws SocketException
  */
 protected function _sendRcpt()
 {
     $from = $this->_cakeEmail->from();
     $this->_smtpSend('MAIL FROM:<' . key($from) . '>');
     $to = $this->_cakeEmail->to();
     $cc = $this->_cakeEmail->cc();
     $bcc = $this->_cakeEmail->bcc();
     $emails = array_merge(array_keys($to), array_keys($cc), array_keys($bcc));
     foreach ($emails as $email) {
         $this->_smtpSend('RCPT TO:<' . $email . '>');
     }
 }

 /**
  * 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
  * 
  * 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());
 }

 /**
  * Sends an email
  * @param  array  $email_data   Email data
  * @param  array $attachments   Attachments data
  * @return boolean              Success of operation
  */
 public function sendMail($email_data = array(), $attachments = null)
 {
     $Email = new CakeEmail();
     $Email->config($email_data['config']);
     $Email->to($email_data['to']);
     if (!is_null($email_data['cc'])) {
         $Email->cc($email_data['cc']);
     }
     $Email->subject($email_data['subject']);
     $Email->emailFormat('html');
     $Email->template($email_data['template'], $email_data['layout']);
     $Email->viewvars($email_data['viewvars']);
     if (!is_null($attachments)) {
         $Email->attachments($attachments);
     }
     if ($Email->send()) {
         return true;
     }
 }

 protected function buildRequest(CakeEmail $email)
 {
     $sender = $email->from();
     if (key($sender) != 'mailerloop@mailerloop.com') {
         $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;
 }

/**
 * Send an email using the specified content, template and layout
 *
 * @param string|array $content Either an array of text lines, or a string with contents
 *  If you are rendering a template this variable will be sent to the templates as `$content`
 * @param string $template Template to use when sending email
 * @param string $layout Layout to use to enclose email body
 * @return boolean Success
 */
	public function send($content = null, $template = null, $layout = null) {
		$lib = new CakeEmail();
		$lib->charset = $this->charset;
		$lib->headerCharset = $this->charset;

		$lib->from($this->_formatAddresses((array)$this->from));
		if (!empty($this->to)) {
			$lib->to($this->_formatAddresses((array)$this->to));
		}
		if (!empty($this->cc)) {
			$lib->cc($this->_formatAddresses((array)$this->cc));
		}
		if (!empty($this->bcc)) {
			$lib->bcc($this->_formatAddresses((array)$this->bcc));
		}
		if (!empty($this->replyTo)) {
			$lib->replyTo($this->_formatAddresses((array)$this->replyTo));
		}
		if (!empty($this->return)) {
			$lib->returnPath($this->_formatAddresses((array)$this->return));
		}
		if (!empty($this->readReceipt)) {
			$lib->readReceipt($this->_formatAddresses((array)$this->readReceipt));
		}

		$lib->subject($this->subject)->messageID($this->messageId);
		$lib->helpers($this->_controller->helpers);

		$headers = array('X-Mailer' => $this->xMailer);
		foreach ($this->headers as $key => $value) {
			$headers['X-' . $key] = $value;
		}
		if ($this->date) {
			$headers['Date'] = $this->date;
		}
		$lib->setHeaders($headers);

		if ($template) {
			$this->template = $template;
		}
		if ($layout) {
			$this->layout = $layout;
		}
		$lib->template($this->template, $this->layout)->viewVars($this->_controller->viewVars)->emailFormat($this->sendAs);

		if (!empty($this->attachments)) {
			$lib->attachments($this->_formatAttachFiles());
		}

		$lib->transport(ucfirst($this->delivery));
		if ($this->delivery === 'mail') {
			$lib->config(array('eol' => $this->lineFeed, 'additionalParameters' => $this->additionalParams));
		} elseif ($this->delivery === 'smtp') {
			$lib->config($this->smtpOptions);
		} else {
			$lib->config(array());
		}

		$sent = $lib->send($content);

		$this->htmlMessage = $lib->message(CakeEmail::MESSAGE_HTML);
		if (empty($this->htmlMessage)) {
			$this->htmlMessage = null;
		}
		$this->textMessage = $lib->message(CakeEmail::MESSAGE_TEXT);
		if (empty($this->textMessage)) {
			$this->textMessage = null;
		}

		$this->_header = array();
		$this->_message = array();

		return $sent;
	}