VelocityEmail.java
package org.apache.turbine.util.velocity;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.mail2.core.EmailException;
import org.apache.commons.mail2.jakarta.SimpleEmail;
import org.apache.commons.text.WordUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.turbine.Turbine;
import org.apache.turbine.TurbineConstants;
import org.apache.turbine.services.TurbineServices;
import org.apache.turbine.services.velocity.VelocityService;
import org.apache.velocity.context.Context;
/**
* This is a simple class for sending email from within Velocity.
* Essentially, the body of the email is processed with a
* Velocity Context object.
* The beauty of this is that you can send email from within your
* Velocity template or from your business logic in your Java code.
* The body of the email is just a Velocity template so you can use
* all the template functionality of Velocity within your emails!
*
* <p>Example Usage (This all needs to be on one line in your
* template):
*
* <p>Setup your context:
*
* <p><code>context.put ("VelocityEmail", new VelocityEmail() );</code>
*
* <p>Then, in your template:
*
* <pre>
* $VelocityEmail.setTo("Jon Stevens", "jon@latchkey.com")
* .setFrom("Mom", "mom@mom.com").setSubject("Eat dinner")
* .setTemplate("email/momEmail.vm")
* .setContext($context)
* </pre>
*
* The email/momEmail.wm template will then be parsed with the
* Context that was defined with setContext().
*
* <p>If you want to use this class from within your Java code all you
* have to do is something like this:
*
* <pre>
* VelocityEmail ve = new VelocityEmail();
* ve.setTo("Jon Stevens", "jon@latchkey.com");
* ve.setFrom("Mom", "mom@mom.com").setSubject("Eat dinner");
* ve.setContext(context);
* ve.setTemplate("email/momEmail.vm")
* ve.send();
* </pre>
*
* <p>(Note that when used within a Velocity template, the send method
* will be called for you when Velocity tries to convert the
* VelocityEmail to a string by calling toString()).</p>
*
* <p>If you need your email to be word-wrapped, you can add the
* following call to those above:
*
* <pre>
* ve.setWordWrap (60);
* </pre>
*
* <p>This class is just a wrapper around the SimpleEmail class from
* commons-mail using the JavaMail API.
* Thus, it depends on having the
* mail.server property set in the TurbineResources.properties file.
* If you want to use this class outside of Turbine for general
* processing that is also possible by making sure to set the path to
* the TurbineResources.properties. See the
* TurbineConfig class for more information.</p>
*
* <p>You can turn on debugging for the JavaMail API by calling
* setDebug(true). The debugging messages will be written to System.out.
*
* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
* @author <a href="mailto:gcoladonato@yahoo.com">Greg Coladonato</a>
* @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
* @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
* @version $Id$
*/
public class VelocityEmail extends SimpleEmail
{
/** Logging */
private static final Logger log = LogManager.getLogger(VelocityEmail.class);
/** The column to word-wrap at. <code>0</code> indicates no wrap. */
private int wordWrap = 0;
/** Address of outgoing mail server */
private String mailServer;
/** The template to process, relative to Velocity template directory. */
private String template = null;
/** Velocity context */
private Context context = null;
/**
* Constructor
*/
public VelocityEmail()
{
super();
}
/**
* Constructor
* @param context the velocity context to use
*/
public VelocityEmail(Context context)
{
this();
this.context = context;
}
/**
* To: toName, toEmail
*
* @param toName A String with the TO toName.
* @param toEmail A String with the TO toEmail.
* @deprecated use addTo(email,name) instead
* @throws EmailException email address could not be parsed
* @return A VelocityEmail (self).
*/
@Deprecated
public VelocityEmail setTo(String toName, String toEmail)
throws EmailException
{
addTo(toEmail,toName);
return this;
}
/**
* Velocity template to execute. Path is relative to the Velocity
* templates directory.
*
* @param template relative path of the template to parse including the
* filename.
* @return A VelocityEmail (self).
*/
public VelocityEmail setTemplate(String template)
{
this.template = template;
return this;
}
/**
* Set the column at which long lines of text should be word-
* wrapped. Setting to zero turns off word-wrap (default).
*
* NOTE: don't use tabs in your email template document,
* or your word-wrapping will be off for the lines with tabs
* in them.
*
* @param wordWrap The column at which to wrap long lines.
* @return A VelocityEmail (self).
*/
public VelocityEmail setWordWrap(int wordWrap)
{
this.wordWrap = wordWrap;
return this;
}
/**
* Set the context object that will be merged with the
* template.
*
* @param context A Velocity context object.
* @return A VelocityEmail (self).
*/
public VelocityEmail setContext(Context context)
{
this.context = context;
return this;
}
/**
* Get the context object that will be merged with the
* template.
*
* @return A Context (self).
*/
public Context getContext()
{
return this.context;
}
/**
* Sets the address of the outgoing mail server. This method
* should be used when you need to override the value stored in
* TR.props.
*
* @param serverAddress host name of your outgoing mail server
*/
public void setMailServer(String serverAddress)
{
this.mailServer = serverAddress;
}
/**
* Gets the host name of the outgoing mail server. If the server
* name has not been set by calling setMailServer(), the value
* from TR.props for mail.server will be returned. If TR.props
* has no value for mail.server, localhost will be returned.
*
* @return host name of the mail server.
*/
public String getMailServer()
{
return StringUtils.isNotEmpty(mailServer) ? mailServer
: Turbine.getConfiguration().getString(
TurbineConstants.MAIL_SERVER_KEY,
TurbineConstants.MAIL_SERVER_DEFAULT);
}
/**
* This method sends the email.
* <p>If the mail server was not set by calling, setMailServer()
* the value of mail.server will be used from TR.props. If that
* value was not set, localhost is used.
*
* @throws EmailException Failure during merging the velocity
* template or sending the email.
*/
@Override
public String send() throws EmailException
{
String body = null;
try
{
// Process the template.
VelocityService velocityService = (VelocityService)TurbineServices.getInstance().getService(VelocityService.SERVICE_NAME);
body = velocityService.handleRequest(context, template);
}
catch (Exception e)
{
throw new EmailException(
"Could not render velocity template", e);
}
// If the caller desires word-wrapping, do it here
if (wordWrap > 0)
{
body = WordUtils.wrap(body, wordWrap,
System.getProperty("line.separator"), false);
}
setMsg(body);
setHostName(getMailServer());
return super.send();
}
/**
* The method toString() calls send() for ease of use within a
* Velocity template (see example usage above).
*
* @return An empty string.
*/
@Override
public String toString()
{
try
{
send();
}
catch (EmailException e)
{
log.error("VelocityEmail error", e);
}
return "";
}
}