To install Sendmail, you can use a package manager like Sendmail:

# apt-get install sendmail

Now, you should configure Sendmail by executing the following command with root privileges:

# sendmailconfig

You can now easily send an e-mail from the command line. Create a file called mail.txt and fill it with some text.

$ touch mail.txt
$ echo "Test mail" > mail.txt
$ mail -s "Hello world" john@wroxexample.com < mail.txt

At the end, you need to execute the mail command, as shown previously. Replace the example e-mail with your own text, send it, and check your mailbox. Probably it will be delivered but filtered as spam, so search your spam inbox as well.

This may come as a surprise, but despite the fact that Sendmail is a UNIX application, it is delivered within XAMPP for Windows, so if you followed XAMPP installation in Chapter 2, you don't have to install anything else. The file structure of Sendmail for Windows is presented below.

c:\xampp\sendmail\
    libeay32.dll
    sendmail.exe
    sendmail.ini
    ssleay32.dll

Sendmail is also used by PHP under Windows to send e-mail.

You can employ SwiftMailer in Symfony by invoking the getMailer() method as shown here:

$mailer = $this->getMailer();

Figure 6.5. Symfony debug toolbar

Creating and sending simple e-mail can be easily done using one method only: composeAndSend(), as shown in the following code. This is very useful when you are developing a big application in which the mailing code is not really the important part, but you need to close some functionalities that depend on sending e-mail.

$mailer->composeAndSend(
        'example@wroxexample.com',
        'example@wroxexample.com',
        'Hello World!!!!',
        'John Smith'
);

After executing this code through a browser, you should be able to see in the right corner of the debug toolbar an envelope with the count of sent e-mail (see Figure 6-5).

When you click the envelope, you should see details of each e-mail on the left (see Figure 6-6).

Figure 6.6. E-mail details toolbar

You can send not only plain text e-mail but also HTML-formatted messages. You may specify what kind of e-mail you want to send with the setBody() method. It gets two parameters: message body (content) and message type. In the following example, an HTML message is sent:

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setBody('foobar <p style="font-weight: bold;">message</p>', 'text/html');
$this->getMailer()->send($message);

Additionally you can use Symfony's partial files for the message body. To get partial content, you should use the getPartial() method. As the second parameter, you send an array with key variables and their assigned values.

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$htmlBody = $this->getPartial('activation',array('name'=>'John Smith'));
$message->setBody($htmlBody,'text/html');
$this->getMailer()->send($message);

To run this example, you need to create a partial file that should be saved as _activation.php in /modules/<example>/templates/ directory. Note that you replace <example> with your module name. The partial file's content can look like this:

Hello World!
<?php echo $name; ?>

The Swift_Attachment class is responsible for creating attachments in SwiftMailer. Attachments can be added in two major ways:

Depending on your business strategy and application architecture, you can store attachment files directly under a file system path or in a database. When you store attachments just as files, you can attach them using the fromPath() method and the file's path. An example e-mail code is shown following. Note that you can also set a proper content-type value. This is not obligatory, and you can omit this parameter, but it can be helpful for some e-mail clients to let them know the attachment type.

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo('example@wroxexample.com');
$attachment = Swift_Attachment::fromPath('C:\funny.jpg', 'image/jpeg');
$message->attach($attachment);
$this->getMailer()->send($message);

To hide files from public, sometimes they are kept with strange names such as frt4754fehrt954643gfwe0.jpg. Such names are very hard to guess, so they cannot be easily accessed from outside. This approach can't be called real security, but proves to be good for keeping the files out of the view of general public. In this case, you can set another filename that will be seen by the receiver. To do that, you should use the setFilename() method as follows:

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo('example@wroxexample.com');
$attachment = Swift_Attachment::fromPath(
  'C:\xampp\public_html\cake\app\webroot\attach\frt4754fehrt954643gfwe0.jpg')
  ->setFilename('funny.jpg');
$message->attach($attachment);
$this->getMailer()->send($message);

However, most developers keep files in databases, especially when attachments are dynamic and change very often, or if they differ for each e-mail. You can easily attach a file that was saved before in a database. Assume that your Attachments table structure looks as follows:

field name    type
id            int(3) primary key auto_increment
fileName      varchar(32)
content       BLOB

You can get attachment's content using Doctrine, as shown in the following code:

$attachData = Doctrine_Core::getTable('Attachments')->find(1);
$data=$attachData->getContent();
$fileName=$attachData->getFileName();
$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo('example@wroxexample.com');
$attachment = Swift_Attachment::newInstance($data, $fileName);
$message->attach($attachment);
$this->getMailer()->send($message);

