Coverage Report - org.melati.util.Email
 
Classes in this File Line Coverage Branch Coverage Complexity
Email
73%
66/90
68%
15/22
3.375
 
 1  
 /*
 2  
  * $Source: /usr/cvsroot/melati/melati/src/site/resources/withWebmacro/org.melati.util.Email.html,v $
 3  
  * $Revision: 1.1 $
 4  
  *
 5  
  * Copyright (C) 2006 Tim Pizey
 6  
  *
 7  
  * Part of Melati (http://melati.org), a framework for the rapid
 8  
  * development of clean, maintainable web applications.
 9  
  *
 10  
  * Melati is free software; Permission is granted to copy, distribute
 11  
  * and/or modify this software under the terms either:
 12  
  *
 13  
  * a) the GNU General Public License as published by the Free Software
 14  
  *    Foundation; either version 2 of the License, or (at your option)
 15  
  *    any later version,
 16  
  *
 17  
  *    or
 18  
  *
 19  
  * b) any version of the Melati Software License, as published
 20  
  *    at http://melati.org
 21  
  *
 22  
  * You should have received a copy of the GNU General Public License and
 23  
  * the Melati Software License along with this program;
 24  
  * if not, write to the Free Software Foundation, Inc.,
 25  
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
 26  
  * GNU General Public License and visit http://melati.org to obtain the
 27  
  * Melati Software License.
 28  
  *
 29  
  * Feel free to contact the Developers of Melati (http://melati.org),
 30  
  * if you would like to work out a different arrangement than the options
 31  
  * outlined here.  It is our intention to allow Melati to be used by as
 32  
  * wide an audience as possible.
 33  
  *
 34  
  * This program is distributed in the hope that it will be useful,
 35  
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 36  
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 37  
  * GNU General Public License for more details.
 38  
  *
 39  
  * Contact details for copyright holder:
 40  
  *
 41  
  *     Tim Pizey <timp At paneris.org>
 42  
  *     http://paneris.org/~timp
 43  
  */
 44  
 package org.melati.util;
 45  
 
 46  
 import java.io.File;
 47  
 import java.io.IOException;
 48  
 import javax.mail.Address;
 49  
 import javax.mail.Message;
 50  
 import javax.mail.MessagingException;
 51  
 import javax.mail.Multipart;
 52  
 import javax.mail.Session;
 53  
 import javax.mail.Transport;
 54  
 import javax.mail.internet.InternetAddress;
 55  
 import javax.mail.internet.MimeBodyPart;
 56  
 import javax.mail.internet.MimeMessage;
 57  
 import javax.mail.internet.MimeMultipart;
 58  
 //import org.melati.poem.Database;
 59  
 
 60  
 import javax.activation.DataHandler;
 61  
 import javax.activation.FileDataSource;
 62  
 
 63  
 /**
 64  
  * Send an email to one or more recipients with or without attachments.
 65  
  */
 66  
 public final class Email {
 67  
 
 68  
   /** Property key for the SMTP server.*/
 69  2
   public static String SMTPSERVER = "SMTPServer";
 70  
 
 71  0
   private Email() {
 72  0
   }
 73  
 
 74  
   /**
 75  
    * deprecated try to disentangle poem and utils
 76  
    */
 77  
 /*  
 78  
   public static void send(Database database, String from, String to,
 79  
                           String replyto, String subject, String text) 
 80  
       throws EmailException, IOException {
 81  
     File[] empty = {};
 82  
     String smtpServer = database.getSettingTable().get(SMTPSERVER);
 83  
     sendWithAttachments(smtpServer, from, to, replyto, subject, text, empty);
 84  
   }
 85  
 */
 86  
   /**
 87  
    * Send the email.
 88  
    * @param smtpServer name of SMTP server to use
 89  
    * @param from email address and optionally name of sender
 90  
    * @param to email address and optionally name of recipient 
 91  
    * @param replyto email address and optionally name to reply to
 92  
    * @param subject subject of message
 93  
    * @param text text body of email
 94  
    */
 95  
   public static void send(String smtpServer, String from, String to,
 96  
                           String replyto, String subject, String text) 
 97  
       throws EmailException, IOException {
 98  4
     File[] empty = {};
 99  4
     sendWithAttachments(smtpServer, from, to, replyto, subject, text, empty);
 100  2
   }
 101  
 
 102  
  /*
 103  
   public static void sendToList(Database database, String from,
 104  
           String[] toList, String apparentlyTo, String replyto, String subject,
 105  
           String message) throws EmailException, IOException {
 106  
     File[] empty = {};
 107  
 
 108  
     String smtpServer = database.getSettingTable().get(SMTPSERVER);
 109  
     for (int i = 0; i < toList.length; i++)
 110  
       sendWithAttachments(smtpServer, from, toList[i], replyto, subject, message, empty);
 111  
   }
 112  
 */
 113  
   /**
 114  
    * Send the email to a list of recipients.
 115  
    * 
 116  
    * @param smtpServer name of SMTP server to use
 117  
    * @param from email address and optionally name of sender
 118  
    * @param toList list of email addresses and optionally names of recipients
 119  
    * @param replyto email address and optionally name to reply to
 120  
    * @param subject subject of message
 121  
    * @param message text body of email
 122  
    */
 123  
   public static void sendToList(String smtpServer, String from,
 124  
           String[] toList,  String replyto, String subject,
 125  
           String message) throws EmailException, IOException {
 126  0
     File[] empty = {};
 127  
 
 128  0
     for (int i = 0; i < toList.length; i++)
 129  0
       sendWithAttachments(smtpServer, from, toList[i], replyto, subject, message, empty);
 130  0
   }
 131  
   
 132  
   /**
 133  
    * Send message with attachments.
 134  
    * 
 135  
    * @param smtpServer name of SMTP server to use
 136  
    * @param from email address and optionally name of sender
 137  
    * @param to email address and optionally name of recipient 
 138  
    * @param replyto email address and optionally name to reply to
 139  
    * @param subject subject of message
 140  
    * @param text text body of email
 141  
    * @param attachments Array of files to attach
 142  
    */
 143  
   public static void sendWithAttachments(String smtpServer, String from,
 144  
           String to, String replyto, String subject, String text, File[] attachments)
 145  
           throws EmailException, IOException {
 146  
 
 147  
     // Construct the message
 148  6
     Message message = initialiseMessage(smtpServer, from, to, replyto, subject);
 149  
     try {
 150  
       // create and fill the first, text message part
 151  6
       MimeBodyPart mbp1 = new MimeBodyPart();
 152  6
       mbp1.setText(text);
 153  6
       Multipart mp = new MimeMultipart();
 154  6
       mp.addBodyPart(mbp1);
 155  12
       for (int i = 0; i < attachments.length; i++) {
 156  6
         File f = attachments[i];
 157  6
         if (f != null) {
 158  
           // create the second message part
 159  2
           MimeBodyPart mbp2 = new MimeBodyPart();
 160  
           // attach the file to the message
 161  2
           FileDataSource fds = new FileDataSource(f);
 162  2
           mbp2.setDataHandler(new DataHandler(fds));
 163  2
           mbp2.setFileName(fds.getName());
 164  2
           mp.addBodyPart(mbp2);
 165  
         }
 166  
       }
 167  
       // add the Multipart to the message
 168  6
       message.setContent(mp);
 169  0
     } catch (Exception e) {
 170  0
       e.printStackTrace();
 171  0
       throw new EmailException("Problem creating message: " + e.toString());
 172  6
     }
 173  
     // send the message
 174  6
     post(message);
 175  4
   }
 176  
   
 177  
   /**
 178  
    * Send HTML message with attachments.
 179  
    * 
 180  
    * @param smtpServer name of SMTP server to use
 181  
    * @param from email address and optionally name of sender
 182  
    * @param to email address and optionally name of recipient 
 183  
    * @param replyto email address and optionally name to reply to
 184  
    * @param subject subject of message
 185  
    * @param plainText text body of email
 186  
    * @param htmlText HTML body of email
 187  
    * @param referenced Array of Files referenced withing the HTML body
 188  
    * @param attachments Array of files to attach
 189  
    */
 190  
   public static void sendAsHtmlWithAttachments(String smtpServer, String from,
 191  
           String to, String replyto, String subject, String plainText,
 192  
           String htmlText, File[] referenced, File[] attachments)
 193  
           throws EmailException, IOException {
 194  
 
 195  
     // Construct the message
 196  2
     Message message = initialiseMessage(smtpServer, from, to, replyto, subject);
 197  
     try {
 198  2
       Multipart mp = new MimeMultipart("related");
 199  2
       MimeBodyPart mbp1 = new MimeBodyPart();
 200  
       //mbp1.setText(plainText);
 201  2
       mbp1.setContent(plainText, "text/plain");
 202  2
       mp.addBodyPart(mbp1);
 203  2
       MimeBodyPart mbp2 = new MimeBodyPart();
 204  2
       mbp2.setContent(htmlText, "text/html");
 205  2
       mp.addBodyPart(mbp2);
 206  
 
 207  2
       if (referenced != null) {
 208  4
         for (int i = 0; i < referenced.length; i++) {
 209  2
           File f = referenced[i];
 210  2
           if (f != null) {
 211  0
             MimeBodyPart mbp3 = new MimeBodyPart();
 212  0
             FileDataSource fds = new FileDataSource(f);
 213  0
             mbp3.setDataHandler(new DataHandler(fds));
 214  0
             mbp3.setFileName(fds.getName());
 215  0
             mp.addBodyPart(mbp3);
 216  
           }
 217  
         }
 218  
       }
 219  2
       if (attachments != null) {
 220  6
         for (int i = 0; i < attachments.length; i++) {
 221  4
           File f = attachments[i];
 222  4
           if (f != null) {
 223  2
             MimeBodyPart mbp4 = new MimeBodyPart();
 224  2
             if (f.getName() == null) {
 225  0
               System.out.println("name is null");
 226  
             }
 227  2
             FileDataSource fds = new FileDataSource(f);
 228  2
             mbp4.setDataHandler(new DataHandler(fds));
 229  2
             mbp4.setFileName(fds.getName());
 230  2
             mp.addBodyPart(mbp4);
 231  
           }
 232  
         }
 233  
       }
 234  
       // add the Multipart to the message
 235  2
       message.setContent(mp);
 236  0
     } catch (Exception e) {
 237  0
       e.printStackTrace();
 238  0
       throw new EmailException("Problem creating message: " + e.toString());
 239  2
     }
 240  
     // send the message
 241  2
     post(message);
 242  2
   }
 243  
 
 244  
   private static Message initialiseMessage(String smtpServer, String from,
 245  
           String to, String replyto, String subject) throws EmailException {
 246  
     // Create the JavaMail session
 247  
     // The properties for the whole system, sufficient to send a mail
 248  
     // and much more besides.
 249  8
     java.util.Properties properties = System.getProperties();
 250  8
     properties.put("mail.smtp.host", smtpServer);
 251  
     // this is required if InetAddress.getLocalHost().getHostName()  returns null
 252  
     // which it does nor me in Eclipse
 253  8
     properties.put("mail.smtp.localhost", smtpServer);
 254  8
     Session session = Session.getInstance(properties, null);
 255  8
     MimeMessage message = new MimeMessage(session);
 256  
     // Set the from address
 257  
     Address fromAddress;
 258  
     try {
 259  8
       fromAddress = new InternetAddress(from);
 260  8
       message.setFrom(fromAddress);
 261  
       // Parse and set the recipient addresses
 262  8
       Address[] toAddresses = InternetAddress.parse(to);
 263  8
       message.setRecipients(Message.RecipientType.TO, toAddresses);
 264  
       /*
 265  
        * Address[] ccAddresses = InternetAddress.parse(cc);
 266  
        * message.setRecipients(Message.RecipientType.CC,ccAddresses);
 267  
        * 
 268  
        * Address[] bccAddresses = InternetAddress.parse(bcc);
 269  
        * message.setRecipients(Message.RecipientType.BCC,bccAddresses);
 270  
        */
 271  8
       if (replyto != null) {
 272  0
         Address[] replyTos = InternetAddress.parse(replyto);
 273  0
         message.setReplyTo(replyTos);
 274  
       }
 275  8
       message.setSubject(subject);
 276  0
     } catch (Exception e) {
 277  0
       e.printStackTrace();
 278  0
       throw new EmailException("Problem sending message: " + e.toString());
 279  8
     }
 280  8
     return message;
 281  
   }
 282  
   
 283  
   private static void post(Message message) throws EmailException {
 284  
     try {
 285  8
       Transport.send(message);
 286  2
     } catch (MessagingException e) {
 287  2
       e.printStackTrace();
 288  2
       throw new EmailException("Problem sending message: " + e.toString());
 289  6
     }
 290  
     
 291  6
   }
 292  
   /**
 293  
    * @return a fancy email address
 294  
    */
 295  
   public static String mailAddress(String name, String email) {
 296  0
     return name + " <" + email + ">";
 297  
   }
 298  
 
 299  
 }