| /* |
| * Copyright 2001-2004 The Apache Software Foundation |
| * |
| * Licensed under the Apache License, Version 2.0 ( the "License" ); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.mail; |
| |
| import java.io.UnsupportedEncodingException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Properties; |
| |
| import javax.mail.Authenticator; |
| import javax.mail.Message; |
| import javax.mail.MessagingException; |
| import javax.mail.Session; |
| import javax.mail.Store; |
| import javax.mail.Transport; |
| import javax.mail.internet.InternetAddress; |
| import javax.mail.internet.MimeMessage; |
| import javax.mail.internet.MimeMultipart; |
| |
| import org.apache.commons.lang.StringUtils; |
| |
| /** |
| * The base class for all email messages. This class sets the |
| * sender's email & name, receiver's email & name, subject, and the |
| * sent date. Subclasses are responsible for setting the message |
| * body. |
| * |
| * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a> |
| * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a> |
| * @author <a href="mailto:frank.kim@clearink.com">Frank Y. Kim</a> |
| * @author <a href="mailto:bmclaugh@algx.net">Brett McLaughlin</a> |
| * @author <a href="mailto:greg@shwoop.com">Greg Ritter</a> |
| * @author <a href="mailto:unknown">Regis Koenig</a> |
| * @author <a href="mailto:colin.chalmers@maxware.nl">Colin Chalmers</a> |
| * @author <a href="mailto:matthias@wessendorf.net">Matthias Wessendorf</a> |
| * @author <a href="mailto:corey.scott@gmail.com">Corey Scott</a> |
| * @version $Revision: 1.1 $ $Date: 2004/11/25 09:56:56 $ |
| * @version $Id: Email.java,v 1.1 2004/11/25 09:56:56 epugh Exp $ |
| */ |
| public abstract class Email |
| { |
| /** Constants used by Email classes. */ |
| |
| /** */ |
| public static final String SENDER_EMAIL = "sender.email"; |
| /** */ |
| public static final String SENDER_NAME = "sender.name"; |
| /** */ |
| public static final String RECEIVER_EMAIL = "receiver.email"; |
| /** */ |
| public static final String RECEIVER_NAME = "receiver.name"; |
| /** */ |
| public static final String EMAIL_SUBJECT = "email.subject"; |
| /** */ |
| public static final String EMAIL_BODY = "email.body"; |
| /** */ |
| public static final String CONTENT_TYPE = "content.type"; |
| |
| /** */ |
| public static final String MAIL_HOST = "mail.host"; |
| /** */ |
| public static final String MAIL_PORT = "mail.smtp.port"; |
| /** */ |
| public static final String MAIL_SMTP_FROM = "mail.smtp.from"; |
| /** */ |
| public static final String MAIL_SMTP_AUTH = "mail.smtp.auth"; |
| /** */ |
| public static final String MAIL_TRANSPORT_PROTOCOL = |
| "mail.transport.protocol"; |
| /** */ |
| public static final String SMTP = "smtp"; |
| /** */ |
| public static final String TEXT_HTML = "text/html"; |
| /** */ |
| public static final String TEXT_PLAIN = "text/plain"; |
| /** */ |
| public static final String ATTACHMENTS = "attachments"; |
| /** */ |
| public static final String FILE_SERVER = "file.server"; |
| /** */ |
| public static final String MAIL_DEBUG = "mail.debug"; |
| |
| /** */ |
| public static final String KOI8_R = "koi8-r"; |
| /** */ |
| public static final String ISO_8859_1 = "iso-8859-1"; |
| /** */ |
| public static final String US_ASCII = "us-ascii"; |
| |
| /** The email message to send. */ |
| protected MimeMessage message; |
| |
| /** The charset to use for this message */ |
| protected String charset; |
| |
| /** The Address of the sending party, mandatory */ |
| protected InternetAddress fromAddress; |
| |
| /** The Subject */ |
| protected String subject; |
| |
| /** An attachment */ |
| protected MimeMultipart emailBody; |
| |
| /** The content */ |
| protected Object content; |
| |
| /** The content type */ |
| protected String contentType; |
| |
| /** Set session debugging on or off */ |
| protected boolean debug = false; |
| |
| /** Sent date */ |
| protected Date sentDate; |
| |
| /** The Session to mail with */ |
| private Session session; |
| |
| /** |
| * Instance of an <code>Authenticator</code> object that will be used |
| * when authentication is requested from the mail server. |
| */ |
| protected Authenticator authenticator; |
| |
| /** |
| * The hostname of the mail server with which to connect. If null will try |
| * to get property from system.properties. If still null, quit |
| */ |
| protected String hostName; |
| |
| /** |
| * The port number of the mail server to connect to. |
| * Defaults to the standard port ( 25 ). |
| */ |
| protected String smtpPort = "25"; |
| |
| /** List of "to" email adresses */ |
| protected ArrayList toList = new ArrayList(); |
| |
| /** List of "cc" email adresses */ |
| protected ArrayList ccList = new ArrayList(); |
| |
| /** List of "bcc" email adresses */ |
| protected ArrayList bccList = new ArrayList(); |
| |
| /** List of "replyTo" email adresses */ |
| protected ArrayList replyList = new ArrayList(); |
| |
| /** |
| * Address to which undeliverable mail should be sent. |
| * Because this is handled by JavaMail as a String property |
| * in the mail session, this property is of type <code>String</code> |
| * rather than <code>InternetAddress</code>. |
| */ |
| protected String bounceAddress = null; |
| |
| /** |
| * Used to specify the mail headers. Example: |
| * |
| * X-Mailer: Sendmail, X-Priority: 1( highest ) |
| * or 2( high ) 3( normal ) 4( low ) and 5( lowest ) |
| * Disposition-Notification-To: user@domain.net |
| */ |
| protected Hashtable headers = new Hashtable(); |
| |
| /** |
| * Used to determine whether to use pop3 before smtp, and if so the settings. |
| */ |
| |
| /** */ |
| protected boolean popBeforeSmtp = false; |
| /** */ |
| protected String popHost = null; |
| /** */ |
| protected String popUsername = null; |
| /** */ |
| protected String popPassword = null; |
| |
| /** |
| * Setting to true will enable the display of debug information. |
| * |
| * @param d A boolean. |
| */ |
| public void setDebug(boolean d) |
| { |
| this.debug = d; |
| } |
| |
| /** |
| * Sets the userName and password if authentication is needed. If this |
| * method is not used, no authentication will be performed. |
| * <p> |
| * This method will create a new instance of |
| * <code>DefaultAuthenticator</code> using the supplied parameters. |
| * |
| * @param userName User name for the SMTP server |
| * @param password password for the SMTP server |
| * @see DefaultAuthenticator |
| * @see #setAuthenticator |
| */ |
| public void setAuthentication(String userName, String password) |
| { |
| this.authenticator = new DefaultAuthenticator(userName, password); |
| this.setAuthenticator(this.authenticator); |
| } |
| |
| /** |
| * Sets the <code>Authenticator</code> to be used when authentication |
| * is requested from the mail server. |
| * <p> |
| * This method should be used when your outgoing mail server requires |
| * authentication. Your mail server must also support RFC2554. |
| * |
| * @param newAuthenticator the <code>Authenticator</code> object. |
| * @see Authenticator |
| */ |
| public void setAuthenticator(Authenticator newAuthenticator) |
| { |
| this.authenticator = newAuthenticator; |
| } |
| |
| /** |
| * Set the charset of the message. |
| * |
| * @param newCharset A String. |
| */ |
| public void setCharset(String newCharset) |
| { |
| this.charset = newCharset; |
| } |
| |
| /** |
| * Set the emailBody to a MimeMultiPart |
| * |
| * @param aMimeMultipart aMimeMultipart |
| */ |
| public void setContent(MimeMultipart aMimeMultipart) |
| { |
| this.emailBody = aMimeMultipart; |
| } |
| |
| /** |
| * Set the content & contentType |
| * |
| * @param aObject aObject |
| * @param aContentType aContentType |
| */ |
| public void setContent(Object aObject, String aContentType) |
| { |
| this.content = aObject; |
| if (!StringUtils.isNotEmpty(aContentType)) |
| { |
| this.contentType = null; |
| } |
| else |
| { |
| // set the content type |
| this.contentType = aContentType; |
| |
| // set the charset if the input was properly formed |
| String strMarker = "; charset="; |
| int charsetPos = aContentType.toLowerCase().indexOf(strMarker); |
| |
| if (charsetPos != -1) |
| { |
| // find the next space (after the marker) |
| charsetPos += strMarker.length(); |
| int intCharsetEnd = |
| aContentType.toLowerCase().indexOf(" ", charsetPos); |
| |
| if (intCharsetEnd != -1) |
| { |
| this.charset = |
| aContentType.substring(charsetPos, intCharsetEnd); |
| } |
| else |
| { |
| this.charset = aContentType.substring(charsetPos); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Set the hostname of the outgoing mail server |
| * |
| * @param aHostName aHostName |
| */ |
| public void setHostName(String aHostName) |
| { |
| this.hostName = aHostName; |
| } |
| |
| /** |
| * Set the port number of the outgoing mail server. |
| * @param aPortNumber aPortNumber |
| */ |
| public void setSmtpPort(int aPortNumber) |
| { |
| if (aPortNumber < 1) |
| { |
| throw new IllegalArgumentException( |
| "Cannot connect to a port number that is less than 1 ( " |
| + aPortNumber |
| + " )"); |
| } |
| |
| this.smtpPort = Integer.toString(aPortNumber); |
| } |
| |
| /** |
| * Supply a mail Session object to use |
| * @param aSession mail session to be used |
| */ |
| public void setMailSession(Session aSession) |
| { |
| this.session = aSession; |
| } |
| /** |
| * Initialise a mailsession object |
| * |
| * @return A Session. |
| * @throws MessagingException thrown when host name was not set |
| */ |
| protected Session getMailSession() throws MessagingException |
| { |
| if (this.session == null) |
| { |
| Properties properties = new Properties(System.getProperties()); |
| properties.setProperty(MAIL_TRANSPORT_PROTOCOL, SMTP); |
| |
| if (!StringUtils.isNotEmpty(this.hostName)) |
| { |
| this.hostName = properties.getProperty(MAIL_HOST); |
| } |
| |
| if (!StringUtils.isNotEmpty(this.hostName)) |
| { |
| throw new MessagingException( |
| "Cannot find valid hostname for mail session"); |
| } |
| |
| properties.setProperty(MAIL_PORT, smtpPort); |
| properties.setProperty(MAIL_HOST, hostName); |
| properties.setProperty(MAIL_DEBUG, String.valueOf(this.debug)); |
| |
| if (this.authenticator != null) |
| { |
| properties.setProperty(MAIL_SMTP_AUTH, "true"); |
| } |
| |
| if (this.bounceAddress != null) |
| { |
| properties.setProperty(MAIL_SMTP_FROM, this.bounceAddress); |
| } |
| |
| // changed this (back) to getInstance due to security exceptions |
| // caused when testing using maven |
| this.session = |
| Session.getInstance(properties, this.authenticator); |
| } |
| return this.session; |
| } |
| |
| /** |
| * Set the FROM field of the email. |
| * |
| * @param email A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email setFrom(String email) throws MessagingException |
| { |
| return setFrom(email, null); |
| } |
| |
| /** |
| * Set the FROM field of the email. |
| * |
| * @param email A String. |
| * @param name A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email setFrom(String email, String name) throws MessagingException |
| { |
| try |
| { |
| // check name input |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| name = email; |
| } |
| |
| // set/update the from address |
| if (this.fromAddress == null) |
| { |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.fromAddress = |
| new InternetAddress(email, name, this.charset); |
| } |
| else |
| { |
| this.fromAddress = new InternetAddress(email, name); |
| } |
| } |
| else |
| { |
| this.fromAddress.setAddress(email); |
| this.fromAddress.setPersonal(name); |
| } |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| throw new MessagingException("cannot set from", e); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Add a recipient TO to the email. |
| * |
| * @param email A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addTo(String email) throws MessagingException |
| { |
| return addTo(email, null); |
| } |
| |
| /** |
| * Add a recipient TO to the email. |
| * |
| * @param email A String. |
| * @param name A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addTo(String email, String name) throws MessagingException |
| { |
| try |
| { |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| name = email; |
| } |
| |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.toList.add(new InternetAddress(email, name, this.charset)); |
| } |
| else |
| { |
| this.toList.add(new InternetAddress(email, name)); |
| } |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| throw new MessagingException("cannot add to", e); |
| } |
| return this; |
| } |
| |
| /** |
| * Set a list of "TO" addresses |
| * |
| * @param aCollection collection of InternetAddress objects |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email setTo(Collection aCollection) throws MessagingException |
| { |
| if (aCollection == null || aCollection.isEmpty()) |
| { |
| throw new MessagingException("Address List provided was invalid"); |
| } |
| |
| this.toList = new ArrayList(aCollection); |
| return this; |
| } |
| |
| /** |
| * Add a recipient CC to the email. |
| * |
| * @param email A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addCc(String email) throws MessagingException |
| { |
| return this.addCc(email, null); |
| } |
| |
| /** |
| * Add a recipient CC to the email. |
| * |
| * @param email A String. |
| * @param name A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addCc(String email, String name) throws MessagingException |
| { |
| try |
| { |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| name = email; |
| } |
| |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.ccList.add(new InternetAddress(email, name, this.charset)); |
| } |
| else |
| { |
| this.ccList.add(new InternetAddress(email, name)); |
| } |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| throw new MessagingException("cannot add cc", e); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Set a list of "CC" addresses |
| * |
| * @param aCollection collection of InternetAddress objects |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email setCc(Collection aCollection) throws MessagingException |
| { |
| if (aCollection == null || aCollection.isEmpty()) |
| { |
| throw new MessagingException("Address List provided was invalid"); |
| } |
| |
| this.ccList = new ArrayList(aCollection); |
| return this; |
| } |
| |
| /** |
| * Add a blind BCC recipient to the email. |
| * |
| * @param email A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addBcc(String email) throws MessagingException |
| { |
| return this.addBcc(email, null); |
| } |
| |
| /** |
| * Add a blind BCC recipient to the email. |
| * |
| * @param email A String. |
| * @param name A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addBcc(String email, String name) throws MessagingException |
| { |
| try |
| { |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| name = email; |
| } |
| |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.bccList.add( |
| new InternetAddress(email, name, this.charset)); |
| } |
| else |
| { |
| this.bccList.add(new InternetAddress(email, name)); |
| } |
| |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| throw new MessagingException("cannot add bcc", e); |
| } |
| |
| return this; |
| } |
| |
| /** |
| * Set a list of "BCC" addresses |
| * |
| * @param aCollection collection of InternetAddress objects |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email setBcc(Collection aCollection) throws MessagingException |
| { |
| if (aCollection == null || aCollection.isEmpty()) |
| { |
| throw new MessagingException("Address List provided was invalid"); |
| } |
| |
| this.bccList = new ArrayList(aCollection); |
| return this; |
| } |
| |
| /** |
| * Add a reply to address to the email. |
| * |
| * @param email A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addReplyTo(String email) throws MessagingException |
| { |
| return this.addReplyTo(email, null); |
| } |
| |
| /** |
| * Add a reply to address to the email. |
| * |
| * @param email A String. |
| * @param name A String. |
| * @return An Email. |
| * @throws MessagingException Indicates an invalid email address |
| */ |
| public Email addReplyTo(String email, String name) |
| throws MessagingException |
| { |
| try |
| { |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| name = email; |
| } |
| |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.replyList.add( |
| new InternetAddress(email, name, this.charset)); |
| } |
| else |
| { |
| this.replyList.add(new InternetAddress(email, name)); |
| } |
| } |
| catch (UnsupportedEncodingException e) |
| { |
| throw new MessagingException("cannot add replyTo", e); |
| } |
| return this; |
| } |
| |
| /** |
| * Used to specify the mail headers. Example: |
| * |
| * X-Mailer: Sendmail, X-Priority: 1( highest ) |
| * or 2( high ) 3( normal ) 4( low ) and 5( lowest ) |
| * Disposition-Notification-To: user@domain.net |
| * |
| * @param ht A Hashtable. |
| */ |
| public void setHeaders(Hashtable ht) |
| { |
| Enumeration enumKeyBad = ht.keys(); |
| |
| while (enumKeyBad.hasMoreElements()) |
| { |
| String strName = (String) enumKeyBad.nextElement(); |
| String strValue = (String) ht.get(strName); |
| |
| if (!StringUtils.isNotEmpty(strName)) |
| { |
| throw new IllegalArgumentException("name can not be null"); |
| } |
| if (!StringUtils.isNotEmpty(strValue)) |
| { |
| throw new IllegalArgumentException("value can not be null"); |
| } |
| } |
| |
| // all is ok, update headers |
| this.headers = ht; |
| } |
| |
| /** |
| * Adds a header ( name, value ) to the headers Hashtable. |
| * |
| * @param name A String with the name. |
| * @param value A String with the value. |
| */ |
| public void addHeader(String name, String value) |
| { |
| if (!StringUtils.isNotEmpty(name)) |
| { |
| throw new IllegalArgumentException("name can not be null"); |
| } |
| if (!StringUtils.isNotEmpty(value)) |
| { |
| throw new IllegalArgumentException("value can not be null"); |
| } |
| |
| this.headers.put(name, value); |
| } |
| |
| /** |
| * Set the email subject. |
| * |
| * @param aSubject A String. |
| * @return An Email. |
| */ |
| public Email setSubject(String aSubject) |
| { |
| this.subject = aSubject; |
| return this; |
| } |
| |
| /** |
| * Set the "bounce address" - the address to which undeliverable messages |
| * will be returned. If this value is never set, then the message will be |
| * sent to the address specified with the System property "mail.smtp.from", |
| * or if that value is not set, then to the "from" address. |
| * |
| * @param email A String. |
| * @return An Email. |
| */ |
| public Email setBounceAddress(String email) |
| { |
| this.bounceAddress = email; |
| return this; |
| } |
| |
| |
| /** |
| * Define the content of the mail. It should be overidden by the |
| * subclasses. |
| * |
| * @param msg A String. |
| * @return An Email. |
| * @throws MessagingException generic exception |
| */ |
| public abstract Email setMsg(String msg) throws MessagingException; |
| |
| /** |
| * Does the work of actually sending the email. |
| * |
| * @throws MessagingException if there was an error. |
| */ |
| public void send() throws MessagingException |
| { |
| this.getMailSession(); |
| this.message = new MimeMessage(this.session); |
| |
| if (StringUtils.isNotEmpty(this.subject)) |
| { |
| if (StringUtils.isNotEmpty(this.charset)) |
| { |
| this.message.setSubject(this.subject, this.charset); |
| } |
| else |
| { |
| this.message.setSubject(this.subject); |
| } |
| } |
| |
| // |
| // As far as i can tell, this logic is circular with |
| // the setContent( Object, String ) method. |
| // There is no way for the content variable to be set without |
| // the contentType also being set. |
| // The logic below therefore appears to be a duplication of |
| // the setContent( Object, String ) method |
| // or if not should it not be moved to that method? |
| // (Proposed replacement code below) |
| // if ( this.content != null ) |
| // { |
| // String type = this.contentType; |
| // |
| // if ( type != null && !type.trim().equals( "" ) |
| // && this.charset != null |
| // && !this.charset.trim().equals( "" ) ) |
| // { |
| // type += "; charset=" + this.charset; |
| // } |
| // |
| // this.message.setContent( this.content, type ); |
| // } |
| |
| // ======================================================== |
| // Start of replacement code |
| if (this.content != null) |
| { |
| this.message.setContent(this.content, this.contentType); |
| } |
| // end of replacement code |
| // ======================================================== |
| else if (this.emailBody != null) |
| { |
| this.message.setContent(this.emailBody); |
| } |
| else |
| { |
| this.message.setContent("", Email.TEXT_PLAIN); |
| } |
| |
| if (this.fromAddress != null) |
| { |
| this.message.setFrom(this.fromAddress); |
| } |
| else |
| { |
| throw new MessagingException("Sender address required"); |
| } |
| |
| if (this.toList.size() + this.ccList.size() + this.bccList.size() == 0) |
| { |
| throw new MessagingException( |
| "At least one receiver address required"); |
| } |
| |
| if (this.toList.size() > 0) |
| { |
| this.message.setRecipients( |
| Message.RecipientType.TO, |
| this.toInternetAddressArray(this.toList)); |
| } |
| |
| if (this.ccList.size() > 0) |
| { |
| this.message.setRecipients( |
| Message.RecipientType.CC, |
| this.toInternetAddressArray(this.ccList)); |
| } |
| |
| if (this.bccList.size() > 0) |
| { |
| this.message.setRecipients( |
| Message.RecipientType.BCC, |
| this.toInternetAddressArray(this.bccList)); |
| } |
| |
| if (this.replyList.size() > 0) |
| { |
| this.message.setReplyTo( |
| this.toInternetAddressArray(this.replyList)); |
| } |
| |
| if (this.headers.size() > 0) |
| { |
| Enumeration enum = this.headers.keys(); |
| |
| while (enum.hasMoreElements()) |
| { |
| String name = (String) enum.nextElement(); |
| String value = (String) headers.get(name); |
| this.message.addHeader(name, value); |
| } |
| } |
| |
| if (this.message.getSentDate() == null) |
| { |
| this.message.setSentDate(getSentDate()); |
| } |
| |
| if (this.popBeforeSmtp) |
| { |
| Store store = session.getStore("pop3"); |
| store.connect(this.popHost, this.popUsername, this.popPassword); |
| } |
| |
| Transport.send(this.message); |
| } |
| |
| /** |
| * Sets the sent date for the email. The sent date will default to the |
| * current date if not explictly set. |
| * |
| * @param date Date to use as the sent date on the email |
| */ |
| public void setSentDate(Date date) |
| { |
| this.sentDate = date; |
| } |
| |
| /** |
| * Gets the sent date for the email. |
| * |
| * @return date to be used as the sent date for the email |
| */ |
| public Date getSentDate() |
| { |
| if (this.sentDate == null) |
| { |
| return new Date(); |
| } |
| else |
| { |
| return this.sentDate; |
| } |
| } |
| |
| /** |
| * Utility to copy ArrayList of known InternetAddress objects into an |
| * array. |
| * |
| * @param aList A ArrayList. |
| * @return An InternetAddress[]. |
| */ |
| protected InternetAddress[] toInternetAddressArray(ArrayList aList) |
| { |
| InternetAddress[] ia = |
| (InternetAddress[]) aList.toArray(new InternetAddress[0]); |
| |
| return ia; |
| } |
| |
| /** |
| * Set details regarding "pop3 before smtp" authentication |
| * @param newPopBeforeSmtp Wether or not to log into pop3 |
| * server before sending mail |
| * @param newPopHost The pop3 host to use. |
| * @param newPopUsername The pop3 username. |
| * @param newPopPassword The pop3 password. |
| */ |
| public void setPopBeforeSmtp( |
| boolean newPopBeforeSmtp, |
| String newPopHost, |
| String newPopUsername, |
| String newPopPassword) |
| { |
| this.popBeforeSmtp = newPopBeforeSmtp; |
| this.popHost = newPopHost; |
| this.popUsername = newPopUsername; |
| this.popPassword = newPopPassword; |
| } |
| } |