DefaultEmailService.java
/*
* This software was designed and created by Jason Carroll.
* Copyright (c) 2002, 2003, 2004 Jason Carroll.
* The author can be reached at jcarroll@cowsultants.com
* ITracker website: http://www.cowsultants.com
* ITracker forums: http://www.cowsultants.com/phpBB/index.php
*
* This program is free software; you can redistribute it and/or modify
* it only under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
package org.itracker.services.implementations;
import org.apache.log4j.Logger;
import org.itracker.services.ConfigurationService;
import org.itracker.services.EmailService;
import org.itracker.util.EmailAuthenticator;
import org.itracker.util.NamingUtilites;
import javax.mail.*;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.io.UnsupportedEncodingException;
import java.util.*;
public class DefaultEmailService implements EmailService {
private ConfigurationService configurationService;
@Deprecated
public static final String DEFAULT_FROM_ADDRESS = "itracker@localhost";
@Deprecated
public static final String DEFAULT_FROM_TEXT = "ITracker Notification System";
@Deprecated
public static final String DEFAULT_REPLYTO_ADDRESS = "itracker@localhost";
@Deprecated
public static final String DEFAULT_SMTP_HOST = "localhost";
public static final String DEFAULT_SMTP_CHARSET = "ISO-8859-1";
private Session session;
private final Logger logger = Logger.getLogger(DefaultEmailService.class);
private InternetAddress replyTo;
private InternetAddress from;
public void setConfigurationService(
ConfigurationService configurationService) {
if (null == configurationService) {
throw new IllegalArgumentException("configuration service must not be null.");
}
if (null != this.configurationService) {
throw new IllegalStateException("configuration service was already set.");
}
this.configurationService = configurationService;
}
/**
* @deprecated use mailssession from JNDI instead
*/
private void initMailsession(String smtpHost, String smtpUserid, String smtpPassword) {
Authenticator smtpAuth = null;
Properties props = new Properties();
props.put("mail.smtp.host", smtpHost);
// props.put("mail.mime.charset", this.smtpCharset);
if (smtpUserid != null && smtpPassword != null) {
smtpAuth = new EmailAuthenticator(
new PasswordAuthentication(smtpUserid,
smtpPassword));
}
this.session = Session.getInstance(props, smtpAuth);
}
private void initCharset(String smtpCharset) {
if (null != smtpCharset) {
try {
new String(new byte[0], smtpCharset);
this.session.getProperties().put("mail.mime.charset",
smtpCharset);
logger.info("initCharset: cherset was initialized to "
+ session.getProperty("mail.mime.charset"));
} catch (UnsupportedEncodingException use) {
logger
.warn(
"initCharset: unsupported smtp charset configured, ignoring",
use);
}
}
}
private void initFrom(String fromAddress, String fromText) {
if (null != fromAddress) {
try {
this.from = new InternetAddress(fromAddress, fromText, readSmtpCharset(this.session));
logger.info("initFrom: initialized from-address: " + this.from);
} catch (UnsupportedEncodingException e) {
logger.warn("initReplyTo: could not initialize reply-to (configured: " +
fromText + " <" + fromAddress + ">", e);
}
}
}
private void initReplyTo(String replyToAddress, String replyToText) {
try {
this.replyTo = new InternetAddress(replyToAddress, replyToText, readSmtpCharset(this.session));
logger.info("initFrom: initialized reply-to: " + this.replyTo);
} catch (UnsupportedEncodingException e) {
logger.warn("initReplyTo: could not initialize reply-to (configured: " + replyToText + " <" + replyToAddress + ">", e);
}
}
public void init() {
if (this.configurationService == null) {
throw new IllegalStateException("configuration service was not set.");
}
String fromAddress = configurationService.getProperty(
"notification_from_address", DEFAULT_FROM_ADDRESS);
String fromText = configurationService.getProperty("notification_from_text",
DEFAULT_FROM_TEXT);
String replyToAddress = configurationService.getProperty(
"notification_replyto_address", DEFAULT_REPLYTO_ADDRESS);
String smtpCharset = configurationService.getProperty(
"notification_smtp_charset", DEFAULT_SMTP_CHARSET);
String mailSessionLookupName = configurationService.getMailSessionLookupName();
try {
InitialContext ctx = new InitialContext();
logger.debug("init: got Mailsession from Naming Context:" + NamingUtilites.lookup(ctx, mailSessionLookupName));
this.session = (Session) NamingUtilites.lookup(ctx, mailSessionLookupName);
} catch (NamingException e) {
logger.warn("init: failed to get Mailsession from initial context.", e);
}
if (null == this.session) {
logger
.warn("init: failed to lookup Session from JNDI lookup " + mailSessionLookupName + ", using manual session");
String smtpHost = configurationService.getProperty(
"notification_smtp_host", DEFAULT_SMTP_HOST);
String smtpUserid = configurationService.getProperty(
"notification_smtp_userid", null);
String smtpPassword = configurationService.getProperty(
"notification_smtp_password", null);
logger
.warn("init: setting up SMTP manually, no session-lookup found in configuration!");
if ("".equals(smtpUserid) || "".equals(smtpPassword)) {
smtpUserid = null;
smtpPassword = null;
}
initMailsession(smtpHost, smtpUserid, smtpPassword);
initCharset(smtpCharset);
initFrom(fromAddress, fromText);
if (logger.isDebugEnabled()) {
logger.debug("init: From Address set to: " + fromAddress);
logger.debug("init: From Text set to: " + fromText);
logger.debug("init: ReplyTo Address set to: " + replyToAddress);
logger.debug("init: SMTP server set to: " + smtpHost);
logger.debug("init: SMTP userid set to: " + smtpUserid);
logger.debug("init: SMTP password set to: " + smtpPassword);
}
} else {
initCharset(smtpCharset);
// use mailsession to initialize from.
initFrom(fromAddress, fromText);
}
initReplyTo(replyToAddress, fromText);
}
/**
* @param address
* @param subject
* @param msgText
*/
public void sendEmail(String address, String subject, String msgText) {
try {
InternetAddress[] recipients = new InternetAddress[1];
recipients[0] = new InternetAddress(address);
sendEmail(recipients, subject, msgText);
} catch (AddressException ex) {
logger.warn(
"AddressException while sending email. caught. address was "
+ address, ex);
}
}
public void sendEmail(Set<InternetAddress> recipients, String subject,
String message) {
InternetAddress[] recipientsArray = new ArrayList<InternetAddress>(recipients).toArray(new InternetAddress[new ArrayList<InternetAddress>(recipients).size()]);
if (recipientsArray.length > 0) {
this.sendEmail(recipientsArray, subject, message);
}
}
/**
* @deprecated use method with InetAddress[] addresses instead.
*/
public void sendEmail(HashSet<String> addresses, String subject,
String msgText) {
if (null == addresses || 0 == addresses.size()) {
throw new IllegalArgumentException(
"No addresses in recipients set.");
}
try {
ArrayList<InternetAddress> recipients = new ArrayList<InternetAddress>(
addresses.size());
for (String address : addresses) {
recipients.add(new InternetAddress(address));
}
sendEmail(recipients.toArray(new InternetAddress[recipients.size()]), subject,
msgText);
} catch (AddressException ex) {
logger.warn("AddressException while sending email.", ex);
}
}
/**
* @param address
* @param subject
* @param msgText
*/
public void sendEmail(InternetAddress address, String subject,
String msgText) {
this.sendEmail(new InternetAddress[]{address}, subject, msgText);
}
/**
* @param recipients
* @param subject
* @param msgText
*/
public void sendEmail(InternetAddress[] recipients, String subject,
String msgText) {
try {
if (logger.isDebugEnabled()) {
logger.debug("sendEmail: called with recipients: " + Arrays.asList(recipients) + ", subject: " + subject + ", msgText: " + subject);
}
if (null == this.session) {
throw new IllegalStateException("session was not initialized.");
}
if (null == recipients || recipients.length < 1) {
throw new IllegalArgumentException(
"at least one recipient must be specified.");
}
if (null == subject || subject.length() < 1) {
throw new IllegalArgumentException("subject must be specified.");
}
if (null == msgText) {
msgText = "Empty message";
}
MimeMessage msg = new MimeMessage(this.session);
if (null != this.from) {
msg.setFrom(this.from);
}
if (null != this.replyTo) {
msg.setReplyTo(new InternetAddress[]{this.replyTo});
}
for (InternetAddress internetAddress : recipients) {
try {
internetAddress.setPersonal(internetAddress.getPersonal(), readSmtpCharset(session));
} catch (UnsupportedEncodingException e) {
logger.info("sendEmail: could not encode " + internetAddress + " using " + readSmtpCharset(session));
}
}
msg.setRecipients(javax.mail.Message.RecipientType.TO, recipients);
msg.setSubject(subject, readSmtpCharset(session));
msg.setSentDate(new Date());
msg.setContent(msgText, "text/plain; charset=\""
+ readSmtpCharset(session) + "\"");
Transport.send(msg);
} catch (MessagingException me) {
logger.warn("MessagingException while sending email, caught.", me);
}
}
private String readSmtpCharset(Session session) {
String charset = null == session ? null : session.getProperty("mail.mime.charset");
if (null == charset) {
charset = configurationService.getProperty(
"notification_smtp_charset", DEFAULT_SMTP_CHARSET);
}
return charset;
}
}