/*
|
* 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.jpdl.internal.xml;
|
|
import java.net.URL;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.Enumeration;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.StringTokenizer;
|
|
import org.jbpm.api.JbpmException;
|
import org.jbpm.api.activity.ActivityBehaviour;
|
import org.jbpm.api.listener.EventListener;
|
import org.jbpm.api.model.Event;
|
import org.jbpm.internal.log.Log;
|
import org.jbpm.jpdl.internal.activity.JpdlBinding;
|
import org.jbpm.jpdl.internal.activity.MailListener;
|
import org.jbpm.jpdl.internal.model.JpdlProcessDefinition;
|
import org.jbpm.pvm.internal.email.impl.MailProducerImpl;
|
import org.jbpm.pvm.internal.email.impl.MailTemplate;
|
import org.jbpm.pvm.internal.email.impl.MailTemplateRegistry;
|
import org.jbpm.pvm.internal.email.spi.MailProducer;
|
import org.jbpm.pvm.internal.env.EnvironmentImpl;
|
import org.jbpm.pvm.internal.model.ActivityCoordinatesImpl;
|
import org.jbpm.pvm.internal.model.ActivityImpl;
|
import org.jbpm.pvm.internal.model.CompositeElementImpl;
|
import org.jbpm.pvm.internal.model.Continuation;
|
import org.jbpm.pvm.internal.model.EventImpl;
|
import org.jbpm.pvm.internal.model.EventListenerReference;
|
import org.jbpm.pvm.internal.model.ObservableElementImpl;
|
import org.jbpm.pvm.internal.model.ProcessDefinitionImpl;
|
import org.jbpm.pvm.internal.model.ScopeElementImpl;
|
import org.jbpm.pvm.internal.model.TimerDefinitionImpl;
|
import org.jbpm.pvm.internal.model.TransitionImpl;
|
import org.jbpm.pvm.internal.model.VariableDefinitionImpl;
|
import org.jbpm.pvm.internal.model.VariableOutDefinitionImpl;
|
import org.jbpm.pvm.internal.model.VariableOutDefinitionSet;
|
import org.jbpm.pvm.internal.repository.DeploymentImpl;
|
import org.jbpm.pvm.internal.task.AssignableDefinitionImpl;
|
import org.jbpm.pvm.internal.task.SwimlaneDefinitionImpl;
|
import org.jbpm.pvm.internal.task.TaskDefinitionImpl;
|
import org.jbpm.pvm.internal.util.XmlUtil;
|
import org.jbpm.pvm.internal.wire.Descriptor;
|
import org.jbpm.pvm.internal.wire.WireContext;
|
import org.jbpm.pvm.internal.wire.binding.MailTemplateBinding;
|
import org.jbpm.pvm.internal.wire.binding.ObjectBinding;
|
import org.jbpm.pvm.internal.wire.descriptor.ObjectDescriptor;
|
import org.jbpm.pvm.internal.wire.usercode.UserCodeReference;
|
import org.jbpm.pvm.internal.wire.xml.WireParser;
|
import org.jbpm.pvm.internal.xml.Bindings;
|
import org.jbpm.pvm.internal.xml.Parse;
|
import org.jbpm.pvm.internal.xml.Parser;
|
import org.jbpm.pvm.internal.xml.ProblemImpl;
|
import org.w3c.dom.Element;
|
|
/**
|
* @author Tom Baeyens
|
*/
|
public class JpdlParser extends Parser {
|
|
private static final Log log = Log.getLog(JpdlParser.class.getName());
|
|
public static final String NAMESPACE_JPDL_40 = "http://jbpm.org/4.0/jpdl";
|
public static final String NAMESPACE_JPDL_42 = "http://jbpm.org/4.2/jpdl";
|
public static final String NAMESPACE_JPDL_43 = "http://jbpm.org/4.3/jpdl";
|
|
public static final String CURRENT_VERSION_JBPM = "4.3";
|
public static final String CURRENT_VERSION_NAMESPACE = "http://jbpm.org/"+CURRENT_VERSION_JBPM+"/jpdl";
|
public static final String CURRENT_VERSION_PROCESS_LANGUAGE_ID = "jpdl-"+CURRENT_VERSION_JBPM;
|
|
public static final List<String> SCHEMA_RESOURCES = new ArrayList<String>();
|
static {
|
SCHEMA_RESOURCES.add("jpdl-4.0.xsd");
|
SCHEMA_RESOURCES.add("jpdl-4.2.xsd");
|
SCHEMA_RESOURCES.add("jpdl-4.3.xsd");
|
}
|
|
public static final WireParser wireParser = WireParser.getInstance();
|
public static final ObjectBinding objectBinding = ObjectBinding.INSTANCE;
|
|
// array elements are mutable, even when final
|
// never make a static array public
|
static final String[] DEFAULT_BINDING_RESOURCES = {
|
"jbpm.jpdl.bindings.xml",
|
"jbpm.user.bindings.xml"
|
};
|
|
static JpdlBindingsParser jpdlBindingsParser = new JpdlBindingsParser();
|
|
public static final String CATEGORY_ACTIVITY = "activity";
|
public static final String CATEGORY_EVENT_LISTENER = "eventlistener";
|
|
public JpdlParser() {
|
initialize();
|
parseBindings();
|
setSchemaResources(SCHEMA_RESOURCES);
|
}
|
|
protected void parseBindings() {
|
this.bindings = new Bindings();
|
|
for (String activityResource: DEFAULT_BINDING_RESOURCES) {
|
Enumeration<URL> resourceUrls = getResources(activityResource);
|
if (resourceUrls.hasMoreElements()) {
|
while (resourceUrls.hasMoreElements()) {
|
URL resourceUrl = resourceUrls.nextElement();
|
log.trace("loading jpdl bindings from resource: "+resourceUrl);
|
jpdlBindingsParser.createParse()
|
.setUrl(resourceUrl)
|
.contextMapPut(Parse.CONTEXT_KEY_BINDINGS, bindings)
|
.execute()
|
.checkErrors("jpdl bindings from "+resourceUrl.toString());
|
}
|
} else {
|
log.trace("skipping unavailable jpdl activities resource: "+activityResource);
|
}
|
}
|
}
|
|
protected Enumeration<URL> getResources(String resourceName) {
|
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
|
Enumeration<URL> resourceUrls;
|
try {
|
resourceUrls = classLoader.getResources(resourceName);
|
} catch (Exception e) {
|
throw new JbpmException("couldn't get resource urls for "+resourceName, e);
|
}
|
return resourceUrls;
|
}
|
|
public Object parseDocumentElement(Element documentElement, Parse parse) {
|
List<ProcessDefinitionImpl> processDefinitions = new ArrayList<ProcessDefinitionImpl>();
|
|
JpdlProcessDefinition processDefinition = instantiateNewJpdlProcessDefinition();
|
|
processDefinitions.add(processDefinition);
|
|
parse.contextStackPush(processDefinition);
|
try {
|
// process attribues
|
String name = XmlUtil.attribute(documentElement, "name", true, parse);
|
processDefinition.setName(name);
|
|
// make the process language version available for bindings
|
// to allow for specific parsing behaviour per version
|
|
// first check if the langid is available as a deployment property
|
DeploymentImpl deployment = (DeploymentImpl) parse.contextMapGet(Parse.CONTEXT_KEY_DEPLOYMENT);
|
if (deployment!=null) {
|
String processLanguageId = deployment.getProcessLanguageId(name);
|
if (processLanguageId==null) {
|
// if it is not available as a deployment property, check if the
|
// jpdlparser attribute specifies a specific jpdl version.
|
// this is the case for certain compatibility tests in our test suite
|
String jpdlParser = XmlUtil.attribute(documentElement, "jpdlparser");
|
if (jpdlParser!=null) {
|
processLanguageId = "jpdl-"+jpdlParser;
|
|
} else {
|
// if none of the above, check if this is a parser test run for a specific verion
|
// specify the jpdltestversion with "mvn -Djpdlparser=jpdl-4.3 clean install"
|
// that way, the whole test suite will be use the specified parser
|
jpdlParser = System.getProperty("jpdlparser");
|
if (jpdlParser!=null) {
|
processLanguageId = "jpdl-"+jpdlParser;
|
|
} else {
|
// if this process has a namespace, then use the namespace
|
// to see what jpdl parser version should be used
|
String namespaceUri = documentElement.getNamespaceURI();
|
if (namespaceUri!=null) {
|
processLanguageId = "jpdl-"+namespaceUri.substring(16, 19);
|
|
} else {
|
// if none of the above, just deploy it as the current library version
|
processLanguageId = CURRENT_VERSION_PROCESS_LANGUAGE_ID;
|
}
|
}
|
}
|
// saving the process language will make sure that
|
// the right parser version is used after an upgrade of jbpm
|
// as the old format xml will still be in the db
|
deployment.setProcessLanguageId(name, processLanguageId);
|
}
|
parse.contextMapPut(Parse.CONTEXT_KEY_PROCESS_LANGUAGE_ID, processLanguageId);
|
}
|
|
String packageName = XmlUtil.attribute(documentElement, "package");
|
processDefinition.setPackageName(packageName);
|
|
Integer version = XmlUtil.attributeInteger(documentElement, "version", false, parse);
|
if (version!=null) {
|
processDefinition.setVersion(version);
|
}
|
|
String key = XmlUtil.attribute(documentElement, "key", false, parse);
|
if (key!=null) {
|
processDefinition.setKey(key);
|
}
|
|
Element descriptionElement = XmlUtil.element(documentElement, "description");
|
if (descriptionElement!=null) {
|
String description = XmlUtil.getContentText(descriptionElement);
|
processDefinition.setDescription(description);
|
}
|
|
UnresolvedTransitions unresolvedTransitions = new UnresolvedTransitions();
|
parse.contextStackPush(unresolvedTransitions);
|
|
// swimlanes
|
List<Element> swimlaneElements = XmlUtil.elements(documentElement, "swimlane");
|
for (Element swimlaneElement: swimlaneElements) {
|
String swimlaneName = XmlUtil.attribute(swimlaneElement, "name", true, parse);
|
if (swimlaneName!=null) {
|
SwimlaneDefinitionImpl swimlaneDefinition =
|
processDefinition.createSwimlaneDefinition(swimlaneName);
|
parseAssignmentAttributes(swimlaneElement, swimlaneDefinition, parse);
|
}
|
}
|
|
// on events
|
parseOnEvents(documentElement, parse, processDefinition);
|
|
// activities
|
parseActivities(documentElement, parse, processDefinition);
|
|
// bind activities to their destinations
|
resolveTransitionDestinations(parse, processDefinition, unresolvedTransitions);
|
|
// process migration information
|
Element migrationElement = XmlUtil.element(documentElement, "migrate-instances");
|
if (migrationElement != null) {
|
MigrationHelper.parseMigrationDescriptor(migrationElement, parse, processDefinition);
|
}
|
|
} finally {
|
parse.contextStackPop();
|
}
|
|
if (processDefinition.getInitial()==null) {
|
parse.addProblem("no start activity in process", documentElement);
|
}
|
|
return processDefinitions;
|
}
|
|
protected JpdlProcessDefinition instantiateNewJpdlProcessDefinition() {
|
return new JpdlProcessDefinition();
|
}
|
|
protected void resolveTransitionDestinations(Parse parse, JpdlProcessDefinition processDefinition, UnresolvedTransitions unresolvedTransitions) {
|
for (UnresolvedTransition unresolvedTransition: unresolvedTransitions.list) {
|
unresolvedTransition.resolve(processDefinition, parse);
|
}
|
}
|
|
public void parseActivities(Element documentElement, Parse parse, CompositeElementImpl compositeElement) {
|
List<Element> elements = XmlUtil.elements(documentElement);
|
for (Element nestedElement : elements) {
|
String tagName = XmlUtil.getTagLocalName(nestedElement);
|
if ("on".equals(tagName)
|
|| "timer".equals(tagName)
|
|| "swimlane".equals(tagName)
|
|| "migrate-instances".equals(tagName)) continue;
|
|
JpdlBinding activityBinding = (JpdlBinding) getBinding(nestedElement, CATEGORY_ACTIVITY);
|
if (activityBinding == null) {
|
log.debug("unrecognized activity: " + tagName);
|
continue;
|
}
|
|
ActivityImpl activity = compositeElement.createActivity();
|
parse.contextStackPush(activity);
|
try {
|
activity.setType(activityBinding.getTagName());
|
activityBinding.parseName(nestedElement, activity, parse);
|
parseTransitions(nestedElement, activity, parse);
|
|
Element descriptionElement = XmlUtil.element(documentElement, "description");
|
if (descriptionElement!=null) {
|
String description = XmlUtil.getContentText(descriptionElement);
|
activity.setDescription(description);
|
}
|
|
String continuationText = XmlUtil.attribute(nestedElement, "continue");
|
if (continuationText!=null) {
|
if ("async".equals(continuationText)) {
|
activity.setContinuation(Continuation.ASYNCHRONOUS);
|
} else if ("exclusive".equals(continuationText)) {
|
activity.setContinuation(Continuation.EXCLUSIVE);
|
}
|
}
|
|
Object parseResult = activityBinding.parse(nestedElement, parse, this);
|
if (parseResult instanceof ActivityBehaviour) {
|
ActivityBehaviour activityBehaviour = (ActivityBehaviour) parseResult;
|
activity.setActivityBehaviour(activityBehaviour);
|
} else {
|
Descriptor activityBehaviourDescriptor = (Descriptor) parseResult;
|
activity.setActivityBehaviourDescriptor(activityBehaviourDescriptor);
|
}
|
|
parseOnEvents(nestedElement, parse, activity);
|
|
String g = XmlUtil.attribute(nestedElement, "g");
|
if (g == null) continue;
|
|
StringTokenizer stringTokenizer = new StringTokenizer(g, ",");
|
ActivityCoordinatesImpl coordinates = null;
|
if (stringTokenizer.countTokens() == 4) {
|
try {
|
int x = Integer.parseInt(stringTokenizer.nextToken());
|
int y = Integer.parseInt(stringTokenizer.nextToken());
|
int width = Integer.parseInt(stringTokenizer.nextToken());
|
int height = Integer.parseInt(stringTokenizer.nextToken());
|
coordinates = new ActivityCoordinatesImpl(x, y, width, height);
|
} catch (NumberFormatException e) {
|
coordinates = null;
|
}
|
}
|
if (coordinates != null) {
|
activity.setCoordinates(coordinates);
|
} else {
|
parse.addProblem("invalid coordinates g=\"" + g + "\" in " + activity, nestedElement);
|
}
|
} finally {
|
parse.contextStackPop();
|
}
|
}
|
}
|
|
public TimerDefinitionImpl parseTimerDefinition(Element timerElement, Parse parse, ScopeElementImpl scopeElement) {
|
TimerDefinitionImpl timerDefinition = scopeElement.createTimerDefinition();
|
|
String duedate = XmlUtil.attribute(timerElement, "duedate");
|
String duedatetime = XmlUtil.attribute(timerElement, "duedatetime");
|
|
if (duedate!=null) {
|
timerDefinition.setDueDateDescription(duedate);
|
|
} else if (duedatetime!=null) {
|
String dueDateTimeFormatText = (String) EnvironmentImpl.getFromCurrent("jbpm.duedatetime.format");
|
if (dueDateTimeFormatText==null) {
|
dueDateTimeFormatText = "HH:mm dd/MM/yyyy";
|
}
|
SimpleDateFormat dateFormat = new SimpleDateFormat(dueDateTimeFormatText);
|
try {
|
Date duedatetimeDate = dateFormat.parse(duedatetime);
|
timerDefinition.setDueDate(duedatetimeDate);
|
} catch (ParseException e) {
|
parse.addProblem("couldn't parse duedatetime "+duedatetime, e);
|
}
|
} else {
|
parse.addProblem("either duedate or duedatetime is required in timer", timerElement);
|
}
|
|
String repeat = XmlUtil.attribute(timerElement, "repeat");
|
timerDefinition.setRepeat(repeat);
|
|
return timerDefinition;
|
}
|
|
public void parseOnEvents(Element element, Parse parse, ScopeElementImpl scopeElement) {
|
// event listeners
|
List<Element> onElements = XmlUtil.elements(element, "on");
|
for (Element onElement: onElements) {
|
String eventName = XmlUtil.attribute(onElement, "event", true, parse);
|
parseOnEvent(onElement, parse, scopeElement, eventName);
|
|
Element timerElement = XmlUtil.element(onElement, "timer");
|
if (timerElement!=null) {
|
TimerDefinitionImpl timerDefinitionImpl = parseTimerDefinition(timerElement, parse, scopeElement);
|
timerDefinitionImpl.setEventName(eventName);
|
}
|
}
|
}
|
|
public void parseOnEvent(Element element, Parse parse, ObservableElementImpl observableElement, String eventName) {
|
if (eventName!=null) {
|
EventImpl event = observableElement.getEvent(eventName);
|
if (event==null) {
|
event = observableElement.createEvent(eventName);
|
}
|
|
String continuationText = XmlUtil.attribute(element, "continue");
|
if (continuationText!=null) {
|
if ("async".equals(continuationText)) {
|
event.setContinuation(Continuation.ASYNCHRONOUS);
|
} else if ("exclusive".equals(continuationText)) {
|
event.setContinuation(Continuation.EXCLUSIVE);
|
}
|
}
|
|
for (Element eventListenerElement: XmlUtil.elements(element)) {
|
JpdlBinding eventBinding = (JpdlBinding) getBinding(eventListenerElement, CATEGORY_EVENT_LISTENER);
|
if (eventBinding!=null) {
|
EventListenerReference eventListenerReference = null;
|
Object parseResult = eventBinding.parse(eventListenerElement, parse, this);
|
if (parseResult instanceof EventListener) {
|
EventListener eventListener = (EventListener) parseResult;
|
eventListenerReference = event.createEventListenerReference(eventListener);
|
} else {
|
Descriptor eventListenerDescriptor = (Descriptor) parseResult;
|
eventListenerReference = event.createEventListenerReference(eventListenerDescriptor);
|
}
|
|
if (XmlUtil.attributeBoolean(eventListenerElement, "propagation", false, parse, false)) {
|
eventListenerReference.setPropagationEnabled(true);
|
}
|
|
continuationText = XmlUtil.attribute(eventListenerElement, "continue");
|
if (continuationText!=null) {
|
if (observableElement instanceof ActivityImpl) {
|
if (observableElement.getName()==null) {
|
parse.addProblem("async continuation on event listener requires activity name", eventListenerElement);
|
}
|
} else if (observableElement instanceof TransitionImpl) {
|
TransitionImpl transition = (TransitionImpl) observableElement;
|
if (transition.getSource().getName()==null) {
|
parse.addProblem("async continuation on event listener requires name in the transition source activity", eventListenerElement);
|
}
|
}
|
if ("async".equals(continuationText)) {
|
eventListenerReference.setContinuation(Continuation.ASYNCHRONOUS);
|
} else if ("exclusive".equals(continuationText)) {
|
eventListenerReference.setContinuation(Continuation.EXCLUSIVE);
|
}
|
}
|
|
} else {
|
String tagName = XmlUtil.getTagLocalName(eventListenerElement);
|
if ( ! ( (observableElement instanceof TransitionImpl)
|
&& ( "condition".equals(tagName)
|
|| "timer".equals(tagName)
|
)
|
)
|
) {
|
parse.addProblem("unrecognized event listener: "+tagName, null, ProblemImpl.TYPE_WARNING, eventListenerElement);
|
}
|
}
|
}
|
}
|
}
|
|
public void parseTransitions(Element element, ActivityImpl activity, Parse parse) {
|
List<Element> transitionElements = XmlUtil.elements(element, "transition");
|
UnresolvedTransitions unresolvedTransitions = parse.contextStackFind(UnresolvedTransitions.class);
|
for (Element transitionElement: transitionElements) {
|
String transitionName = XmlUtil.attribute(transitionElement, "name", false, parse);
|
|
Element timerElement = XmlUtil.element(transitionElement, "timer");
|
if (timerElement!=null) {
|
TimerDefinitionImpl timerDefinitionImpl = parseTimerDefinition(timerElement, parse, activity);
|
timerDefinitionImpl.setSignalName(transitionName);
|
}
|
|
TransitionImpl transition = activity.createOutgoingTransition();
|
transition.setName(transitionName);
|
|
unresolvedTransitions.add(transition, transitionElement);
|
|
parseOnEvent(transitionElement, parse, transition, Event.TAKE);
|
}
|
}
|
|
public void parseAssignmentAttributes(Element element, AssignableDefinitionImpl assignableDefinition, Parse parse) {
|
Element descriptionElement = XmlUtil.element(element, "description");
|
if (descriptionElement!=null) {
|
String description = XmlUtil.getContentText(descriptionElement);
|
assignableDefinition.setDescription(description);
|
}
|
|
Element assignmentHandlerElement = XmlUtil.element(element, "assignment-handler");
|
if (assignmentHandlerElement!=null) {
|
UserCodeReference assignmentHandlerReference = parseUserCodeReference(assignmentHandlerElement, parse);
|
assignableDefinition.setAssignmentHandlerReference(assignmentHandlerReference);
|
}
|
|
String assigneeExpression = XmlUtil.attribute(element, "assignee");
|
assignableDefinition.setAssigneeExpression(assigneeExpression);
|
|
String assigneeExpressionLanguage = XmlUtil.attribute(element, "assignee-lang");
|
assignableDefinition.setAssigneeExpressionLanguage(assigneeExpressionLanguage);
|
|
String candidateUsersExpression = XmlUtil.attribute(element, "candidate-users");
|
assignableDefinition.setCandidateUsersExpression(candidateUsersExpression);
|
|
String candidateUsersExpressionLanguage = XmlUtil.attribute(element, "candidate-users-lang");
|
assignableDefinition.setCandidateUsersExpressionLanguage(candidateUsersExpressionLanguage);
|
|
String candidateGroupsExpression = XmlUtil.attribute(element, "candidate-groups");
|
assignableDefinition.setCandidateGroupsExpression(candidateGroupsExpression);
|
|
String candidateGroupsExpressionLanguage = XmlUtil.attribute(element, "candidate-groups-lang");
|
assignableDefinition.setCandidateGroupsExpressionLanguage(candidateGroupsExpressionLanguage);
|
}
|
|
public TaskDefinitionImpl parseTaskDefinition(Element element, Parse parse, ScopeElementImpl scopeElement) {
|
TaskDefinitionImpl taskDefinition = new TaskDefinitionImpl();
|
|
String taskName = XmlUtil.attribute(element, "name");
|
taskDefinition.setName(taskName);
|
|
String form = XmlUtil.attribute(element, "form");
|
taskDefinition.setFormResourceName(form);
|
|
ProcessDefinitionImpl processDefinition = parse.contextStackFind(ProcessDefinitionImpl.class);
|
if (processDefinition.getTaskDefinition(taskName)!=null) {
|
parse.addProblem("duplicate task name "+taskName, element);
|
} else {
|
processDefinition.addTaskDefinitionImpl(taskDefinition);
|
}
|
|
String swimlaneName = XmlUtil.attribute(element, "swimlane");
|
if (swimlaneName!=null) {
|
JpdlProcessDefinition jpdlProcessDefinition = parse.contextStackFind(JpdlProcessDefinition.class);
|
SwimlaneDefinitionImpl swimlaneDefinition = jpdlProcessDefinition.getSwimlaneDefinition(swimlaneName);
|
if (swimlaneDefinition!=null) {
|
taskDefinition.setSwimlaneDefinition(swimlaneDefinition);
|
} else {
|
parse.addProblem("swimlane "+swimlaneName+" not declared", element);
|
}
|
}
|
|
parseAssignmentAttributes(element, taskDefinition, parse);
|
|
// parse notification mail producer
|
Element notificationElement = XmlUtil.element(element, "notification");
|
if (notificationElement != null) {
|
parseMailEvent(notificationElement, parse, scopeElement, Event.ASSIGN);
|
}
|
|
Element reminderElement = XmlUtil.element(element, "reminder");
|
if (reminderElement != null) {
|
parseMailEvent(reminderElement, parse, scopeElement, Event.REMIND);
|
// associate timer to event
|
TimerDefinitionImpl timerDefinition = parseTimerDefinition(reminderElement, parse, scopeElement);
|
timerDefinition.setEventName(Event.REMIND);
|
}
|
|
return taskDefinition;
|
}
|
|
public List<VariableDefinitionImpl> parseVariableDefinitions(Element element, Parse parse, boolean initRequired) {
|
List<VariableDefinitionImpl> variableDefinitions = new ArrayList<VariableDefinitionImpl>();
|
|
for (Element inElement: XmlUtil.elements(element, "variable")) {
|
VariableDefinitionImpl variableDefinition = new VariableDefinitionImpl();
|
|
String name = XmlUtil.attribute(inElement, "name", true, parse);
|
variableDefinition.setName(name);
|
|
int sources = 0;
|
|
String initExpr = XmlUtil.attribute(inElement, "init");
|
if (initExpr!=null) {
|
variableDefinition.setInitExpression(initExpr);
|
sources++;
|
}
|
|
Element valueElement = XmlUtil.element(inElement);
|
if (valueElement!=null) {
|
Descriptor initValueDescriptor = (Descriptor) WireParser.getInstance().parseElement(valueElement, parse);
|
variableDefinition.setInitDescriptor(initValueDescriptor);
|
sources++;
|
}
|
|
if (initRequired && sources==0) {
|
parse.addProblem("no init specified", inElement);
|
}
|
if (sources>1) {
|
parse.addProblem("init attribute and init element are mutually exclusive on element variable", inElement);
|
}
|
|
variableDefinitions.add(variableDefinition);
|
}
|
|
return variableDefinitions;
|
}
|
|
public VariableOutDefinitionSet parseVariableOutDefinitionSet(Element element, Parse parse) {
|
VariableOutDefinitionSet variableOutDefinitionSet = new VariableOutDefinitionSet();
|
|
for (Element inElement: XmlUtil.elements(element, "out-variable")) {
|
VariableOutDefinitionImpl variableOutDefinition = variableOutDefinitionSet.createVariableOutDefinition();
|
|
String name = XmlUtil.attribute(inElement, "name", true, parse);
|
variableOutDefinition.setName(name);
|
|
String expression = XmlUtil.attribute(inElement, "init");
|
if (expression!=null) {
|
variableOutDefinition.setExpression(expression);
|
}
|
}
|
|
return variableOutDefinitionSet;
|
}
|
|
public void parseMailEvent(Element element, Parse parse,
|
ObservableElementImpl observableElement, String eventName) {
|
// obtain assign event
|
EventImpl event = observableElement.getEvent(eventName);
|
if (event == null) {
|
event = observableElement.createEvent(eventName);
|
}
|
// register event listener
|
MailListener eventListener = new MailListener();
|
EventListenerReference eventListenerRef = event.createEventListenerReference(eventListener);
|
// set continuation mode
|
String continuationText = XmlUtil.attribute(element, "continue");
|
if ("async".equals(continuationText)) {
|
eventListenerRef.setContinuation(Continuation.ASYNCHRONOUS);
|
}
|
else if ("exclusive".equals(continuationText)) {
|
eventListenerRef.setContinuation(Continuation.EXCLUSIVE);
|
}
|
|
//https://jira.jboss.org/jira/browse/JBPM-2466
|
String mailTemplateName = eventName;
|
if (Event.ASSIGN.equals(eventName)) {
|
mailTemplateName = "task-notification";
|
} else if (Event.REMIND.equals(eventName)) {
|
mailTemplateName = "task-reminder";
|
}
|
|
// associate mail producer to event listener
|
MailProducer mailProducer = parseMailProducer(element, parse, mailTemplateName);
|
eventListener.setMailProducer(mailProducer);
|
}
|
|
public MailProducer parseMailProducer(Element element, Parse parse, String defaultTemplateName) {
|
// check whether the element is a generic object descriptor
|
if (ObjectBinding.isObjectDescriptor(element)) {
|
// TODO test custom mail producer
|
ObjectDescriptor objectDescriptor = parseObjectDescriptor(element, parse);
|
return (MailProducer) WireContext.create(objectDescriptor);
|
}
|
|
// parse the default producer
|
MailProducerImpl mailProducer = new MailProducerImpl();
|
mailProducer.setTemplate(parseMailTemplate(element, parse, defaultTemplateName));
|
return mailProducer;
|
}
|
|
private MailTemplate parseMailTemplate(Element element, Parse parse,
|
String defaultTemplateName) {
|
if (element.hasAttribute("template")) {
|
// fetch template from configuration
|
return findTemplate(element, parse, element.getAttribute("template"));
|
}
|
if (!XmlUtil.isTextOnly(element)) {
|
// parse inline template
|
return MailTemplateBinding.parseMailTemplate(element, parse);
|
}
|
if (defaultTemplateName != null) {
|
// fetch default template
|
return findTemplate(element, parse, defaultTemplateName);
|
}
|
parse.addProblem("mail template must be referenced in the 'template' attribute "
|
+ "or specified inline", element);
|
return null;
|
}
|
|
private MailTemplate findTemplate(Element element, Parse parse, String templateName) {
|
MailTemplateRegistry templateRegistry = EnvironmentImpl.getFromCurrent(MailTemplateRegistry.class);
|
if (templateRegistry != null) {
|
MailTemplate template = templateRegistry.getTemplate(templateName);
|
if (template != null) return template;
|
}
|
parse.addProblem("mail template not found: " + templateName, element);
|
return null;
|
}
|
|
public UserCodeReference parseUserCodeReference(Element element, Parse parse) {
|
UserCodeReference userCodeReference = new UserCodeReference();
|
|
ObjectDescriptor objectDescriptor = parseObjectDescriptor(element, parse);
|
userCodeReference.setDescriptor(objectDescriptor);
|
|
if (objectDescriptor.getExpr()!=null) {
|
// expressions are not cached by default
|
userCodeReference.setCached(false);
|
}
|
|
Boolean isCached = XmlUtil.attributeBoolean(element, "cache", false, parse, null);
|
if (isCached!=null) {
|
userCodeReference.setCached(isCached.booleanValue());
|
}
|
|
return userCodeReference;
|
}
|
|
public ObjectDescriptor parseObjectDescriptor(Element element, Parse parse) {
|
return (ObjectDescriptor) objectBinding.parse(element, parse, wireParser);
|
}
|
|
public Descriptor parseDescriptor(Element element, Parse parse) {
|
return (Descriptor) wireParser.parseElement(element, parse);
|
}
|
|
public Set<String> getActivityTagNames() {
|
return getBindings().getTagNames(CATEGORY_ACTIVITY);
|
}
|
}
|
