/*
|
* JBoss, Home of Professional Open Source
|
* Copyright 2005, JBoss Inc., and individual contributors as indicated
|
* by the @authors tag. See the copyright.txt in the distribution for a
|
* full listing of individual contributors.
|
*
|
* This is free software; you can redistribute it and/or modify it
|
* under the terms of the GNU Lesser General Public License as
|
* published by the Free Software Foundation; either version 2.1 of
|
* the License, or (at your option) any later version.
|
*
|
* This software 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
|
* Lesser General Public License for more details.
|
*
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this software; if not, write to the Free
|
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
|
*/
|
package org.jbpm.pvm.internal.email.impl;
|
|
import java.io.File;
|
import java.io.Serializable;
|
import java.net.MalformedURLException;
|
import java.net.URL;
|
import java.util.Arrays;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.List;
|
|
import javax.activation.DataHandler;
|
import javax.activation.FileDataSource;
|
import javax.mail.Address;
|
import javax.mail.BodyPart;
|
import javax.mail.Message;
|
import javax.mail.MessagingException;
|
import javax.mail.Multipart;
|
import javax.mail.Session;
|
import javax.mail.Message.RecipientType;
|
import javax.mail.internet.InternetAddress;
|
import javax.mail.internet.MimeBodyPart;
|
import javax.mail.internet.MimeMessage;
|
import javax.mail.internet.MimeMultipart;
|
|
import org.jbpm.api.Execution;
|
import org.jbpm.api.JbpmException;
|
import org.jbpm.api.identity.Group;
|
import org.jbpm.api.identity.User;
|
import org.jbpm.pvm.internal.email.spi.AddressResolver;
|
import org.jbpm.pvm.internal.email.spi.MailProducer;
|
import org.jbpm.pvm.internal.env.EnvironmentImpl;
|
import org.jbpm.pvm.internal.identity.spi.IdentitySession;
|
import org.jbpm.pvm.internal.script.ScriptManager;
|
|
/**
|
* Default mail producer.
|
*
|
* @author Alejandro Guizar
|
*/
|
public class MailProducerImpl implements MailProducer, Serializable {
|
|
private static final long serialVersionUID = 1L;
|
|
private MailTemplate template;
|
|
public MailTemplate getTemplate() {
|
return template;
|
}
|
|
public void setTemplate(MailTemplate template) {
|
this.template = template;
|
}
|
|
public Collection<Message> produce(Execution execution) {
|
Message email = instantiateEmail();
|
fillFrom(execution, email);
|
fillRecipients(execution, email);
|
fillSubject(execution, email);
|
fillContent(execution, email);
|
return Collections.singleton(email);
|
}
|
|
protected Message instantiateEmail() {
|
return new MimeMessage((Session) null);
|
}
|
|
/**
|
* Fills the <code>from</code> attribute of the given email. The sender addresses are an optional
|
* element in the mail template. If absent, each mail server supplies the current user's email
|
* address.
|
*
|
* @see {@link InternetAddress#getLocalAddress(Session)}
|
*/
|
protected void fillFrom(Execution execution, Message email) {
|
AddressTemplate fromTemplate = template.getFrom();
|
// "from" attribute is optional
|
if (fromTemplate == null) return;
|
|
// resolve and parse addresses
|
String addresses = fromTemplate.getAddresses();
|
if (addresses != null) {
|
addresses = evaluateExpression(addresses, execution);
|
try {
|
email.addFrom(InternetAddress.parse(addresses));
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add " + addresses + " to senders", e);
|
}
|
}
|
|
EnvironmentImpl environment = EnvironmentImpl.getCurrent();
|
IdentitySession identitySession = environment.get(IdentitySession.class);
|
AddressResolver addressResolver = environment.get(AddressResolver.class);
|
|
// resolve and tokenize users
|
String userList = fromTemplate.getUsers();
|
if (userList != null) {
|
String[] userIds = tokenizeActors(userList, execution);
|
List<User> users = identitySession.findUsersById(userIds);
|
addSenders(resolveAddresses(users, addressResolver), email);
|
}
|
|
// resolve and tokenize groups
|
String groupList = fromTemplate.getGroups();
|
if (groupList != null) {
|
for (String groupId : tokenizeActors(groupList, execution)) {
|
Group group = identitySession.findGroupById(groupId);
|
addSenders(addressResolver.resolveAddresses(group), email);
|
}
|
}
|
}
|
|
private String evaluateExpression(String expression, Execution execution) {
|
ScriptManager scriptManager = EnvironmentImpl.getFromCurrent(ScriptManager.class);
|
Object value = scriptManager.evaluateExpression(expression, template.getLanguage());
|
if (!(value instanceof String)) {
|
throw new JbpmException("expected expression '"
|
+ expression
|
+ "' to return string, but was: "
|
+ value);
|
}
|
return (String) value;
|
}
|
|
private String[] tokenizeActors(String recipients, Execution execution) {
|
String[] actors = evaluateExpression(recipients, execution).split("[,;|\\s]+");
|
if (actors.length == 0) throw new JbpmException("recipient list is empty: " + recipients);
|
return actors;
|
}
|
|
/** construct recipient addresses from user entities */
|
private Address[] resolveAddresses(List<User> users, AddressResolver addressResolver) {
|
int userCount = users.size();
|
Address[] addresses = new Address[userCount];
|
for (int i = 0; i < userCount; i++) {
|
addresses[i] = addressResolver.resolveAddress(users.get(i));
|
}
|
return addresses;
|
}
|
|
/** add senders to message */
|
private void addSenders(Address[] addresses, Message email) {
|
try {
|
email.addFrom(addresses);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add " + Arrays.toString(addresses) + " to senders", e);
|
}
|
}
|
|
protected void fillRecipients(Execution execution, Message email) {
|
// to
|
AddressTemplate to = template.getTo();
|
if (to != null) fillRecipients(to, execution, email, RecipientType.TO);
|
|
// cc
|
AddressTemplate cc = template.getCc();
|
if (cc != null) fillRecipients(cc, execution, email, RecipientType.CC);
|
|
// bcc
|
AddressTemplate bcc = template.getBcc();
|
if (bcc != null) fillRecipients(bcc, execution, email, RecipientType.BCC);
|
}
|
|
private void fillRecipients(AddressTemplate addressTemplate, Execution execution, Message email,
|
RecipientType recipientType) {
|
// resolve and parse addresses
|
String addresses = addressTemplate.getAddresses();
|
if (addresses != null) {
|
addresses = evaluateExpression(addresses, execution);
|
try {
|
email.addRecipients(recipientType, InternetAddress.parse(addresses));
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add "
|
+ addresses
|
+ " to recipients of type "
|
+ recipientType, e);
|
}
|
}
|
|
EnvironmentImpl environment = EnvironmentImpl.getCurrent();
|
IdentitySession identitySession = environment.get(IdentitySession.class);
|
AddressResolver addressResolver = environment.get(AddressResolver.class);
|
|
// resolve and tokenize users
|
String userList = addressTemplate.getUsers();
|
if (userList != null) {
|
String[] userIds = tokenizeActors(userList, execution);
|
List<User> users = identitySession.findUsersById(userIds);
|
addRecipients(resolveAddresses(users, addressResolver), email, recipientType);
|
}
|
|
// resolve and tokenize groups
|
String groupList = addressTemplate.getGroups();
|
if (groupList != null) {
|
for (String groupId : tokenizeActors(groupList, execution)) {
|
Group group = identitySession.findGroupById(groupId);
|
addRecipients(addressResolver.resolveAddresses(group), email, recipientType);
|
}
|
}
|
}
|
|
/** add recipient addresses to message */
|
private void addRecipients(Address[] addresses, Message email, RecipientType recipientType) {
|
try {
|
email.addRecipients(recipientType, addresses);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add "
|
+ Arrays.toString(addresses)
|
+ " to recipients of type "
|
+ recipientType, e);
|
}
|
}
|
|
protected void fillSubject(Execution execution, Message email) {
|
String subject = template.getSubject();
|
if (subject != null) {
|
subject = evaluateExpression(subject, execution);
|
try {
|
email.setSubject(subject);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to set subject to " + subject, e);
|
}
|
}
|
}
|
|
protected void fillContent(Execution execution, Message email) {
|
String text = template.getText();
|
String html = template.getHtml();
|
List<AttachmentTemplate> attachmentTemplates = template.getAttachmentTemplates();
|
|
if (html != null || !attachmentTemplates.isEmpty()) {
|
// multipart
|
Multipart multipart = new MimeMultipart("related");
|
|
// text
|
if (text != null) {
|
BodyPart textPart = new MimeBodyPart();
|
text = evaluateExpression(text, execution);
|
try {
|
textPart.setText(text);
|
multipart.addBodyPart(textPart);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add text content: " + text, e);
|
}
|
}
|
|
// html
|
if (html != null) {
|
BodyPart htmlPart = new MimeBodyPart();
|
html = evaluateExpression(html, execution);
|
try {
|
htmlPart.setContent(html, "text/html");
|
multipart.addBodyPart(htmlPart);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add html content: " + html, e);
|
}
|
}
|
|
// attachments
|
if (!attachmentTemplates.isEmpty()) {
|
addAttachments(execution, multipart);
|
}
|
|
try {
|
email.setContent(multipart);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to set multipart content: " + multipart, e);
|
}
|
}
|
else if (text != null) {
|
// unipart
|
text = evaluateExpression(text, execution);
|
try {
|
email.setText(text);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add text content: " + text, e);
|
}
|
}
|
}
|
|
protected void addAttachments(Execution execution, Multipart multipart) {
|
for (AttachmentTemplate attachmentTemplate : template.getAttachmentTemplates()) {
|
BodyPart attachmentPart = new MimeBodyPart();
|
|
// resolve and set description
|
String description = attachmentTemplate.getDescription();
|
if (description != null) {
|
description = evaluateExpression(description, execution);
|
try {
|
attachmentPart.setDescription(description);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to set attachment description: " + description, e);
|
}
|
}
|
|
// resolve name; if absent, it will be taken from file or url
|
String name = attachmentTemplate.getName();
|
if (name != null) {
|
name = evaluateExpression(name, execution);
|
}
|
|
// resolve and read file
|
String file = attachmentTemplate.getFile();
|
if (file != null) {
|
File targetFile = new File(evaluateExpression(file, execution));
|
if (!targetFile.isFile()) {
|
throw new JbpmException("could not read attachment content, file not found: "
|
+ targetFile);
|
}
|
// set content from target file
|
try {
|
attachmentPart.setDataHandler(new DataHandler(new FileDataSource(targetFile)));
|
// extract attachment name from file
|
if (name == null) {
|
name = targetFile.getName();
|
}
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add attachment content: " + targetFile, e);
|
}
|
}
|
else {
|
URL targetUrl;
|
// resolve and read external url
|
String url = attachmentTemplate.getUrl();
|
if (url != null) {
|
try {
|
url = evaluateExpression(url, execution);
|
targetUrl = new URL(url);
|
}
|
catch (MalformedURLException e) {
|
throw new JbpmException("could not read attachment content, malformed url: " + url, e);
|
}
|
}
|
// resolve and read classpath resource
|
else {
|
String resource = evaluateExpression(attachmentTemplate.getResource(), execution);
|
targetUrl = EnvironmentImpl.getCurrent().getClassLoader().getResource(resource);
|
if (targetUrl == null) {
|
throw new JbpmException("could not read attachment content, resource not found: "
|
+ resource);
|
}
|
}
|
// set content from url
|
try {
|
attachmentPart.setDataHandler(new DataHandler(targetUrl));
|
// extract attachment name from target url
|
if (name == null) {
|
name = extractResourceName(targetUrl);
|
}
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add attachment content: " + targetUrl, e);
|
}
|
}
|
|
// set name, must be resolved at this point
|
try {
|
attachmentPart.setFileName(name);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to set attachment name: " + name, e);
|
}
|
|
try {
|
multipart.addBodyPart(attachmentPart);
|
}
|
catch (MessagingException e) {
|
throw new JbpmException("failed to add attachment part: " + attachmentPart, e);
|
}
|
}
|
}
|
|
private static String extractResourceName(URL url) {
|
String path = url.getPath();
|
if (path == null || path.length() == 0) return null;
|
|
int sepIndex = path.lastIndexOf('/');
|
return sepIndex != -1 ? path.substring(sepIndex) : null;
|
}
|
}
|