That's really easy to implement.

Adding more than one recipient can be done in few ways. The simplest way is to add more recipients in the TO field as follows:

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo(array('example@wroxexample.com','john@wroxexample.com'));
$this->getMailer()->send($message);

In some cases this solution is not the proper one. That's why carbon copies (CC) and blind carbon copies (BCC) were invented. You can add carbon copies using the addCc() method of the Swift_Message object.

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo('example@wroxexample.com');
$message->addCc('boss@wroxexample.com', 'John Kowalski');
$this->getMailer()->send($message);

Adding blind carbon copies is similar to adding carbon copies.

$message = Swift_Message::newInstance('Hello World Subject!', 'foobar message');
$message->setFrom('producer@wroxexample.com');
$message->setTo('example@wroxexample.com');
$message->setBcc(array(
    'pm@wroxexample.com',
    'boss@wroxexample.com' => 'John Kowalski',
));
$this->getMailer()->send($message);

Both in CC and BCC, you can apply more than one recipient, as shown previously.

SwiftMailer is integrated with Symfony. Therefore, you can configure an SMTP connection in application configuration files. By editing the factories.yml file in an application's /config directory, you can add some configuration entries dedicated to Symfony's default mailer. You can enable or disable logging for SwiftMailer, and set default charset and delivery options. But most interesting are the SMTP configuration entries. You can set user, password, host name and port for all sent e-mail. So you don't need to set it anywhere else when sending e-mail. Exemplary SwiftMailer entries for all environments can be set as follows:

all:
  routing:
    class: sfPatternRouting
    param:
      generate_shortest_url: true
      extra_parameters_as_query_string: true
  view_cache_manager:
    class: sfViewCacheManager
    param:
      cache_key_use_vary_headers: true
      cache_key_use_host_name: true
  mailer:
    class: sfMailer
    param:
      logging:           %SF_LOGGING_ENABLED%
      charset:           %SF_CHARSET%
      delivery_strategy: realtime
      transport:
        class: Swift_SmtpTransport
        param:
          host:       localhost
          port:       25
          encryption: ~
          username: ~
          password: ~

Because nonsecure connections (shown in the preceding code snippet) are very rarely used, you will most likely be using secure connections. You can easily change the configuration according to your needs. For example, for a secure connection, the configuration entries could be as follows:

all:
  routing:
    class: sfPatternRouting
    param:
      generate_shortest_url:            true
      extra_parameters_as_query_string: true
  view_cache_manager:
    class: sfViewCacheManager
    param:
      cache_key_use_vary_headers: true
      cache_key_use_host_name: true
  mailer:
    class: sfMailer
    param:
      logging: %SF_LOGGING_ENABLED%
      charset: %SF_CHARSET%

delivery_strategy: realtime
        transport:
          class: Swift_SmtpTransport
          param:
            host:       smtp.gmail.com
            port:       465
            encryption: ssl
            username:   wroxexample@gmail.com
            password:   wroxexample123

In some situations, one global configuration for all sent e-mail is not a good solution. Let's assume that you use a few accounts on different SMTP servers. In this case, it's better to use Swift_SmtpTransport to define connection parameters for each e-mail module, as follows:

$transport = Swift_SmtpTransport::newInstance('smtp.example.org', 25)
->setUsername('your username')
->setPassword('your password');

Next you need to send the authentication data to Swift_Mailer as a parameter:

$mailer = Swift_Mailer::newInstance($transport);

You can also define a secure connection with the same effect as described previously:

$transport = Swift_SmtpTransport::newInstance('smtp.example.org', 465, 'ssl');

To summarize, the following code shows a registration module example in which all previously described features are presented.

