[jbossseam-issues] [JBoss JIRA] Created: (JBSEAM-3285) Seam Email session integration into jBPM

[Boretti Mathieu (JIRA)]

Seam Email session integration into jBPM
----------------------------------------

                 Key: JBSEAM-3285
                 URL: https://jira.jboss.org/jira/browse/JBSEAM-3285
             Project: Seam
          Issue Type: Feature Request
          Components: BPM
    Affects Versions: 2.0.2.GA
         Environment: N/A
            Reporter: Boretti Mathieu


The goal is to use the MailSession from seam (provided by DataSource or not), when using jBPM task-node. 

The idea is to provide a class that extend org.jbpm.mail.Mail and use the MailSession from Seam, instance of the MailSession from jBPM.

It is then possible to reference this class in the jbpm config file (<string name='jbpm.mail.class.name' value='XXXX' />

I wrote a small "example class", by copy-paste from jBPM (see below):

This implementation use the jBPM variable config jbpm.mail.ignoreError to throw, or not, an error in case of error in sending of email.
The MailSession is retrieved with 
org.jboss.seam.mail.MailSession.instance();

package org.domain.HardWareStore.actions;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.StringTokenizer;

import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jboss.seam.contexts.Context;
import org.jboss.seam.contexts.Lifecycle;
import org.jboss.seam.mail.MailSession;
import org.jbpm.JbpmConfiguration;
import org.jbpm.JbpmException;
import org.jbpm.graph.exe.ExecutionContext;
import org.jbpm.jpdl.el.ELException;
import org.jbpm.jpdl.el.VariableResolver;
import org.jbpm.jpdl.el.impl.JbpmExpressionEvaluator;
import org.jbpm.mail.AddressResolver;
import org.jbpm.mail.Mail;
import org.jbpm.util.XmlUtil;

public class MailHandler extends Mail {

	private static final long serialVersionUID = 1L;

	String template = null;
	String actors = null;
	String to = null;
	String bcc = null;
	String bccActors = null;
	String subject = null;
	String text = null;

	ExecutionContext executionContext = null;

	public MailHandler() {
	}

	public MailHandler(String template, String actors, String to,
			String subject, String text) {
		this.template = template;
		this.actors = actors;
		this.to = to;
		this.subject = subject;
		this.text = text;
	}

	public MailHandler(String template, String actors, String to,
			String bccActors, String bcc, String subject, String text) {
		this.template = template;
		this.actors = actors;
		this.to = to;
		this.bccActors = bccActors;
		this.bcc = bcc;
		this.subject = subject;
		this.text = text;
	}

	public void execute(ExecutionContext executionContext) {
		this.executionContext = executionContext;
		send();
	}

	public List getRecipients() {
		List recipients = new ArrayList();
		if (actors != null) {
			String evaluatedActors = evaluate(actors);
			List tokenizedActors = tokenize(evaluatedActors);
			if (tokenizedActors != null) {
				recipients.addAll(resolveAddresses(tokenizedActors));
			}
		}
		if (to != null) {
			String resolvedTo = evaluate(to);
			recipients.addAll(tokenize(resolvedTo));
		}
		return recipients;
	}

	public List getBccRecipients() {
		List recipients = new ArrayList();
		if (bccActors != null) {
			String evaluatedActors = evaluate(bccActors);
			List tokenizedActors = tokenize(evaluatedActors);
			if (tokenizedActors != null) {
				recipients.addAll(resolveAddresses(tokenizedActors));
			}
		}
		if (bcc != null) {
			String resolvedTo = evaluate(to);
			recipients.addAll(tokenize(resolvedTo));
		}
		if (JbpmConfiguration.Configs.hasObject("jbpm.mail.bcc.address")) {
			recipients.addAll(tokenize(JbpmConfiguration.Configs
					.getString("jbpm.mail.bcc.address")));
		}
		return recipients;
	}

	public String getSubject() {
		if (subject == null)
			return null;
		return evaluate(subject);
	}

	public String getText() {
		if (text == null)
			return null;
		return evaluate(text);
	}

	public String getFromAddress() {
		if (JbpmConfiguration.Configs.hasObject("jbpm.mail.from.address")) {
			return JbpmConfiguration.Configs
					.getString("jbpm.mail.from.address");
		}
		return "jbpm at noreply";
	}

	public void send() {
		if (template != null) {
			Properties properties = getMailTemplateProperties(template);
			if (actors == null) {
				actors = properties.getProperty("actors");
			}
			if (to == null) {
				to = properties.getProperty("to");
			}
			if (subject == null) {
				subject = properties.getProperty("subject");
			}
			if (text == null) {
				text = properties.getProperty("text");
			}
			if (bcc == null) {
				bcc = properties.getProperty("bcc");
			}
			if (bccActors == null) {
				bccActors = properties.getProperty("bccActors");
			}
		}

		send(getFromAddress(), getRecipients(), getBccRecipients(),
				getSubject(), getText());
	}

	public static void send(String fromAddress, List recipients,
			String subject, String text) {
		send(fromAddress, recipients, null, subject, text);
	}

	public static void send(String fromAddress, List recipients,
			List bccRecipients, String subject, String text) {
		if ((recipients == null) || (recipients.isEmpty())) {
			log.info("skipping mail because there are no recipients");
			return;
		}
		log.info("sending email to '" + recipients + "' about '" + subject
				+ "'");
		log.info("BeginCall");
		Context context = Lifecycle.beginMethod();
		try {
			log.info("GetSession");
			Session session = MailSession.instance();
			log.info("Create msg for "+session);
			MimeMessage message = new MimeMessage(session);
			if (fromAddress != null) {
				message.setFrom(new InternetAddress(fromAddress));
			}
			Iterator iter = recipients.iterator();
			while (iter.hasNext()) {
				InternetAddress recipient = new InternetAddress((String) iter
						.next());
				message.addRecipient(Message.RecipientType.TO, recipient);
			}
			if (bccRecipients != null) {
				iter = bccRecipients.iterator();
				while (iter.hasNext()) {
					InternetAddress recipient = new InternetAddress(
							(String) iter.next());
					message.addRecipient(Message.RecipientType.BCC, recipient);
				}
			}
			if (subject != null) {
				message.setSubject(subject);
			}
			if (text != null) {
				message.setText(text);
			}
			message.setSentDate(new Date());

			Transport.send(message);
		} catch (Exception e) {
			log.error("couldn't send email",e);
			boolean ignore=false;
			if (JbpmConfiguration.Configs.hasObject("jbpm.mail.ignoreError")) {
				ignore=JbpmConfiguration.Configs.getBoolean("jbpm.mail.ignoreError");
			}
			if (!ignore) throw new JbpmException("couldn't send email", e);
		} finally {
			Lifecycle.endMethod(context);
		}
	}

	protected List tokenize(String text) {
		if (text == null) {
			return null;
		}
		List list = new ArrayList();
		StringTokenizer tokenizer = new StringTokenizer(text, ";:");
		while (tokenizer.hasMoreTokens()) {
			list.add(tokenizer.nextToken());
		}
		return list;
	}

	protected Collection resolveAddresses(List actorIds) {
		List emailAddresses = new ArrayList();
		Iterator iter = actorIds.iterator();
		while (iter.hasNext()) {
			String actorId = (String) iter.next();
			AddressResolver addressResolver = (AddressResolver) JbpmConfiguration.Configs
					.getObject("jbpm.mail.address.resolver");
			Object resolvedAddresses = addressResolver.resolveAddress(actorId);
			if (resolvedAddresses != null) {
				if (resolvedAddresses instanceof String) {
					emailAddresses.add((String) resolvedAddresses);
				} else if (resolvedAddresses instanceof Collection) {
					emailAddresses.addAll((Collection) resolvedAddresses);
				} else if (resolvedAddresses instanceof String[]) {
					emailAddresses.addAll(Arrays
							.asList((String[]) resolvedAddresses));
				} else {
					throw new JbpmException(
							"Address resolver '"
									+ addressResolver
									+ "' returned '"
									+ resolvedAddresses.getClass().getName()
									+ "' instead of a String, Collection or String-array: "
									+ resolvedAddresses);
				}
			}
		}
		return emailAddresses;
	}

	static Map templates = null;
	static Map templateVariables = null;

	synchronized Properties getMailTemplateProperties(String templateName) {
		if (templates == null) {
			templates = new HashMap();
			String mailTemplatesResource = JbpmConfiguration.Configs
					.getString("resource.mail.templates");
			org.w3c.dom.Element mailTemplatesElement = XmlUtil
					.parseXmlResource(mailTemplatesResource)
					.getDocumentElement();
			List mailTemplateElements = XmlUtil.elements(mailTemplatesElement,
					"mail-template");
			Iterator iter = mailTemplateElements.iterator();
			while (iter.hasNext()) {
				org.w3c.dom.Element mailTemplateElement = (org.w3c.dom.Element) iter
						.next();

				Properties templateProperties = new Properties();
				addTemplateProperty(mailTemplateElement, "actors",
						templateProperties);
				addTemplateProperty(mailTemplateElement, "to",
						templateProperties);
				addTemplateProperty(mailTemplateElement, "subject",
						templateProperties);
				addTemplateProperty(mailTemplateElement, "text",
						templateProperties);
				addTemplateProperty(mailTemplateElement, "bcc",
						templateProperties);
				addTemplateProperty(mailTemplateElement, "bccActors",
						templateProperties);

				templates.put(mailTemplateElement.getAttribute("name"),
						templateProperties);
			}

			templateVariables = new HashMap();
			List variableElements = XmlUtil.elements(mailTemplatesElement,
					"variable");
			iter = variableElements.iterator();
			while (iter.hasNext()) {
				org.w3c.dom.Element variableElement = (org.w3c.dom.Element) iter
						.next();
				templateVariables.put(variableElement.getAttribute("name"),
						variableElement.getAttribute("value"));
			}
		}
		return (Properties) templates.get(templateName);
	}

	void addTemplateProperty(org.w3c.dom.Element mailTemplateElement,
			String property, Properties templateProperties) {
		org.w3c.dom.Element element = XmlUtil.element(mailTemplateElement,
				property);
		if (element != null) {
			templateProperties.put(property, XmlUtil.getContentText(element));
		}
	}

	String evaluate(String expression) {
		if (expression == null) {
			return null;
		}
		VariableResolver variableResolver = JbpmExpressionEvaluator
				.getUsedVariableResolver();
		if (variableResolver != null) {
			variableResolver = new MailVariableResolver(templateVariables,
					variableResolver);
		}
		return (String) JbpmExpressionEvaluator.evaluate(expression,
				executionContext, variableResolver, null);
	}

	class MailVariableResolver implements VariableResolver, Serializable {
		private static final long serialVersionUID = 1L;
		Map templateVariables = null;
		VariableResolver variableResolver = null;

		public MailVariableResolver(Map templateVariables,
				VariableResolver variableResolver) {
			this.templateVariables = templateVariables;
			this.variableResolver = variableResolver;
		}

		public Object resolveVariable(String pName) throws ELException {
			if ((templateVariables != null)
					&& (templateVariables.containsKey(pName))) {
				return templateVariables.get(pName);
			}
			return variableResolver.resolveVariable(pName);
		}
	}

	private static Log log = LogFactory.getLog(Mail.class);
}


-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators: https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira