The files can be found in the activiti-engine-5.11.jar file in directory
org/activiti/db/upgrade/optional.
+
+
API Change
+
The functionality of the repositoryService.suspendProcessDefinitionByXXX has been slightly altered.
+ Previously, calling this method would stop the execution of jobs related to this process definition.
+ Now, calling this method will not do this, but rather make sure a process instance
+ cannot be created from this process definition. We've added a new method with an additional
+ parameter 'suspendProcessInstances' which can be used to get the same behavior: when set to 'true',
+ all the associated process instances will be suspended. This will avoid process instance continuation,
+ including the execution of jobs related to the process instance.
Release Notes - Activiti - Version 5.10
diff --git a/modules/activiti-engine/pom.xml b/modules/activiti-engine/pom.xml
index d453fbd0fa857cdc8a4e3c576202bb6342e48f03..aa2baa84d1ddc45d8dd48e2afa28ee85dc00cdf6 100644
--- a/modules/activiti-engine/pom.xml
+++ b/modules/activiti-engine/pom.xml
@@ -22,11 +22,6 @@
commons-langcommons-lang
-
-
- org.livetribe
- livetribe-jsr223
- org.mybatismybatis
@@ -41,11 +36,6 @@
junitprovided
-
- org.apache.ant
- ant
- provided
- org.codehaus.groovygroovy
diff --git a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/DeployBarTask.java b/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/DeployBarTask.java
deleted file mode 100644
index 57cf0ca80d0d864e75cae7adc43685e5d747e05f..0000000000000000000000000000000000000000
--- a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/DeployBarTask.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/* Licensed 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.
- */
-package org.activiti.engine.impl.ant;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.zip.ZipInputStream;
-
-import org.activiti.engine.ActivitiException;
-import org.activiti.engine.ProcessEngine;
-import org.activiti.engine.ProcessEngineInfo;
-import org.activiti.engine.ProcessEngines;
-import org.activiti.engine.RepositoryService;
-import org.activiti.engine.impl.util.IoUtil;
-import org.activiti.engine.impl.util.LogUtil;
-import org.apache.tools.ant.BuildException;
-import org.apache.tools.ant.DirectoryScanner;
-import org.apache.tools.ant.Task;
-import org.apache.tools.ant.types.FileSet;
-
-
-/**
- * @author Tom Baeyens
- */
-public class DeployBarTask extends Task {
-
- String processEngineName = ProcessEngines.NAME_DEFAULT;
- File file;
- List fileSets;
-
- public void execute() throws BuildException {
- List files = new ArrayList();
- if (file!=null) {
- files.add(file);
- }
- if (fileSets!=null) {
- for (FileSet fileSet: fileSets) {
- DirectoryScanner directoryScanner = fileSet.getDirectoryScanner(getProject());
- File baseDir = directoryScanner.getBasedir();
- String[] includedFiles = directoryScanner.getIncludedFiles();
- String[] excludedFiles = directoryScanner.getExcludedFiles();
- List excludedFilesList = Arrays.asList(excludedFiles);
- for (String includedFile: includedFiles) {
- if (!excludedFilesList.contains(includedFile)) {
- files.add(new File(baseDir, includedFile));
- }
- }
- }
- }
-
- Thread currentThread = Thread.currentThread();
- ClassLoader originalClassLoader = currentThread.getContextClassLoader();
- currentThread.setContextClassLoader(DeployBarTask.class.getClassLoader());
-
- LogUtil.readJavaUtilLoggingConfigFromClasspath();
-
- try {
- log("Initializing process engine " + processEngineName);
- ProcessEngines.init();
- ProcessEngine processEngine = ProcessEngines.getProcessEngine(processEngineName);
- if (processEngine == null) {
- List processEngineInfos = ProcessEngines.getProcessEngineInfos();
- if( processEngineInfos != null && processEngineInfos.size() > 0 )
- {
- // Since no engine with the given name is found, we can't be 100% sure which ProcessEngineInfo
- // is causing the error. We should show ALL errors and process engine names / resource URL's.
- String message = getErrorMessage(processEngineInfos, processEngineName);
- throw new ActivitiException(message);
- }
- else
- throw new ActivitiException("Could not find a process engine with name '" + processEngineName + "', no engines found. " +
- "Make sure an engine configuration is present on the classpath");
- }
- RepositoryService repositoryService = processEngine.getRepositoryService();
-
- log("Starting to deploy " + files.size() + " files");
- for (File file: files) {
- String path = file.getAbsolutePath();
- log("Handling file " + path);
- try {
- FileInputStream inputStream = new FileInputStream(file);
- try {
- log("deploying bar "+path);
- repositoryService
- .createDeployment()
- .name(file.getName())
- .addZipInputStream(new ZipInputStream(inputStream))
- .deploy();
- } finally {
- IoUtil.closeSilently(inputStream);
- }
- } catch (Exception e) {
- throw new BuildException("couldn't deploy bar "+path+": "+e.getMessage(), e);
- }
- }
-
- } finally {
- currentThread.setContextClassLoader(originalClassLoader);
- }
- }
-
- private String getErrorMessage(List processEngineInfos, String name) {
- StringBuilder builder = new StringBuilder("Could not find a process engine with name ");
- builder.append(name).append(", engines loaded:\n");
- for (ProcessEngineInfo engineInfo : processEngineInfos) {
- String engineName = (engineInfo.getName() != null) ? engineInfo.getName() : "unknown";
- builder.append("Process engine name: ").append(engineName);
- builder.append(" - resource: ").append(engineInfo.getResourceUrl());
- builder.append(" - status: ");
-
- if (engineInfo.getException() != null) {
- builder.append("Error while initializing engine. ");
- if (engineInfo.getException().indexOf("driver on UnpooledDataSource") != -1) {
- builder.append("Exception while initializing process engine! Database or database driver might not have been configured correctly.")
- .append("Please consult the user guide for supported database environments or build.properties. Stacktrace: ")
- .append(engineInfo.getException());
- } else {
- builder.append("Stacktrace: ").append(engineInfo.getException());
- }
- } else {
- // Process engine initialised without exception
- builder.append("Initialised");
- }
- builder.append("\n");
- }
- return builder.toString();
- }
-
- public String getProcessEngineName() {
- return processEngineName;
- }
- public void setProcessEngineName(String processEngineName) {
- this.processEngineName = processEngineName;
- }
- public File getFile() {
- return file;
- }
- public void setFile(File file) {
- this.file = file;
- }
- public List getFileSets() {
- return fileSets;
- }
- public void setFileSets(List fileSets) {
- this.fileSets = fileSets;
- }
-}
diff --git a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchTask.java b/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchTask.java
deleted file mode 100644
index 393d54fb29b5778ef180c69685bbd691ac1f3717..0000000000000000000000000000000000000000
--- a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchTask.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/* Licensed 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.
- */
-package org.activiti.engine.impl.ant;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.StringTokenizer;
-
-import org.apache.tools.ant.BuildException;
-import org.apache.tools.ant.Task;
-
-
-/**
- * @author Tom Baeyens
- */
-public class LaunchTask extends Task {
-
- private static final String FILESEPARATOR = System.getProperty("file.separator");
-
- File dir;
- String script;
- String msg;
- String args;
-
- public void execute() throws BuildException {
- if (dir==null) {
- throw new BuildException("dir attribute is required with the launch task");
- }
- if (script==null) {
- throw new BuildException("script attribute is required with the launch task");
- }
-
- String[] cmd = null;
- String executable = getExecutable();
- if (args!=null) {
- List pieces = new ArrayList();
- pieces.add(executable);
- StringTokenizer tokenizer = new StringTokenizer("args", " ");
- while (tokenizer.hasMoreTokens()) {
- pieces.add(tokenizer.nextToken());
- }
- cmd = pieces.toArray(new String[pieces.size()]);
-
- } else {
- cmd = new String[]{executable};
- }
-
- LaunchThread.launch(this,cmd,dir,msg);
- }
-
- public String getExecutable() {
- String os = System.getProperty("os.name").toLowerCase();
- String dirPath = dir.getAbsolutePath();
- String base = dirPath+FILESEPARATOR+script;
- if (exists(base)) {
- return base;
- }
-
- if (os.indexOf("windows")!=-1) {
- if (exists(base+".exe")) {
- return base+".exe";
- }
- if (exists(base+".bat")) {
- return base+".bat";
- }
- }
-
- if (os.indexOf("linux")!=-1 || os.indexOf("mac")!=-1) {
- if (exists(base+".sh")) {
- return base+".sh";
- }
- }
-
- throw new BuildException("couldn't find executable for script "+base);
- }
-
- public boolean exists(String path) {
- File file = new File(path);
- return (file.exists());
- }
-
- public void setDir(File dir) {
- this.dir = dir;
- }
-
- public void setScript(String script) {
- this.script = script;
- }
-
- public void setMsg(String msg) {
- this.msg = msg;
- }
-
- public void setArgs(String args) {
- this.args = args;
- }
-}
diff --git a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchThread.java b/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchThread.java
deleted file mode 100644
index d4725706c983126767b10402697fb53ce5883e49..0000000000000000000000000000000000000000
--- a/modules/activiti-engine/src/main/java/org/activiti/engine/impl/ant/LaunchThread.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/* Licensed 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.
- */
-package org.activiti.engine.impl.ant;
-
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
-import org.activiti.engine.impl.util.IoUtil;
-import org.apache.tools.ant.BuildException;
-import org.apache.tools.ant.Task;
-
-
-/**
- * @author Tom Baeyens
- */
-public class LaunchThread extends Thread {
-
- Task task;
- String[] cmd;
- File dir;
- String msg;
-
- public LaunchThread(Task task, String[] cmd, File dir, String msg) {
- this.task = task;
- this.cmd = cmd;
- this.dir = dir;
- this.msg = msg;
- }
-
- public static void launch(Task task, String[] cmd, File dir, String launchCompleteText) {
- if (cmd==null) {
- throw new BuildException("cmd is null");
- }
- try {
- LaunchThread launchThread = new LaunchThread(task, cmd, dir, launchCompleteText);
- launchThread.start();
- launchThread.join();
- } catch (Exception e) {
- throw new BuildException("couldn't launch cmd: "+cmdString(cmd), e);
- }
- }
-
- private static String cmdString(String[] cmd) {
- StringBuilder cmdText = new StringBuilder();
- for(String cmdPart: cmd) {
- cmdText.append(cmdPart);
- cmdText.append(" ");
- }
- return cmdText.toString();
- }
-
- public void run() {
- task.log("launching cmd '"+cmdString(cmd)+"' in dir '"+dir+"'");
- if (msg!=null) {
- task.log("waiting for launch completion msg '"+msg+"'...");
- } else {
- task.log("not waiting for a launch completion msg.");
- }
- ProcessBuilder processBuilder = new ProcessBuilder(cmd)
- .redirectErrorStream(true)
- .directory(dir);
-
- InputStream consoleStream = null;
- try {
- Process process = processBuilder.start();
-
- consoleStream = process.getInputStream();
- BufferedReader consoleReader = new BufferedReader(new InputStreamReader(consoleStream));
- String consoleLine = "";
- while ( (consoleLine!=null)
- && (msg==null || consoleLine.indexOf(msg)==-1)
- ) {
- consoleLine = consoleReader.readLine();
-
- if (consoleLine!=null) {
- task.log(" " + consoleLine);
- } else {
- task.log("launched process completed");
- }
- }
- } catch (Exception e) {
- throw new BuildException("couldn't launch "+cmdString(cmd), e);
- } finally {
- IoUtil.closeSilently(consoleStream);
- }
- }
-}
diff --git a/modules/activiti-explorer/src/main/java/org/activiti/explorer/demo/DemoDataGenerator.java b/modules/activiti-explorer/src/main/java/org/activiti/explorer/demo/DemoDataGenerator.java
index 6a9048e74a475ea2cc4621a919d4b759bcda5b33..535d4ce2a26b8c90c76d78b87293a6910f99b869 100644
--- a/modules/activiti-explorer/src/main/java/org/activiti/explorer/demo/DemoDataGenerator.java
+++ b/modules/activiti-explorer/src/main/java/org/activiti/explorer/demo/DemoDataGenerator.java
@@ -136,9 +136,14 @@ public class DemoDataGenerator implements ModelDataJsonConstants {
processEngine.getRepositoryService()
.createDeployment()
.name("Demo processes")
- .addClasspathResource("org/activiti/explorer/demo/process/testProcess.bpmn20.xml")
- .addClasspathResource("org/activiti/explorer/demo/process/oneTaskProcess.bpmn20.xml")
.addClasspathResource("org/activiti/explorer/demo/process/createTimersProcess.bpmn20.xml")
+ .addClasspathResource("org/activiti/explorer/demo/process/VacationRequest.bpmn20.xml")
+ .addClasspathResource("org/activiti/explorer/demo/process/VacationRequest.png")
+ .addClasspathResource("org/activiti/explorer/demo/process/FixSystemFailureProcess.bpmn20.xml")
+ .addClasspathResource("org/activiti/explorer/demo/process/FixSystemFailureProcess.png")
+ .addClasspathResource("org/activiti/explorer/demo/process/Helpdesk.bpmn20.xml")
+ .addClasspathResource("org/activiti/explorer/demo/process/Helpdesk.png")
+ .addClasspathResource("org/activiti/explorer/demo/process/reviewSalesLead.bpmn20.xml")
.deploy();
}
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.bpmn20.xml b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.bpmn20.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6e74b3f6e7ad247db8f586d3f81ecfccf68201e6
--- /dev/null
+++ b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.bpmn20.xml
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ PT4H
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.png b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.png
new file mode 100644
index 0000000000000000000000000000000000000000..382f17ea4504d713aafda67aacd97da5ec3c5669
Binary files /dev/null and b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/FixSystemFailureProcess.png differ
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.bpmn20.xml b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.bpmn20.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2574b428dfbea680f5b539d9b20cd2d907ccb95e
--- /dev/null
+++ b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.bpmn20.xml
@@ -0,0 +1,35 @@
+
+
+
+
+
+
+
+
+
+ Fix issue raised by customer
+
+
+
+
+
+
+
+ PT5M
+
+
+
+
+
+ Escalation: issue was not fixed in time by first level support
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.png b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c4d573970932ef2a9d0b78f8d884b97029bf5c2
Binary files /dev/null and b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/Helpdesk.png differ
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.bpmn20.xml b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.bpmn20.xml
new file mode 100644
index 0000000000000000000000000000000000000000..86746f848e394abc9ef5dfc5dd3ffc133f2d6e95
--- /dev/null
+++ b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.bpmn20.xml
@@ -0,0 +1,86 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ${employeeName} would like to take ${numberOfDays} day(s) of vacation (Motivation: ${vacationMotivation}).
+
+
+
+
+
+
+
+
+
+
+ management
+
+
+
+
+
+
+
+ ${vacationApproved == 'true'}
+
+
+
+
+
+
+
+ ${vacationApproved == 'false'}
+
+
+
+
+ Your manager has disapproved your vacation request for ${numberOfDays} days.
+ Reason: ${managerMotivation}
+
+
+
+
+
+
+
+
+
+
+
+
+ ${employeeName}
+
+
+
+
+
+
+
+ ${resendRequest == 'true'}
+
+
+
+ ${resendRequest == 'false'}
+
+
+
+
+
+
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.png b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4115e9d5fdd8166db0a1c50a62eb3619a7e8d5e
Binary files /dev/null and b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/VacationRequest.png differ
diff --git a/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/reviewSalesLead.bpmn20.xml b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/reviewSalesLead.bpmn20.xml
new file mode 100644
index 0000000000000000000000000000000000000000..6a03c25e489efef32ded8358fe12a7d874b79009
--- /dev/null
+++ b/modules/activiti-webapp-explorer2/src/main/resources/org/activiti/explorer/demo/process/reviewSalesLead.bpmn20.xml
@@ -0,0 +1,197 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ${initiator} has published a new sales lead: ${customerName}. Details: ${details}
+
+
+
+
+
+
+
+
+
+
+
+
+ ${notEnoughInformation == 'true'}
+
+
+ ${notEnoughInformation == 'false'}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Provide additional details for ${customerName}.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pom.xml b/pom.xml
index 98263460325d01a3a05645fbda5ceba60b4b3b41..22a733e90926d828c31f409382877a65785e8870 100644
--- a/pom.xml
+++ b/pom.xml
@@ -201,12 +201,6 @@
activiti-cxf${version}
-
- org.apache.ant
- ant
- 1.7.1
- provided
- org.apache.commons
@@ -270,14 +264,6 @@
json20070829
-
-
- org.livetribe
- livetribe-jsr223
- 2.0.6
- jar
- compile
- org.mule.modulesmule-module-cxf
diff --git a/userguide/src/en/chapters/ch02-GettingStarted.xml b/userguide/src/en/chapters/ch02-GettingStarted.xml
index 65c89dc962c55e78f61b0efe025dee878d7f1f37..47ca9463ba17989c8d8e05802b457d418728fedd 100644
--- a/userguide/src/en/chapters/ch02-GettingStarted.xml
+++ b/userguide/src/en/chapters/ch02-GettingStarted.xml
@@ -10,7 +10,8 @@
After downloading the Activiti Explorer WAR file from the Activiti website,
follow these steps to get the demo setup running with default settings.
You'll need a working Java runtime and
- Apache Tomcat installation.
+ Apache Tomcat installation (Actually,
+ any web container would work since we only rely on servlet capablility. But we test on Tomcat primarily).
Copy the downloaded activiti-explorer.war to the webapps directory of Tomcat.
@@ -103,49 +104,77 @@
-
- Database table names explained
+
+
+ Include the Activiti jar and its dependencies
+
- The database names of Activiti all start with ACT_. The
- second part is a two-character identification of use case of the table. This use case
- will also roughly match the service API.
-
-
-
- ACT_RE_*: 'RE' stands for repository.
- Tables with this prefix will contain 'static'' information such as process definitions and,
- process resources (images, rules, etc.).
-
-
-
-
- ACT_RU_*: 'RU' stands for runtime.
- These are the runtime tables, that contain the runtime data of process instances,
- user tasks,variables, jobs, etc. Activiti only stores the runtime data during process instance
- execution, and removes the records when a process instance ends. This keeps
- the runtime tables small and fast.
-
-
-
-
- ACT_ID_*: 'ID' stands for identity.
- These tables contain identity information, such as users, groups, etc.
-
-
-
-
- ACT_HI_*: 'HI' stands for history.
- These are the tables that contain historic data, such as past process instances,
- variables, tasks, etc.
-
-
-
-
- ACT_GE_*: general data, which is used
- in various use cases.
-
-
-
+ To include the Activiti jar and its dependent libraries, we advise using
+ MavenMaven (or Ivy), as it
+ simplies dependency management on both our and your side a lot. Follow the instructions
+ at to
+ include the necessary jars in your environment.
+
+
+
+ Alternatively, if you don't want to use Maven you can include the jars in your project
+ yourself. The Activiti download zip contains a folder libs which
+ contain all the Activiti jars (and the source jars). The dependencies are not shipped this way.
+ The required dependencies of the Activiti engine are (generated using mvn dependency:tree):
+
+org.activiti:activiti-engine:jar:5.11-SNAPSHOT
++- org.apache.commons:commons-email:jar:1.2:compile
+| +- javax.mail:mail:jar:1.4.1:compile
+| \- javax.activation:activation:jar:1.1:compile
++- commons-lang:commons-lang:jar:2.4:compile
++- org.mybatis:mybatis:jar:3.1.1:compile
++- org.springframework:spring-beans:jar:3.1.2.RELEASE:compile
+| \- org.springframework:spring-core:jar:3.1.2.RELEASE:compile
+| +- org.springframework:spring-asm:jar:3.1.2.RELEASE:compile
+| \- commons-logging:commons-logging:jar:1.1.1:compile
+\- joda-time:joda-time:jar:2.1:compile
+
+ Note: the mail jars are only needed if you are using the mail service task.
+
+
+
+ All the dependencies can easily be downloaded using mvn dependency:copy-dependencies
+ on a module of the Activiti source code.
+
+
+
+
+
+ Next steps
+
+ Playing around with the Activiti Explorer web application
+ is a good way to get familiar with the Activiti concepts and functionality. However, the
+ main purpose of Activiti is of course to enable powerful BPM and workflow capabilities
+ in your own application. The following chapters will get you familiar with how to
+ use Activiti programmatically in your environment:
+
+
+
+ The chapter on configuration will learn you
+ how to set up Activiti and how to obtain an instance of the ProcessEngine
+ class which is your central access point to all the engine functionality of Activiti.
+
+
+
+
+ The API chapter will guide you through the
+ services which form the API of Activiti. These services offer the Activiti engine
+ functionality in a convienent yet powerful way and can be used in any Java
+ environment.
+
+
+
+
+ Interested in getting insight on BPMN 2.0, the format in which process for the
+ Activiti engine are written? Then continue on to the BPMN 2.0 section.
+
+
+
diff --git a/userguide/src/en/chapters/ch03-Configuration.xml b/userguide/src/en/chapters/ch03-Configuration.xml
index 1b02ffaf21c24cebf3e2c3ff7dc41a1af43e38c6..1891b945e1c9f57db64c6507259e81e9ebc33909 100644
--- a/userguide/src/en/chapters/ch03-Configuration.xml
+++ b/userguide/src/en/chapters/ch03-Configuration.xml
@@ -265,50 +265,6 @@ ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemPr
-
- Job executor activation
- The JobExecutor is a component that manages a couple of threads to fire timers (and later also asynchronous messages).
- For unit testing scenarios, it is cumbersome to work with multiple threads. Therefor the API allows to query for
- (ManagementService.createJobQuery) and execute jobs (ManagementService.executeJob) through
- the API so that job execution can be controlled from within a unit test. To avoid that the job executor interferes, it can be turned off.
-
-
- By default, the JobExecutor is activated when the process engine boots. Specify
- <property name="jobExecutorActivate" value="false" />
- when you don't want the JobExecutor to be activated upon process engine boot.
-
-
-
-
- Mail server configuration
-
- Optional. Activiti supports sending e-mails in business processes. To actually send an e-mail, a valid
- SMTP mail server configuration is required. See the
- e-mail task for the configuration options.
-
-
-
-
- History configuration
-
- Optional. Allows to tweak settings that influence the history capabilities
- of the engine. See history configuration for more details.
- <property name="history" value="audit" />
-
-
-
-
- Exposing configuration beans in expressions and scripts
- By default, all beans that you specify in the activiti.cfg.xml configuration
- or in your own spring configuration file are available to expressions and in the scripts.
- If you want to limit the visibility of beans in your configuration file, then you can
- configure a property called beans in your process engine configuration.
- The beans property in ProcessEngineConfiguration is a map. When you specify that property,
- only beans specified in that map will be visible to expressions and scripts. The exposed beans
- will be exposed with the names as you specify in that map.
-
-
-
Supported databasesFollowing are the types (case sensitive!) that Activiti uses to refer to databases.
@@ -404,12 +360,59 @@ ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemPr
identity: optional tables, when using the default identity management as shipped with the engine.
- history: contain the history and audit information. Optional: not needed when history level is set to none
+ history: contain the history and audit information. Optional: not needed when history level is set to none
+ Note that this will also disable some features such as commenting on tasks which store the data in the history database.
+
+
+ Database table names explained
+
+ The database names of Activiti all start with ACT_. The
+ second part is a two-character identification of use case of the table. This use case
+ will also roughly match the service API.
+
+
+
+ ACT_RE_*: 'RE' stands for repository.
+ Tables with this prefix will contain 'static'' information such as process definitions and,
+ process resources (images, rules, etc.).
+
+
+
+
+ ACT_RU_*: 'RU' stands for runtime.
+ These are the runtime tables, that contain the runtime data of process instances,
+ user tasks,variables, jobs, etc. Activiti only stores the runtime data during process instance
+ execution, and removes the records when a process instance ends. This keeps
+ the runtime tables small and fast.
+
+
+
+
+ ACT_ID_*: 'ID' stands for identity.
+ These tables contain identity information, such as users, groups, etc.
+
+
+
+
+ ACT_HI_*: 'HI' stands for history.
+ These are the tables that contain historic data, such as past process instances,
+ variables, tasks, etc.
+
+
+
+
+ ACT_GE_*: general data, which is used
+ in various use cases.
+
+
+
+
+ Database upgrade
@@ -443,4 +446,49 @@ ProcessEngine processEngine = ProcessEngineConfiguration.createStandaloneInMemPr
It's also possible to run the upgrade database scripts, available on the Activiti downloads page.
+
+
+ Job executor activation
+ The JobExecutor is a component that manages a couple of threads to fire timers (and later also asynchronous messages).
+ For unit testing scenarios, it is cumbersome to work with multiple threads. Therefor the API allows to query for
+ (ManagementService.createJobQuery) and execute jobs (ManagementService.executeJob) through
+ the API so that job execution can be controlled from within a unit test. To avoid that the job executor interferes, it can be turned off.
+
+
+ By default, the JobExecutor is activated when the process engine boots. Specify
+ <property name="jobExecutorActivate" value="false" />
+ when you don't want the JobExecutor to be activated upon process engine boot.
+
+
+
+
+ Mail server configuration
+
+ Optional. Activiti supports sending e-mails in business processes. To actually send an e-mail, a valid
+ SMTP mail server configuration is required. See the
+ e-mail task for the configuration options.
+
+
+
+
+ History configuration
+
+ Optional. Allows to tweak settings that influence the history capabilities
+ of the engine. See history configuration for more details.
+ <property name="history" value="audit" />
+
+
+
+
+ Exposing configuration beans in expressions and scripts
+ By default, all beans that you specify in the activiti.cfg.xml configuration
+ or in your own spring configuration file are available to expressions and in the scripts.
+ If you want to limit the visibility of beans in your configuration file, then you can
+ configure a property called beans in your process engine configuration.
+ The beans property in ProcessEngineConfiguration is a map. When you specify that property,
+ only beans specified in that map will be visible to expressions and scripts. The exposed beans
+ will be exposed with the names as you specify in that map.
+
+
+
diff --git a/userguide/src/en/chapters/ch05-API.xml b/userguide/src/en/chapters/ch04-API.xml
similarity index 55%
rename from userguide/src/en/chapters/ch05-API.xml
rename to userguide/src/en/chapters/ch04-API.xml
index 928b1896a77adedffbd2741f72a8c7e09376b452..a6d434f68f26c1c45ca107d8874e88f6a51a4880 100644
--- a/userguide/src/en/chapters/ch05-API.xml
+++ b/userguide/src/en/chapters/ch04-API.xml
@@ -1,8 +1,8 @@
-
- API
+
+ The Activiti APIEngine API
@@ -35,7 +35,7 @@ FormService formService = processEngine.getFormService();
and ProcessEngines.destroy()
- ProcessEngines will scan for all activiti.cfg.xml and activiti-context.xml files.
+ The ProcessEngines class will scan for all activiti.cfg.xml and activiti-context.xml files.
For all activiti.cfg.xml files, the process engine will be build in the typical Activiti way: ProcessEngineConfiguration.createProcessEngineConfigurationFromInputStream(inputStream).buildProcessEngine().
For all activiti-context.xml files, the process engine will be build in the Spring way: First
the spring application context is created and then the process engine is obtained from that application context.
@@ -79,12 +79,252 @@ FormService formService = processEngine.getFormService();
-
+
+
+ Working with the Activiti services
+
+ As described above, the way to interact with the Activiti engine is through the services exposed by
+ an instance of the org.activiti.engine.ProcessEngine class. The following
+ code snippets assume you have a working Activiti environment, ie. you have access
+ to a valid org.activiti.engine.ProcessEngine. If you simply want to try
+ out the code below, you can download or clone the
+ Activiti unit test template,
+ import it in your IDE and add a testUserguideCode() method to the
+ org.activiti.MyUnitTest unit test.
+
+
+ The end goal of this little tutorial will be to have a working business process which mimics
+ a simplistic vacation request process at a company:
+
+
+
+
+ Deploying the process
+
+ Everything that is related to 'static' data (such as process definitions) are accessed
+ through the RepositoryService. Conceptually, every such
+ static piece of data is content of the 'repository' of the Activiti engine.
+
+
+ Create a new xml file VacationRequest.bpmn20.xml in the src/test/resources/org/activiti/test
+ resource folder (or anywhere else if you're not using the unit test template) with the
+ following content. Note that this section won't explain the xml constructs being used in the example above.
+ Please read the bpmn 2.0 chapter to get yourself familiar
+ first if that hasn't happened yet.
+
+<?xml version="1.0" encoding="UTF-8" ?>
+<definitions id="definitions"
+ targetNamespace="http://activiti.org/bpmn20"
+ xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:activiti="http://activiti.org/bpmn">
+
+ <process id="vacationRequest" name="Vacation request">
+
+ <startEvent id="request" activiti:initiator="employeeName">
+ <extensionElements>
+ <activiti:formProperty id="numberOfDays" name="Number of days" type="long" value="1" required="true"/>
+ <activiti:formProperty id="startDate" name="First day of holiday (dd-MM-yyy)" datePattern="dd-MM-yyyy hh:mm" type="date" required="true" />
+ <activiti:formProperty id="vacationMotivation" name="Motivation" type="string" />
+ </extensionElements>
+ </startEvent>
+ <sequenceFlow id="flow1" sourceRef="request" targetRef="handleRequest" />
+
+ <userTask id="handleRequest" name="Handle vacation request" >
+ <documentation>
+ ${employeeName} would like to take ${numberOfDays} day(s) of vacation (Motivation: ${vacationMotivation}).
+ </documentation>
+ <extensionElements>
+ <activiti:formProperty id="vacationApproved" name="Do you approve this vacation" type="enum" required="true">
+ <activiti:value id="true" name="Approve" />
+ <activiti:value id="false" name="Reject" />
+ </activiti:formProperty>
+ <activiti:formProperty id="managerMotivation" name="Motivation" type="string" />
+ </extensionElements>
+ <potentialOwner>
+ <resourceAssignmentExpression>
+ <formalExpression>management</formalExpression>
+ </resourceAssignmentExpression>
+ </potentialOwner>
+ </userTask>
+ <sequenceFlow id="flow2" sourceRef="handleRequest" targetRef="requestApprovedDecision" />
+
+ <exclusiveGateway id="requestApprovedDecision" name="Request approved?" />
+ <sequenceFlow id="flow3" sourceRef="requestApprovedDecision" targetRef="sendApprovalMail">
+ <conditionExpression xsi:type="tFormalExpression">${vacationApproved == 'true'}</conditionExpression>
+ </sequenceFlow>
+
+ <task id="sendApprovalMail" name="Send confirmation e-mail" />
+ <sequenceFlow id="flow4" sourceRef="sendApprovalMail" targetRef="theEnd1" />
+ <endEvent id="theEnd1" />
+
+ <sequenceFlow id="flow5" sourceRef="requestApprovedDecision" targetRef="adjustVacationRequestTask">
+ <conditionExpression xsi:type="tFormalExpression">${vacationApproved == 'false'}</conditionExpression>
+ </sequenceFlow>
+
+ <userTask id="adjustVacationRequestTask" name="Adjust vacation request">
+ <documentation>
+ Your manager has disapproved your vacation request for ${numberOfDays} days.
+ Reason: ${managerMotivation}
+ </documentation>
+ <extensionElements>
+ <activiti:formProperty id="numberOfDays" name="Number of days" value="${numberOfDays}" type="long" required="true"/>
+ <activiti:formProperty id="startDate" name="First day of holiday (dd-MM-yyy)" value="${startDate}" datePattern="dd-MM-yyyy hh:mm" type="date" required="true" />
+ <activiti:formProperty id="vacationMotivation" name="Motivation" value="${vacationMotivation}" type="string" />
+ <activiti:formProperty id="resendRequest" name="Resend vacation request to manager?" type="enum" required="true">
+ <activiti:value id="true" name="Yes" />
+ <activiti:value id="false" name="No" />
+ </activiti:formProperty>
+ </extensionElements>
+ <humanPerformer>
+ <resourceAssignmentExpression>
+ <formalExpression>${employeeName}</formalExpression>
+ </resourceAssignmentExpression>
+ </humanPerformer>
+ </userTask>
+ <sequenceFlow id="flow6" sourceRef="adjustVacationRequestTask" targetRef="resendRequestDecision" />
+
+ <exclusiveGateway id="resendRequestDecision" name="Resend request?" />
+ <sequenceFlow id="flow7" sourceRef="resendRequestDecision" targetRef="handleRequest">
+ <conditionExpression xsi:type="tFormalExpression">${resendRequest == 'true'}</conditionExpression>
+ </sequenceFlow>
+
+ <sequenceFlow id="flow8" sourceRef="resendRequestDecision" targetRef="theEnd2">
+ <conditionExpression xsi:type="tFormalExpression">${resendRequest == 'false'}</conditionExpression>
+ </sequenceFlow>
+ <endEvent id="theEnd2" />
+
+ </process>
+
+</definitions>
+
+
+
+
+ To make this process being known to the Activiti engine, we must 'deploy' it first.
+ Deploying means that the engine will parse the BPMN 2.0 xml to something executable
+ and a new database record will be added for each process definition included in the
+ 'deployment'. This way, when the engine reboots, it will still know all of the
+ 'deployed' processes:
+
+ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
+RepositoryService repositoryService = processEngine.getRepositoryService();
+repositoryService.createDeployment()
+ .addClasspathResource("org/activiti/test/VacationRequest.bpmn20.xml")
+ .deploy();
+
+Log.info("Number of process definitions: " + repositoryService.createProcessDefinitionQuery().count());
+
+
+
+
+ Read more about deployment in the deployment chapter.
+
+
+
+
+ Starting a process instance
+
+ After deploying the process definition to the Activiti engine, we can start new process instances from it.
+ For each process definition, there are typically many process instances. The process definition
+ is the 'blueprint', while a process instance is a runtime execution of it.
+
+
+ Everything related to the runtime state of processes can be found in the RuntimeService.
+ There are various way to start a new process instance. In the following snippet, we use the
+ key we defined in the process definition xml to start the process instance. We're also providing
+ some process variables at process instance start, because the description of the first
+ user task will use these in its expressions. Process variables will be used all the time,
+ as these variables give meaning to the process instance. Typically, the process variables
+ are what make process instances differ.
+
+Map<String, Object> variables = new HashMap<String, Object>();
+variables.put("employeeName", "Kermit");
+variables.put("numberOfDays", new Integer(4));
+variables.put("vacationMotivation", "I'm really tired!");
+
+RuntimeService runtimeService = processEngine.getRuntimeService();
+ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("vacationRequest", variables);
+
+// Verify that we started a new process instance
+Log.info("Number of process instances: " + runtimeService.createProcessInstanceQuery().count());
+
+
+
+
+
+ Completing tasks
+
+ When the process starts, the first step will be a user task. This is a step that must be performed
+ by a user of the system. Typically, such a user will have an 'inbox of tasks' which lists
+ all the tasks that need to be done by this user. Following code snippet shows how such a query might be performed:
+
+// Fetch all tasks for the management group
+TaskService taskService = processEngine.getTaskService();
+List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup("management").list();
+for (Task task : tasks) {
+ Log.info("Task available: " + task.getName());
+}
+
+
+
+ To continue the process instance, we need to finish this task. For the Activiti engine,
+ this means you need to complete the task. Following snippet shows how this is done:
+
+Task task = tasks.get(0);
+
+Map<String, Object> taskVariables = new HashMap<String, Object>();
+taskVariables.put("vacationApproved", "false");
+taskVariables.put("managerMotivation", "We have a tight deadline!");
+taskService.complete(task.getId(), taskVariables);
+
+ The process instance will now continue to the next step. In this example, this will
+ be the first step again, because the task was not approved.
+
+
+
+
+ Suspending and activating a process
+
+ It's possible to suspend a process definition. When a process definition is suspended,
+ new process instance can't be created (an exception will be thrown). Suspending
+ the process definition is done through the RepositoryService:
+
+repositoryService.suspendProcessDefinitionByKey("vacationRequest");
+try {
+ runtimeService.startProcessInstanceByKey("vacationRequest");
+} catch (ActivitiException e) {
+ e.printStackTrace();
+}
+
+ To reactivate a process definition, simply call one of the repositoryService.activateProcessDefinitionXXX methods.
+
+
+ It's also possible to suspend a process instance. When suspended, the process cannot
+ be continued (eg. completing a task throws an exception) and no jobs (such as timers)
+ will executed. Suspending a process instance can be done by calling the
+ runtimeService.suspendProcessInstance method.
+ Activating the process instance again, is done by calling the runtimeService.activateProcessInstanceXXX methods.
+
+
+
+
+ Further reading
+
+ We've barely scratched the surface in the previous sections regarding Activiti functionality.
+ We will expand these sections further in the future with additional coverage of the Activiti API.
+ Of course, as with any open source project, the best way to learn is to inspect the code
+ and read the Javadocs!
+
+
+
+
+
Query API
There are two ways of querying data from the engine: The query API and native queries. The Query API allows to
- programm with a fluent API completly typesafe queries. You can add various conditions to your queries, all of them
+ program with a fluent API completly typesafe queries. You can add various conditions to your queries, all of them
are applied together (logical AND) and one ordering. The following code shows an example:
List<Task> tasks = taskService.createTaskQuery()
@@ -121,6 +361,53 @@ FormService formService = processEngine.getFormService();
+
+ Expressions
+ Activiti uses UEL for expression-resolving. UEL stands for Unified Expression Language and is part of the EE6 specification (see
+
+ the EE6 specification for detailed information). To support all features of latest UEL spec on ALL environments, we use a modified version of JUEL.
+
+
+ Expressions can be used in for example Java Service tasks, Execution Listeners, Task Listeners and Conditional sequence flows.
+ Although there are 2 types of expressions, value-expression and method-expression, Activiti makes abstraction of this and they can both be used where an expression is needed.
+
+
+
+ Value expression: resolves to a value. By default, all process variables are available to use. Also all spring-beans (if using Spring) are available to use in expressions.
+
+ Some examples:
+${myVar}
+${myBean.myProperty}
+
+
+
+
+ Method expression: invokes a method, with or without parameters. When invoking a method without parameters, be sure to add empty parentheses after the method-name.
+ The passed parameters can be literal values or expressions that are resolved themselves. Examples:
+${printer.print()}
+${myBean.addNewOrder('orderName')}
+${myBean.doSomething(myVar, execution)}
+
+
+
+
+
+ Note that these expressions support resolving primitives (incl. comparing them), beans, lists, arrays and maps.
+
+
+ On top of all process-variables, there are a few object exposed that you can use in expressions:
+
+ execution: The DelegateExecution that holds additional information about the ongoing execution.
+ task: The DelegateTask that holds additional information about the current Task.Note: Only works in expressions evaluated from task-listeners.
+ authenticatedUserId: The id of the user that is currently authenticated. If no user is authenticated, variable is not available.
+
+
+
+ For more concrete usage and examples, check out Expressions in Spring, Java Service tasks, Execution Listeners, Task Listeners or Conditional sequence flows.
+
+
+
+
Unit testing
@@ -278,92 +565,4 @@ public class ProcessEnginesServletContextListener implements ServletContextListe
-
- Process Virtual Machine API
- The Process Virtual Machine API exposes the POJO core of the Process Virtual Machine.
- Reading and playing with it is interesting for education purposes to understand
- the internal workings of Activiti. And the POJO API can also be used to build
- new process languages.
-
- For example:
- PvmProcessDefinition processDefinition = new ProcessDefinitionBuilder()
- .createActivity("a")
- .initial()
- .behavior(new WaitState())
- .transition("b")
- .endActivity()
- .createActivity("b")
- .behavior(new WaitState())
- .transition("c")
- .endActivity()
- .createActivity("c")
- .behavior(new WaitState())
- .endActivity()
- .buildProcessDefinition();
-
-PvmProcessInstance processInstance = processDefinition.createProcessInstance();
-processInstance.start();
-
-PvmExecution activityInstance = processInstance.findExecution("a");
-assertNotNull(activityInstance);
-
-activityInstance.signal(null, null);
-
-activityInstance = processInstance.findExecution("b");
-assertNotNull(activityInstance);
-
-activityInstance.signal(null, null);
-
-activityInstance = processInstance.findExecution("c");
-assertNotNull(activityInstance);
-
-
-
-
- Expressions
- Activiti uses UEL for expression-resolving. UEL stands for Unified Expression Language and is part of the EE6 specification (see
-
- the EE6 specification for detailed information). To support all features of latest UEL spec on ALL environments, we use a modified version of JUEL.
-
-
- Expressions can be used in for example Java Service tasks, Execution Listeners, Task Listeners and Conditional sequence flows.
- Although there are 2 types of expressions, value-expression and method-expression, Activiti makes abstraction of this and they can both be used where an expression is needed.
-
-
-
- Value expression: resolves to a value. By default, all process variables are available to use. Also all spring-beans (if using Spring) are available to use in expressions.
-
- Some examples:
-${myVar}
-${myBean.myProperty}
-
-
-
-
- Method expression: invokes a method, with or without parameters. When invoking a method without parameters, be sure to add empty parentheses after the method-name.
- The passed parameters can be literal values or expressions that are resolved themselves. Examples:
-${printer.print()}
-${myBean.addNewOrder('orderName')}
-${myBean.doSomething(myVar, execution)}
-
-
-
-
-
- Note that these expressions support resolving primitives (incl. comparing them), beans, lists, arrays and maps.
-
-
- On top of all process-variables, there are a few object exposed that you can use in expressions:
-
- execution: The DelegateExecution that holds additional information about the ongoing execution.
- task: The DelegateTask that holds additional information about the current Task.Note: Only works in expressions evaluated from task-listeners.
- authenticatedUserId: The id of the user that is currently authenticated. If no user is authenticated, variable is not available.
-
-
-
- For more concrete usage and examples, check out Expressions in Spring, Java Service tasks, Execution Listeners, Task Listeners or Conditional sequence flows.
-
-
-
-
diff --git a/userguide/src/en/chapters/ch04-Spring.xml b/userguide/src/en/chapters/ch05-Spring.xml
similarity index 100%
rename from userguide/src/en/chapters/ch04-Spring.xml
rename to userguide/src/en/chapters/ch05-Spring.xml
diff --git a/userguide/src/en/chapters/ch06-Deployment.xml b/userguide/src/en/chapters/ch06-Deployment.xml
index ca76acb21733438de0a6e03410b7736b9f8e59d3..5801bb1460c88d9275519c349b32cbba8b4e9b10 100644
--- a/userguide/src/en/chapters/ch06-Deployment.xml
+++ b/userguide/src/en/chapters/ch06-Deployment.xml
@@ -35,26 +35,6 @@ repositoryService.createDeployment()
See javadocs for more details.
-
- Deploying with ant
- To deploy a business archive with ant, first the deploy-bar task
- needs to be defined. Make sure that the configuration jar is on the classpath, as well as the
- Activiti jar and all its dependencies:
- <taskdef name="deploy-bar" classname="org.activiti.engine.impl.ant.DeployBarTask">
- <classpath>
- <fileset dir="...">
- <include name="activiti-cfg.jar"/>
- <include name="your-db-driver.jar"/>
- </fileset>
- <fileset dir="${activiti.home}/lib">
- <include name="activiti-engine-${activiti.version}.jar"/>
- <include name="ibatis-sqlmap-*.jar"/>
- </fileset>
- </classpath>
-</taskdef>
-<deploy-bar file=".../yourprocess.bar" />
-
-
Deploying with Activiti Explorer
diff --git a/userguide/src/en/chapters/ch11-Designer.xml b/userguide/src/en/chapters/ch11-Designer.xml
index d10ed6a4329d5299576c0cbcc8fb3a264c38cd95..ccab4e0bc2352c44e145923842ff4437cab65beb 100644
--- a/userguide/src/en/chapters/ch11-Designer.xml
+++ b/userguide/src/en/chapters/ch11-Designer.xml
@@ -572,7 +572,9 @@
the classes that will be used by the Activiti engine during runtime. In your extension you
describe the properties that can be set in Activiti Designer for each shape. From these
shapes, your refer to the runtime class that should be used by the engine. This class
- should implement JavaDelegate as for any ServiceTask in Activiti.
+ should implement JavaDelegate as for any ServiceTask in Activiti.
+ See this section for more
+ details.
A shape's class is a simple Java class, to which a number of annotations are added.
The class should implement the CustomServiceTask interface, but you
shouldn't implement this interface yourself. Extend the
@@ -692,15 +694,46 @@ public class AcmeMoneyTask extends AbstractCustomServiceTask {
- The final step for your shape is to indicate the class that is instantiated by the
- Activiti engine when it reaches your node when executing a process instance. To do this,
- you use the @Runtime annotation. The delegationClass
- attribute you return should contain the canonical name of the runtime class. Note that the
- runtime class shouldn't be in your extension JAR, as it's dependent on the Activiti
- libraries.
-
- @Runtime(delegationClass = "org.acme.runtime.AcmeMoneyJavaDelegation")
-
+
+
+ Configuring runtime execution of Custom Service Tasks
+
+
+ With your fields setup and your extension applied to Designer, users can configure
+ the properties of the service task when modelling a process. In most cases, you will
+ want to use these user-configured properties when the process is executed by Activiti.
+ To do this, you must instruct Activiti which class to instantiate when the process reaches
+ your CustomServiceTask.
+
+
+
+ There is a special annotation for specifying the class to be executed for your CustomServiceTask,
+ the @Runtime annotation. Here's an example of how to use it:
+
+
+ @Runtime(delegationClass = "org.acme.runtime.AcmeMoneyJavaDelegation")
+
+
+ The delegationClass
+ attribute you provide should contain the canonical name of the runtime class. This is a class that implements
+ Activiti's JavaDelegate interface. You should implement this class in the same manner as any
+ other JavaDelegate. Documentation for this is provided in the userguide here.
+
+
+
+ The user's property values will be injected into the delegationClass runtime class
+ if you provide members in the class for Activiti to inject into. The names should match the names of the members
+ in your CustomServiceTask. For more information, consult this part
+ of the userguide.
+
+
+
+ Note that the runtime class shouldn't be in your extension JAR, as it's dependent on the Activiti
+ libraries. Activiti needs to be able to find it at runtime, so it needs to be on the Activiti engine's
+ classpath.
+
+
+ Property types
diff --git a/userguide/src/en/chapters/ch12-Explorer.xml b/userguide/src/en/chapters/ch12-Explorer.xml
index 5a41fa4655770f3d6daff365188c09e700e3ece1..f84291b50116e772a90adc295057640c09052dd8 100644
--- a/userguide/src/en/chapters/ch12-Explorer.xml
+++ b/userguide/src/en/chapters/ch12-Explorer.xml
@@ -6,19 +6,23 @@
Activiti Explorer
- Activiti Explorer is a web application that is installed during the demo setup.
+ Activiti Explorer is a web application that is included when you download Activiti from the
+ Activiti website. The purpose of Explorer is not a finished, end-user ready application, but
+ rather to excersise and show the functionality of Activiti. As such, Explorer is meant as a demo,
+ or maybe inspiration for people using Activti in there own applications. Out of the box, Explorer
+ uses an in-memory database, but it is easy to switch to your own database (see the applicationContext files in the WEB-INF folder).
+
+
After logging into the application, you will see three large icons that show the main capabilities.
- Cases: case and task management functionality.
+ Tasks: Task management functionality.
Here you can see user tasks from running processes that are assigned to you, or
- see group tasks which you can claim. Note that in Explorer we talk about cases
- rather than tasks. As Explorer allows to relate content, divide
- work into subtasks, involve people in different roles, etc ... the term case
- covers better what is possible. Activiti Explorer as such can be used to create
- cases that are not related to processes (i.e. standalone cases).
+ see group tasks which you can claim. Explorer allows to relate content, divide
+ work into subtasks, involve people in different roles, etc ... Explorer can also be used
+ to create standalone tasks that are not related to any process.
@@ -39,47 +43,37 @@
- Case overview
-
-
-
-
-
-
-
-
-
- Cases
+ Tasks
- Inbox: shows the cases where the logged in user is the assignee.
+ Inbox: shows the tasks where the logged in user is the assignee.
- My Cases: shows the cases where the logged in user is the owner.
- When you create a standalone case, you are automatically made owner of the case.
+ My tasks: shows the tasks where the logged in user is the owner.
+ When you create a standalone task, you are automatically made owner of the task.
Queued: shows the different groups which you are part
- of. Cases here must first be claimed before they can be completed.
+ of. Tasks here must first be claimed before they can be completed.
- Involved: shows the cases where the logged in user is
+ Involved: shows the tasks where the logged in user is
involved with (i.e. not assignee or owner).
- Archived contains the past (historical) cases.
+ Archived contains the past (historical) tasks.
@@ -154,7 +148,7 @@
Users and Groups: manage the users and groups: create, edit and delete
users and groups. Relate users to groups such they have more privileges or they can see
- cases assigned to specific groups.
+ tasks assigned to specific groups.
diff --git a/userguide/src/en/images/api.vacationRequest.png b/userguide/src/en/images/api.vacationRequest.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4115e9d5fdd8166db0a1c50a62eb3619a7e8d5e
Binary files /dev/null and b/userguide/src/en/images/api.vacationRequest.png differ
diff --git a/userguide/src/en/index.xml b/userguide/src/en/index.xml
index a1edab06517729a6d8ba6ddd3db9cc0d316b66fa..eaf56f2b036b2156fffa45391807ff0a0484cd4c 100644
--- a/userguide/src/en/index.xml
+++ b/userguide/src/en/index.xml
@@ -3,8 +3,8 @@
-
-
+
+