Namespaces

  • Latte
    • Loaders
    • Macros
    • Runtime
  • Nette
    • Application
      • Responses
      • Routers
      • UI
    • Bridges
      • ApplicationDI
      • ApplicationLatte
      • ApplicationTracy
      • CacheDI
      • CacheLatte
      • DatabaseDI
      • DatabaseTracy
      • DITracy
      • FormsDI
      • FormsLatte
      • Framework
      • HttpDI
      • HttpTracy
      • MailDI
      • ReflectionDI
      • SecurityDI
      • SecurityTracy
    • Caching
      • Storages
    • ComponentModel
    • Database
      • Conventions
      • Drivers
      • Table
    • DI
      • Config
        • Adapters
      • Extensions
    • Forms
      • Controls
      • Rendering
    • Http
    • Iterators
    • Loaders
    • Localization
    • Mail
    • Neon
    • PhpGenerator
    • Reflection
    • Security
    • Utils
  • none
  • Tracy
    • Bridges
      • Nette

Classes

  • FallbackMailer
  • Message
  • MimePart
  • SendmailMailer
  • SmtpMailer

Interfaces

  • IMailer

Exceptions

  • FallbackMailerException
  • SendException
  • SmtpException
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (https://nette.org)
  5:  * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
  6:  */
  7: 
  8: namespace Nette\Mail;
  9: 
 10: use Nette;
 11: use Nette\Utils\Strings;
 12: 
 13: 
 14: /**
 15:  * Mail provides functionality to compose and send both text and MIME-compliant multipart email messages.
 16:  *
 17:  * @property   string $subject
 18:  * @property   mixed $htmlBody
 19:  */
 20: class Message extends MimePart
 21: {
 22:     /** Priority */
 23:     const HIGH = 1,
 24:         NORMAL = 3,
 25:         LOW = 5;
 26: 
 27:     /** @var array */
 28:     public static $defaultHeaders = [
 29:         'MIME-Version' => '1.0',
 30:         'X-Mailer' => 'Nette Framework',
 31:     ];
 32: 
 33:     /** @var array */
 34:     private $attachments = [];
 35: 
 36:     /** @var array */
 37:     private $inlines = [];
 38: 
 39:     /** @var mixed */
 40:     private $html;
 41: 
 42: 
 43:     public function __construct()
 44:     {
 45:         foreach (static::$defaultHeaders as $name => $value) {
 46:             $this->setHeader($name, $value);
 47:         }
 48:         $this->setHeader('Date', date('r'));
 49:     }
 50: 
 51: 
 52:     /**
 53:      * Sets the sender of the message.
 54:      * @param  string  email or format "John Doe" <doe@example.com>
 55:      * @param  string
 56:      * @return self
 57:      */
 58:     public function setFrom($email, $name = NULL)
 59:     {
 60:         $this->setHeader('From', $this->formatEmail($email, $name));
 61:         return $this;
 62:     }
 63: 
 64: 
 65:     /**
 66:      * Returns the sender of the message.
 67:      * @return array
 68:      */
 69:     public function getFrom()
 70:     {
 71:         return $this->getHeader('From');
 72:     }
 73: 
 74: 
 75:     /**
 76:      * Adds the reply-to address.
 77:      * @param  string  email or format "John Doe" <doe@example.com>
 78:      * @param  string
 79:      * @return self
 80:      */
 81:     public function addReplyTo($email, $name = NULL)
 82:     {
 83:         $this->setHeader('Reply-To', $this->formatEmail($email, $name), TRUE);
 84:         return $this;
 85:     }
 86: 
 87: 
 88:     /**
 89:      * Sets the subject of the message.
 90:      * @param  string
 91:      * @return self
 92:      */
 93:     public function setSubject($subject)
 94:     {
 95:         $this->setHeader('Subject', $subject);
 96:         return $this;
 97:     }
 98: 
 99: 
100:     /**
101:      * Returns the subject of the message.
102:      * @return string
103:      */
104:     public function getSubject()
105:     {
106:         return $this->getHeader('Subject');
107:     }
108: 
109: 
110:     /**
111:      * Adds email recipient.
112:      * @param  string  email or format "John Doe" <doe@example.com>
113:      * @param  string
114:      * @return self
115:      */
116:     public function addTo($email, $name = NULL) // addRecipient()
117:     {
118:         $this->setHeader('To', $this->formatEmail($email, $name), TRUE);
119:         return $this;
120:     }
121: 
122: 
123:     /**
124:      * Adds carbon copy email recipient.
125:      * @param  string  email or format "John Doe" <doe@example.com>
126:      * @param  string
127:      * @return self
128:      */
129:     public function addCc($email, $name = NULL)
130:     {
131:         $this->setHeader('Cc', $this->formatEmail($email, $name), TRUE);
132:         return $this;
133:     }
134: 
135: 
136:     /**
137:      * Adds blind carbon copy email recipient.
138:      * @param  string  email or format "John Doe" <doe@example.com>
139:      * @param  string
140:      * @return self
141:      */
142:     public function addBcc($email, $name = NULL)
143:     {
144:         $this->setHeader('Bcc', $this->formatEmail($email, $name), TRUE);
145:         return $this;
146:     }
147: 
148: 
149:     /**
150:      * Formats recipient email.
151:      * @param  string
152:      * @param  string
153:      * @return array
154:      */
155:     private function formatEmail($email, $name)
156:     {
157:         if (!$name && preg_match('#^(.+) +<(.*)>\z#', $email, $matches)) {
158:             return [$matches[2] => $matches[1]];
159:         } else {
160:             return [$email => $name];
161:         }
162:     }
163: 
164: 
165:     /**
166:      * Sets the Return-Path header of the message.
167:      * @param  string  email
168:      * @return self
169:      */
170:     public function setReturnPath($email)
171:     {
172:         $this->setHeader('Return-Path', $email);
173:         return $this;
174:     }
175: 
176: 
177:     /**
178:      * Returns the Return-Path header.
179:      * @return string
180:      */
181:     public function getReturnPath()
182:     {
183:         return $this->getHeader('Return-Path');
184:     }
185: 
186: 
187:     /**
188:      * Sets email priority.
189:      * @param  int
190:      * @return self
191:      */
192:     public function setPriority($priority)
193:     {
194:         $this->setHeader('X-Priority', (int) $priority);
195:         return $this;
196:     }
197: 
198: 
199:     /**
200:      * Returns email priority.
201:      * @return int
202:      */
203:     public function getPriority()
204:     {
205:         return $this->getHeader('X-Priority');
206:     }
207: 
208: 
209:     /**
210:      * Sets HTML body.
211:      * @param  string
212:      * @param  mixed base-path
213:      * @return self
214:      */
215:     public function setHtmlBody($html, $basePath = NULL)
216:     {
217:         $html = (string) $html;
218: 
219:         if ($basePath) {
220:             $cids = [];
221:             $matches = Strings::matchAll(
222:                 $html,
223:                 '#
224:                     (<img[^<>]*\s src\s*=\s*
225:                     |<body[^<>]*\s background\s*=\s*
226:                     |<[^<>]+\s style\s*=\s* ["\'][^"\'>]+[:\s] url\(
227:                     |<style[^>]*>[^<]+ [:\s] url\()
228:                     (["\']?)(?![a-z]+:|[/\\#])([^"\'>)\s]+)
229:                     |\[\[ ([\w()+./@~-]+) \]\]
230:                 #ix',
231:                 PREG_OFFSET_CAPTURE
232:             );
233:             foreach (array_reverse($matches) as $m) {
234:                 $file = rtrim($basePath, '/\\') . '/' . (isset($m[4]) ? $m[4][0] : urldecode($m[3][0]));
235:                 if (!isset($cids[$file])) {
236:                     $cids[$file] = substr($this->addEmbeddedFile($file)->getHeader('Content-ID'), 1, -1);
237:                 }
238:                 $html = substr_replace($html,
239:                     "{$m[1][0]}{$m[2][0]}cid:{$cids[$file]}",
240:                     $m[0][1], strlen($m[0][0])
241:                 );
242:             }
243:         }
244: 
245:         if ($this->getSubject() == NULL) { // intentionally ==
246:             $html = Strings::replace($html, '#<title>(.+?)</title>#is', function ($m) use (& $title) {
247:                 $title = $m[1];
248:             });
249:             $this->setSubject(html_entity_decode($title, ENT_QUOTES, 'UTF-8'));
250:         }
251: 
252:         $this->html = ltrim(str_replace("\r", '', $html), "\n");
253: 
254:         if ($this->getBody() == NULL && $html != NULL) { // intentionally ==
255:             $this->setBody($this->buildText($html));
256:         }
257: 
258:         return $this;
259:     }
260: 
261: 
262:     /**
263:      * Gets HTML body.
264:      * @return mixed
265:      */
266:     public function getHtmlBody()
267:     {
268:         return $this->html;
269:     }
270: 
271: 
272:     /**
273:      * Adds embedded file.
274:      * @param  string
275:      * @param  string
276:      * @param  string
277:      * @return MimePart
278:      */
279:     public function addEmbeddedFile($file, $content = NULL, $contentType = NULL)
280:     {
281:         return $this->inlines[$file] = $this->createAttachment($file, $content, $contentType, 'inline')
282:             ->setHeader('Content-ID', $this->getRandomId());
283:     }
284: 
285: 
286:     /**
287:      * Adds inlined Mime Part.
288:      * @param  MimePart
289:      * @return self
290:      */
291:     public function addInlinePart(MimePart $part)
292:     {
293:         $this->inlines[] = $part;
294:         return $this;
295:     }
296: 
297: 
298:     /**
299:      * Adds attachment.
300:      * @param  string
301:      * @param  string
302:      * @param  string
303:      * @return MimePart
304:      */
305:     public function addAttachment($file, $content = NULL, $contentType = NULL)
306:     {
307:         return $this->attachments[] = $this->createAttachment($file, $content, $contentType, 'attachment');
308:     }
309: 
310: 
311:     /**
312:      * Gets all email attachments.
313:      * @return MimePart[]
314:      */
315:     public function getAttachments()
316:     {
317:         return $this->attachments;
318:     }
319: 
320: 
321:     /**
322:      * Creates file MIME part.
323:      * @return MimePart
324:      */
325:     private function createAttachment($file, $content, $contentType, $disposition)
326:     {
327:         $part = new MimePart;
328:         if ($content === NULL) {
329:             $content = @file_get_contents($file); // @ is escalated to exception
330:             if ($content === FALSE) {
331:                 throw new Nette\FileNotFoundException("Unable to read file '$file'.");
332:             }
333:         } else {
334:             $content = (string) $content;
335:         }
336:         $part->setBody($content);
337:         $part->setContentType($contentType ? $contentType : finfo_buffer(finfo_open(FILEINFO_MIME_TYPE), $content));
338:         $part->setEncoding(preg_match('#(multipart|message)/#A', $contentType) ? self::ENCODING_8BIT : self::ENCODING_BASE64);
339:         $part->setHeader('Content-Disposition', $disposition . '; filename="' . Strings::fixEncoding(basename($file)) . '"');
340:         return $part;
341:     }
342: 
343: 
344:     /********************* building and sending ****************d*g**/
345: 
346: 
347:     /**
348:      * Returns encoded message.
349:      * @return string
350:      */
351:     public function generateMessage()
352:     {
353:         return $this->build()->getEncodedMessage();
354:     }
355: 
356: 
357:     /**
358:      * Builds email. Does not modify itself, but returns a new object.
359:      * @return self
360:      */
361:     protected function build()
362:     {
363:         $mail = clone $this;
364:         $mail->setHeader('Message-ID', $this->getRandomId());
365: 
366:         $cursor = $mail;
367:         if ($mail->attachments) {
368:             $tmp = $cursor->setContentType('multipart/mixed');
369:             $cursor = $cursor->addPart();
370:             foreach ($mail->attachments as $value) {
371:                 $tmp->addPart($value);
372:             }
373:         }
374: 
375:         if ($mail->html != NULL) { // intentionally ==
376:             $tmp = $cursor->setContentType('multipart/alternative');
377:             $cursor = $cursor->addPart();
378:             $alt = $tmp->addPart();
379:             if ($mail->inlines) {
380:                 $tmp = $alt->setContentType('multipart/related');
381:                 $alt = $alt->addPart();
382:                 foreach ($mail->inlines as $value) {
383:                     $tmp->addPart($value);
384:                 }
385:             }
386:             $alt->setContentType('text/html', 'UTF-8')
387:                 ->setEncoding(preg_match('#[^\n]{990}#', $mail->html)
388:                     ? self::ENCODING_QUOTED_PRINTABLE
389:                     : (preg_match('#[\x80-\xFF]#', $mail->html) ? self::ENCODING_8BIT : self::ENCODING_7BIT))
390:                 ->setBody($mail->html);
391:         }
392: 
393:         $text = $mail->getBody();
394:         $mail->setBody(NULL);
395:         $cursor->setContentType('text/plain', 'UTF-8')
396:             ->setEncoding(preg_match('#[^\n]{990}#', $text)
397:                 ? self::ENCODING_QUOTED_PRINTABLE
398:                 : (preg_match('#[\x80-\xFF]#', $text) ? self::ENCODING_8BIT : self::ENCODING_7BIT))
399:             ->setBody($text);
400: 
401:         return $mail;
402:     }
403: 
404: 
405:     /**
406:      * Builds text content.
407:      * @return string
408:      */
409:     protected function buildText($html)
410:     {
411:         $text = Strings::replace($html, [
412:             '#<(style|script|head).*</\\1>#Uis' => '',
413:             '#<t[dh][ >]#i' => ' $0',
414:             '#<a\s[^>]*href=(?|"([^"]+)"|\'([^\']+)\')[^>]*>(.*?)</a>#is' =>  '$2 &lt;$1&gt;',
415:             '#[\r\n]+#' => ' ',
416:             '#<(/?p|/?h\d|li|br|/tr)[ >/]#i' => "\n$0",
417:         ]);
418:         $text = html_entity_decode(strip_tags($text), ENT_QUOTES, 'UTF-8');
419:         $text = Strings::replace($text, '#[ \t]+#', ' ');
420:         return trim($text);
421:     }
422: 
423: 
424:     /** @return string */
425:     private function getRandomId()
426:     {
427:         return '<' . Nette\Utils\Random::generate() . '@'
428:             . preg_replace('#[^\w.-]+#', '', isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : php_uname('n'))
429:             . '>';
430:     }
431: 
432: }
433: 
Nette 2.4-20161109 API API documentation generated by ApiGen 2.8.0