<?php
class RegistrationActions extends sfActions {
    public function executeRegister() {
           $transport = Swift_SmtpTransport::newInstance('smtp.gmail.com', 465, 'ssl')
           ->setUsername('wroxexampleregistration@gmail.com')
           ->setPassword('wroxexample123');
      $mailer = Swift_Mailer::newInstance($transport);
      $message = Swift_Message::newInstance('Hello World Subject!', 'foobar
message');
      $message->setFrom('wroxexampleregistration@gmail.com');
      $message->setTo('example@wroxexample.com');
      $message->setCc(array(
                            'admin@wroxexample.com' => 'John Kowalski',
      ));
     $attachment = Swift_Attachment::fromPath(
       '/home/wrox/public_html/symfony/web/attachments/subscription_pack.zip',
       'application/zip');

$message->attach($attachment);
    $mailer->send($message);
   }
}
code snippet /swiftmailer/symfony/app/frontend/modules/registration/actions/actions.class.php

After you import SwiftMailer, you can send e-mail as you can in Symfony. The only difference is that you need to set transport parameters through Swift_SmtpTransport every time you use SwiftMailer. The following code shows sending an e-mail with SwitfMailer via Gmail.

$transport = Swift_SmtpTransport::newInstance('smtp.gmail.com', 465, 'ssl')
                ->setUsername('wroxexample@gmail.com')
                ->setPassword('wroxexample123');
$mailer = Swift_Mailer::newInstance($transport);

$message = Swift_Message::newInstance('Cake SwiftMailer','Hello World!');
$message->setFrom('wroxexample@gmail.com');
$message->setTo('example@wroxexample.com');
$mailer->send($message);

You can easily add message content using the setBody() method. But what about message templates? Can they be made as shown in Symfony using partials? Template loading is possible with CakePHP's View class.

$viewPath='email';
$type='html';
$viewName='registration';
$view = new View($this);
$view->layout=$this->layout;
$content=$view->element($viewPath.DS.$type.DS.$viewName, array('name' => "John
Smith"), true);
$htmlBody= $view->renderLayout($content);

Note that in the preceding example you get a page with the layout used by the current controller as the $htmlBody variable. To see any results, you need to create a registration.phtml template element, which should be placed in the /app/views/elements/email/html/ directory. If you print the $htmlBody content with the echo command, you will see something similar to Figure 6-7.

Figure 6.7. CakePHP SwiftMailer'delivered mail content

Your registration.ctp should be as follows:

Hello World!
<?php echo $name; ?>

The output shown in Figure 6-7 is probably not exactly the one you expected. This is because the default layout was used. To replace the default layout, you need to assign the layout's name to the $this->layout variable instead of assigning the current layout, which is by default the default layout. For example if you set the layout as follows:

$this->layout='mailing';

then you should also create mailing.ctp in the /app/views/layouts/ directory with the following content:

<?php echo $content_for_layout; ?>

The preceding layout has only one line, which includes the template's content. It works in the same way as it does in a usual application. After merging, your code should look like the following:

$viewPath='email';
$type='html';
$viewName='registration';
$view = new View($this);

$view->layout=$this->layout;
$content=$view->element($viewPath.DS.$type.DS.$viewName,
  array('name' => "John Smith"), true);
$htmlBody= $view->renderLayout($content);
$transport = Swift_SmtpTransport::newInstance('smtp.gmail.com', 465, 'ssl')
                ->setUsername('wroxexample@gmail.com')
                ->setPassword('wroxexample123');
$mailer = Swift_Mailer::newInstance($transport);
$message = Swift_Message::newInstance();
$message->setSubject('swiftExample');
$message->setFrom('wroxexample@gmail.com');
$message->setTo('example@wroxexample.com');
$message->setCc(array('admin@wroxexample.com' => 'John Kowalski',));
$message->setBody($htmlBody,'text/html');
$mailer->send($message);

Note that it is a good practice to keep HTML and plain e-mail in separate folders in the elements/email/ directory.

views/elements/email/html/
views/elements/email/text/

These are done exactly as described in the "Symfony" section earlier in this chapter, so it will not be covered again here.

When you merge all code described in this section, your code should be similar to following code.

<?php
App::import('Vendor', 'Swift', array('file' =>
'swift_mailer'.DS.'lib'.DS.'swift_required.php'));
class RegistrationController extends AppController {
    var $name = 'registration';
    function send() {
        $transport = Swift_SmtpTransport::newInstance('smtp.gmail.com', 465, 'ssl')
                ->setUsername('wroxexample@gmail.com')
                ->setPassword('wroxexample123');
        $mailer = Swift_Mailer::newInstance($transport);
        $message = Swift_Message::newInstance();
        $message->setSubject('swiftExample');
        $message->setFrom('wroxexample@gmail.com');
        $message->setTo('example@wroxexample.com');
        $message->setCc(array('admin@wroxexample.com' => 'John Kowalski',));
        $viewPath='email';
        $type='html';
        $viewName='registration';
        $view = new View($this);
        $view->layout=$this->layout;
        $content=$view->element($viewPath.DS.$type.DS.$viewName,
          array('name' => "John Smith"), true);
        $htmlBody= $view->renderLayout($content);
        $message->setBody($htmlBody,'text/html');

$attachment = Swift_Attachment::fromPath(
          '/home/wrox/public_html/symfony/web/attachments/subscription_pack.zip',
          'application/zip');
        $message->attach($attachment);
        $mailer->send($message);
    }
}
?>
code snippet /swiftmailer/cakephp/app/controllers/registration_controller.php

Note that you also need to create proper template files and attachments to make this example runnable.

The rest of the code within the controller is almost the same as in Symfony and CakePHP.

$mailer = Swift_Mailer::newInstance($transport);
$message = Swift_Message::newInstance();
$message->setSubject('swiftExample');
$message->setFrom('wroxexample@gmail.com');
$message->setTo('example@wroxexample.com');
$message->setBody("Hello World",'text/plain');
$mailer->send($message);

The only difference, explained in the following section, is in getting the view template because it depends on the framework's architecture and libraries.

To get a template and send it as an HTML e-mail, you need to use Zend_View class.

$view = new Zend_View();
$view->addScriptPath(APPLICATION_PATH . '/application/views/scripts/email/');
$view->assign('name','John Smith');
$htmlBody = $view ->render(registration.phtml');
$mail->setBody($htmlBody,'text/html');

Your template should be saved as /application/views/scripts/email/registration.phtml and can look as follows:

Hello World! <br />
<?php echo $this->name; ?>

Note that the APPLICATION_PATH variable is defined in /application/public/index.php.

<?php
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));

Your merged efforts will result in following code.

<?php
require_once('swiftmailer/lib/swift_required.php');
class RegistrationController extends Zend_Controller_Action {
    function send() {
        $transport = Swift_SmtpTransport::newInstance('smtp.gmail.com', 465, 'ssl')
                ->setUsername('wroxexample@gmail.com')
                ->setPassword('wroxexample123');
        $mailer = Swift_Mailer::newInstance($transport);
        $message = Swift_Message::newInstance();
        $message->setSubject('swiftExample');
        $message->setFrom('wroxexample@gmail.com');
        $message->setTo('example@wroxexample.com');
        $message->setCc(array(
                                  'admin@wroxexample.com' => 'John Kowalski',
        ));
        $view = new Zend_View();
        $view->addScriptPath(APPLICATION_PATH .
 '/application/views/scripts/email/');
        $view->assign('name','John Smith');
        $htmlBody = $view ->render(registration.phtml');
        $message->setBody($htmlBody,'text/html');
        $attachment = Swift_Attachment::fromPath(
          '/home/wrox/public_html/symfony/web/attachments/subscription_pack.zip',
          'application/zip');
        $message->attach($attachment);

$mailer->send($message);
    }
}
?>
code snippet /swiftmailer/zf/application/controllers/RegistrationController.php

The individual code snippets demonstrating PHPMailer are discussed in the Zend Framework section. For CakePHP developers, there is a merged example presented below and the discussion in the Zend Framework section applies to this example as well. Almost all PHPMailer code used in CakePHP example is the same as in Zend Framework.

<?php
App::import('Vendor', 'PHPMailer', array('file' =>
'phpmailer'.DS.'class.phpmailer.php'));
class MailController extends AppController {
    var $uses = '';
    function sendEmail() {
        $mail = new PHPMailer();
        $mail->IsSMTP();
        $mail->SMTPAuth = true;
        $mail->SMTPSecure = 'ssl';
        $mail->Host = 'smtp.gmail.com';
        $mail->Port = 465;
        $mail->Username = "wroxexample@gmail.com";
        $mail->Password = "wroxexample123";
        $mail->SetFrom("wroxexample@gmail.com", "PHPMailer Wrox Example");
        $mail->Subject = "PHPMailer example";
        $mail->AddAddress("kprzystalski@gmail.com");
        $viewPath='email';
        $type='html';
        $viewName='registration';
        $view = new View($this);
        $view->layout=$this->layout;
        $content=$view->element($viewPath.DS.$type.DS.$viewName,
          array('name' => "John Smith"), true);
        $htmlBody= $view->renderLayout($content);
        $mail->MsgHTML($htmlBody);
        $mail->Send();
    }
}
code snippet /phpMailer/cakephp/app/controllers/registration_controller.php

As you did with SwiftMailer, you need to include the PHPMailer libraries using the import() method. Note that you also need to use the View class to create e-mail contents using templates.

To send an e-mail with PHPMailer, you need to create an instance of PHPMailer and set some commonly known attributes.

$mail = new PHPMailer();
$mail->SetFrom("boss@wroxexample", "Boss");
$mail->Subject = "PHPMailer example";
$mail->Body = "Hello World!";
$mail->AddAddress("john@wroxexample.com");
$mail->Send();

HTML e-mail can be sent using the MsgHTML() method. PHPMailer has a nice attribute, AltBody, which allows you to set a message that is shown when recipient can't receive HTML e-mail. Getting templates is done in the same way as in SwiftMailer.

$mail = new PHPMailer();
$mail->SetFrom("boss@wroxexample", "Boss");
$mail->Subject = "Wrox example";
$htmlTemplate = new Zend_View();
$htmlTemplate->addScriptPath(APPLICATION_PATH.'/views/scripts/email/');
$htmlTemplate->assign('name','Foo Bar');
$htmlBody = $htmlTemplate ->render('registration.phtml');
$mail->AltBody="To view the message, use an HTML compatible e-mail viewer!";
$mail->MsgHTML($htmlBody);
$mail->AddAddress("john@wroxexample.com");
$mail->Send();

PHPMailer has options very similar to the CakePHP mailing component. You can attach a file using its file system path.

$mail = new PHPMailer();
$mail->SetFrom("boss@wroxexample", "Boss");
$mail->Subject = "PHPMailer example";
$mail->MsgHTML("Hello World!");

$mail->AddAddress("john@wroxexample.com");
$mail->AddAttachment("attachments/schedule.doc");
$mail->AddAttachment("attachments/fnf84y534thb38h53.doc","plan.doc");
$mail->Send();

Additionally, you can set the name of the attachment that will be shown to the recipient.

This solution delivers three methods with which we can set the reply address, add additional recipients, and add hidden recipients: AddReplyTo(), AddCC(), and AddBCC().

$mail = new PHPMailer();
$mail->SetFrom("boss@wroxexample", "Boss");
$mail->Subject = "PHPMailer example";
$mail->MsgHTML("Hello World!");
$mail->AddAddress("john@wroxexample.com");
$mail->AddReplyTo("pm@wroxexample.com","PM");
$mail->AddCC("john.smith@wroxexample.com,"John Smith");
$mail->AddBCC("foo.bar@wroxexample.com", "foo bar");
$mail->Send();

To connect to a remote SMTP server, you need to express it directly by invoking the isSMTP() method. Additionally you need to set all commonly needed attributes such as host name, port number, username, and password. PHPMailer also has additional functionalities dedicated to specific mail servers such as Qmail, Sendmail, or Gmail.

$mail = new PHPMailer();
$mail->IsSMTP();
$mail->SMTPAuth = true;
$mail->Host = 'smtp.wroxexample.com';
$mail->Port = 25;
$mail->Username = "admin@wroxexample.com";
$mail->Password = "wroxexample123";
$mail->SetFrom("admin@wroxexample.com", "Admin");
$mail->Subject ="PHPMailer example";
$mail->Body ="Hello World!";
$mail->AddAddress("john@wroxexample.com");
$mail->Send();

For a secure connection you need only to set the SMTPSecure attribute to ssl and change the port to a secured one.

$mail = new PHPMailer();
$mail->IsSMTP();
$mail->SMTPAuth = true;
$mail->SMTPSecure = 'ssl';
$mail->Host = 'smtp.gmail.com';
$mail->Port = 465;
$mail->Username = "wroxexample@gmail.com";
$mail->Password = "wroxexample123";

$mail->SetFrom("wroxexample@gmail.com", "Admin");
$mail->Subject = "PHPMailer example";
$mail->Body = "Hello World!";
$mail->AddAddress("john@wroxexample.com");
$mail->Send();

Your merged code should be as shown here.

<?php
require_once('phpmailer/class.phpmailer.php');
class RegistrationController extends Zend_Controller_Action {
    function send() {
        $mail = new PHPMailer();
        $mail->IsSMTP();
        $mail->SMTPAuth = true;
        $mail->SMTPSecure = 'ssl';
        $mail->Host = 'smtp.gmail.com';
        $mail->Port = 465;
        $mail->Username = "wroxexample@gmail.com";
        $mail->Password = "wroxexample123";
        $mail->SetFrom("wroxexample@gmail.com", "PHPMailer Wrox Example");
        $mail->Subject = "PHPMailer example";
        $mail->AddAddress("kprzystalski@gmail.com"));
        $htmlTemplate = new Zend_View();
        $htmlTemplate->addScriptPath(APPLICATION_PATH.'/views/scripts/email/');
        $htmlTemplate->assign('name','Foo Bar');
        $htmlBody = $htmlTemplate ->render('registration.phtml');
        $mail->MsgHTML($htmlBody);
        $mail->Send();
    }
}
code snippet /phpMailer/zf/application/controllers/RegistrationController.php