文章来源于网络收集而来，版权归原创者所有，如有侵权请及时联系！

15.REST API

发布于 2019-10-28 05:33:28 字数 227438 浏览 1268 评论 0 收藏 0

通用 Activiti REST 原则

安装与认证

activiti 包含了一个 activiti 引擎的 REST API，把 activiti-rest.war 部署到像 Apache Tomcat 这样的 servlet 容器就可以使用。不过，它也可以使用在其他 web 应用中，把 activiti-rest 的依赖都加入 classpath，添加 servlet，并映射到你的应用中。

默认情况下，activiti 引擎会连接内存数据库 H2。你可以修改 WEB-INF/classes 目录下的 db.properties 来修改数据库设置。REST API 使用 JSON 格式（http://www.json.org），它是基于 Restlet（http://www.restlet.org）开发的。

默认所有 REST 资源都需要先使用有效的 activiti 用户认证后才能使用。会使用 Basic HTTP 认证，所以你要一直在请求的 HTTP 头中包含一个 Authorization: Basic ...== 属性，或在请求 url 中包含用户名和密码（比如： http://username:password@localhost... ）。

建议把 Basic 认证与 HTTPS 一起使用。

可以从删除对应资源的认证，或添加额外的授权给一个认证的用户（比如，把用户加入一个组，让它可以执行 URL Y）。可以使用 org.activiti.rest.common.filter.RestAuthenticator 的实现，它有两个方法：

boolean requestRequiresAuthentication(Request request) ：在请求认证检查之前调用（通过头部传递合法的账号和密码）。如果方法返回 true，这个方法就需要认证才能访问。如果返回 false，无论请求是否认证都可以访问。如果返回 false，就不会为这个方法调用 isRequestAuthorized 。
boolean isRequestAuthorized(Request request) ：在用户已经通过 activiti 账号管理认证后，但是再请求实际之前调用。可以用来检查认证用户是否可以访问对应请求。如果返回 true，会允许请求执行。如果返回 true，请求不会执行，客户端会收到对应的错误。

自定义的 RestAuthenticator 应该设置到 RestletServlet 的 org.activiti.rest.service.application.ActivitiRestServicesApplication 中。最简单的方法是创建 ActivitiRestServicesApplication 的子类，并在 servlet-mapping 中设置自定义的类名：

   <!-- Restlet adapter -->
  <servlet>
    <servlet-name>RestletServlet</servlet-name>
    <servlet-class>org.restlet.ext.servlet.ServerServlet</servlet-class>
    <init-param>
      <!-- Application class name -->
      <param-name>org.restlet.application</param-name>
      <param-value>com.my.company.CustomActivitiRestServicesApplication</param-value>
    </init-param>
  </servlet>

使用 Tomcat

根据 Tomcat 的默认安全配置，默认转码的前斜线（ %2F 和 %5C ）都不允许使用（返回 400）。 这可能对部署资源和它们的数据 URL 造成影响，URL 可能会包含转移的前斜线。 当出现预期外的 400 问题，设置下面这个系统参数： -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true.

方法和返回值

Table 15.1.HTTP 方法和对应操作

方法	操作
`GET`	获得一个资源或获得多个资源
`POST`	创建一个新资源。当请求结果太复杂，无法放到 GET 请求的 URL 中，也用来查询资源。
`PUT`	更新已有资源的属性。也用来调用现存资源的功能。
`DELETE`	删除现存资源。

Table 15.2.HTTP 方法响应代码

响应	描述
`200 - Ok`	操作成功，响应返回（ `GET` 和 `PUT` 请求）。
`201 - Created`	操作成功，实体已创建，并返回到响应体中（ `POST` 请求）。
`204 - No content`	操作成功，实体已删除，不会返回响应体（ `DELETE` 请求）。
`401 - Unauthorized`	操作失败。操作要求设置 Authentication 头部。如果请求中已经设置了头部，对应的凭证是无效的或者用户不允许执行这个操作。
`403 - Forbidden`	禁止操作，不要重试。这不是认证和授权的问题，这是禁止操作。比如：删除一个执行中流程的任务是不允许的，无论用户或流程任务的状态。
`404 - Not found`	操作失败。找不到请求的资源。
`405 - Method not allowed`	操作失败。使用的资源方法不允许调用。比如：想更新（PUT）已部署的资源会返回 `405` 结果。
`409 - Conflict`	操作失败。更新其他操作应更新的资源，会导致更新不合法。也可以表示一个结合中新创建的资源的 id 已经存在了。
`415 - Unsupported Media Type`	操作失败。请求体包含了不支持的媒体类型。当请求体的 JSON 中包含未知的属性或值时，也会返回这个响应，一般是因为无法处理的错误格式或类型。
`500 - Internal server error`	操作失败。执行操作时出现了预期外的异常。响应体中包含错误的细节。

media-type 和 HTTP 响应永远都是 application/json ，除非需要使用二进制内容（比如：发布资源数据），会使用内容的 media-type。

错误响应体

当发生错误时（包括客户端和服务端，4XX 和 5XX 状态码），响应体会包含描述发生的错误的描述。下面是任务不存在时出现的 404 状态：

{
  "statusCode" : 404,
  "errorMessage" : "Could not find a task with id '444'."
}

请求参数

URL 片段

url 上的参数（比如 http://host/actviti-rest/service/repository/deployments/{deploymentId} 上的 deploymentId）都需要转义（参考 URL 编码或百分号编码来解决特殊字符问题）。大多数框架都有这种内置功能，但我们也要把这个问题考虑在内。特别是对于可能包含前斜线（比如，部署资源）的情况，这就是必须的。

Rest URL 查询参数

设置在 URL 中的查询参数（比如， http://host/activiti-rest/service/deployments?name=Deployment 中的 name 参数）可以使用以下类型，它们对应着以下 REST-API 文档：

Table 15.3.URL 查询参数类型

类型	格式
String	纯文本参数。可以包含任何 URL 允许的合法的字符。对于 `XXXLike` 参数，字符串应该包含通配符 `%` （还要通过 url 编码）。这可以指定模糊搜索的意图。比如' `Tas%` '匹配所有以'Tas'开头的值。
Integer	整数参数。只能包含非小数的整数值，在-2.147.483.648 与 2.147.483.647 之间。
Long	长整形参数。只能包含非小树的长整形值，在-9.223.372.036.854.775.808 与 9.223.372.036.854.775.807 之间。
Boolean	布尔类型参数。可以是 `true` 或 `false` 。如果使用了其他值，会返回' `405 - Bad request` '响应。
Date	日期类型。使用 ISO-8601 日期格式（参考维基百科上的 ISO-8601），用于时间和日期组件（比如 `2013-04-03T23:45Z` ）。

JSON 内容参数

Table 15.4.JSON 参数类型

类型	格式
String	纯文本参数。可以包含任何 URL 允许的合法的字符。对于 `XXXLike` 参数，字符串应该包含通配符 `%` （还要通过 url 编码）。这可以指定模糊搜索的意图。比如' `Tas%` '匹配所有以'Tas'开头的值。
Integer	整数参数，JSON 数字。只能包含非小数的整数值，在-2.147.483.648 与 2.147.483.647 之间。
Long	长整形参数，JSON 数字。只能包含非小树的长整形值，在-9.223.372.036.854.775.808 与 9.223.372.036.854.775.807 之间。
Boolean	布尔类型参数，JSON 布尔。可以是 `true` 或 `false` 。如果使用了其他值，会返回' `405 - Bad request` '响应。
Date	日期类型，JSON 文本。使用 ISO-8601 日期格式（参考维基百科上的 ISO-8601），用于时间和日期组件（比如 `2013-04-03T23:45Z` ）。

分页与排序

分页与排序参数可以添加到 URL 的 query-string 中（比如 http://host/activiti-rest/service/deployments?sort=name 中的 name 参数）。

Table 15.5.查询 JSON 参数

参数	默认值	描述
sort	根据查询实现而不同	查询的名称，对于不同的查询实现，默认值也不同。
order	asc	排序的方式，可以为'asc'或'desc'。
start	0	分页查询开始的值，默认从 0 开始。
size	10	分页查询每页显示的记录数。默认为 10。

JSON 查询变量格式

{
  "name" : "variableName",
  "value" : "variableValue",
  "operation" : "equals",
  "type" : "string"
}

Table 15.6.查询 JSON 参数

参数	是否必须	描述
name	否	查询包含的变量名称。在一些查询中使用' `equals` '查询对应资源的所有值时，可以为空。
value	是	查询包含的变量值，要包含给定类型的正确格式。
operation	是	查询使用的参数，可以是以下值： `equals, notEquals, equalsIgnoreCase, notEqualsIgnoreCase, lessThan, greaterThan, lessThanOrEquals, greaterThanOrEquals` 和 `like` 。
type	否	使用的变量的类型。如果省略，类型会根据 `value` 参数决定。所以 JSON 文本值都会认为是 `string` 类型，JSON 布尔对应 `boolean` ，JSON 数字根据数字的长度对应 `long` 或 `integer` 。在不确定时，建议使用精确的类型。下面列出了不稳定支持的其他类型。

Table 15.7.默认查询 JSON 类型

类型名称	描述
string	对应 `java.lang.String` .
short	对应 `java.lang.Integer` .
integer	对应 `java.lang.Integer` .
long	对应 `java.lang.Long` .
double	对应 `java.lang.Double` .
boolean	对应 `java.lang.Boolean` .
date	对应 `java.util.Date` 。JSON 字符串会使用 ISO-8601 格式进行转换。

变量格式

在使用变量时（执行，流程和任务），REST-api 使用一些通用原则和 JSON 格式实现读写。变量的 JSON 格式看起来如下所示：

{
  "name" : "variableName",
  "value" : "variableValue",
  "valueUrl" : "http://...",
  "scope" : "local",
  "type" : "string"
}

Table 15.8.变量 JSON 属性

参数	是否必须	描述
name	是	变量名称。
value	否	变量值。写入变量时，如果没有设置 `value` ，会认为值是 `null` 。
valueUrl	否	当读取变量的类型为 `binary` 或 `serializable` 时，这个属性会指向获取原始二进制数据的 URL。
scope	否	变量的范围。如果为' `local` '，变量会对应到请求的资源。如果为' `global` '，变量会定义到请求资源的上级（或上级树的任何上级）。当写入变量，没有设置 scope 时，假设使用 `global` 。
type	否	变量类型。参考下面的表格对类型的描述。当写入变量，没有设置类型时，会根据请求的 JSON 属性来推断它的类型，限制为 `string` ， `double` ， `integer` 和 `boolean` 。如果不确定会用到的类型，建议还是要设置一个类型。

Table 15.9.变量类型

类型名	描述
string	对应 `java.lang.String` 。写入时使用 JSON 文本。
integer	对应 `java.lang.Integer` 。写入时，先使用 JSON 数进行字转换，如果失败就使用 JSON 文本。
short	对应 `java.lang.Short` 。写入时，先使用 JSON 数字进行转换，如果失败就使用 JSON 文本。
long	对应 `java.lang.Long` 。写入时，先使用 JSON 数字进行转换，如果失败就使用 JSON 文本。
double	对应 `java.lang.Double` 。写入时，先使用 JSON 数字进行转换，如果失败就使用 JSON 文本。
boolean	对应 `java.lang.Boolean` 。写入时，使用 JSON 布尔进行转换。
date	对应 `java.util.Date` 。写入时，使用 ISO-8601 日期格式转换为 JSON 文本。
binary	二进制变量，对应字节数组。 `value` 属性为 null， `valueUrl` 包含指向原始二进制流的 URL。
serializable	可序列化的 Java 对象序列化后的结果。和 `binary` 类型相同， `value` 属性为 null， `valueUrl` 包含指向原始二进制流的 URL。所有可以序列化变量（上面不包含的类型）都会使用这个类型。

可以通过自定义 JSON 格式来支持更多变量类型（无论是简单数值或复杂/内嵌 JSON 对象）。扩展 org.activiti.rest.api.RestResponseFactory 的 initializeVariableConverters() 方法，你可以添加自定义的 org.activiti.rest.api.service.engine.variable.RestVariableConverter 类来支持 POJO 与对应 REST 数据的相互转换。实际的 JSON 转换是通过 Jackson 实现的。

部署

如果使用 tomcat，请参考 tomcat 用法。

部署列表

GET repository/deployments

Table 15.10.URL 查询参数

参数	是否必须	值	描述
name	否	String	只返回指定名称的部署。
nameLike	否	String	只返回名称与指定值相似的部署。
category	否	String	只返回指定分类的部署。
categoryNotEquals	否	String	只返回与指定分类不同的部署。
tenantId	否	String	只返回指定 tenantId 的部署。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的部署。
withoutTenantId	否	Boolean	如果为 `true` ，只返回没有设置 tenantId 的部署。如果为 `false` ，忽略 `withoutTenantId` 参数。
sort	否	'id'（默认），'name'，'deploytime'或'tenantId'	排序属性，与'order'一起使用。
通用的分页和排序查询参数都可以使用。

Table 15.11.REST 响应码

响应码	描述
200	表示请求成功。

成功响应体：

{
  "data": [
    {
      "id": "10",
      "name": "activiti-examples.bar",
      "deploymentTime": "2010-10-13T14:54:26.750+02:00",
      "category": "examples",
      "url": "http://localhost:8081/service/repository/deployments/10",
          "tenantId": null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获得一个部署

GET repository/deployments/{deploymentId}

Table 15.12.获得一个部署 - URL 参数

参数	是否必须	值	描述
deploymentId	是	String	获取部署的 id。

Table 15.13.获得一个部署 - 响应码

响应码	描述
200	表示找到了部署，并返回。
404	表示找不到请求的部署。

成功响应体：

{
  "id": "10",
  "name": "activiti-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": "examples",
  "url": "http://localhost:8081/service/repository/deployments/10",
  "tenantId" : null
}

创建新部署

POST repository/deployments

请求体：

请求体包含的数据类型应该是multipart/form-data。请求里应该只包含一个文件，其他额外的任务都会被忽略。部署的名称就是文件域的名称。如果需要在一个部署中包含多个资源，把这些文件压缩成 zip 包，并要确认文件名是以 .bar 或 .zip 结尾。

可以在请求体中传递一个额外的参数（表单域） tenantId 。字段的值会用来设置部署的租户 id。

Table 15.14.创建新部署 - 响应码

响应码	描述
201	表示部署已经创建了。
400	表示请求内没有内容，或部署不支持内容的 mime-type。在状态描述中包含更新信息。

成功响应体：

{
  "id": "10",
  "name": "activiti-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": null,
  "url": "http://localhost:8081/service/repository/deployments/10",
  "tenantId" : "myTenant"
}

删除部署

DELETE repository/deployments/{deploymentId}

Table 15.15.删除部署 - URL 参数

参数	是否必须	值	描述
deploymentId	是	String	删除的部署 id。

Table 15.16.删除部署 - 响应码

响应码	描述
204	表示找到了部署并已经删除。响应体为空。
404	表示没有找到请求的部署。

列出部署内的资源

GET repository/deployments/{deploymentId}/resources

Table 15.17.列出部署内的资源 - URL 参数

参数	是否必须	值	描述
deploymentId	是	String	获取资源的部署 id。

Table 15.18.列出部署内的资源 - 响应码

响应码	描述
200	表示找到了部署，并返回了资源列表。
404	表示找不到请求的部署。

成功响应体：

[
  {
    "id": "diagrams/my-process.bpmn20.xml",
    "url": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resources/diagrams%2Fmy-process.bpmn20.xml",
    "dataUrl": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resourcedata/diagrams%2Fmy-process.bpmn20.xml",
    "mediaType": "text/xml",
    "type": "processDefinition"
  },
  {
    "id": "image.png",
    "url": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resources/image.png",
    "dataUrl": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resourcedata/image.png",
    "mediaType": "image/png",
    "type": "resource"
  }
]

mediaType ：包含资源的 media-type。这是使用（可插拔的） MediaTypeResolver 处理的，默认已经支持了一些有限的 mime-type 映射。
type ：资源类型，可能值为：
- resource ：原始资源。
- processDefinition ：包含一个或多个流程定义的资源。它会被发布器处理。
- processImage ：展示一个已发布流程定义的图形布局。

结果 json 中的 dataUrl 属性包含了用来获取二进制资源的真实 URL。

获取部署资源

GET repository/deployments/{deploymentId}/resources/{resourceId}

Table 15.19.获取部署资源 - URL 参数

参数	是否必须	值	描述
deploymentId	是	String	部署 ID 是请求资源的一部分。
resourceId	是	String	获取资源的 ID 确保 URL 对资源 ID 进行编码的情况下，包含斜杠，例如：使用'diagrams%2Fmy-process.bpmn20.xml' 代替 'diagrams/Fmy-process.bpmn20.xml'。

Table 15.20.获取部署资源 - 响应码

响应码	描述
200	表示部署和资源都已经找到并且部署的资源已经成功返回。
404	表示请求的部署并没有找到或者目前的部署对象并没有该资源 ID。状态描述还包含一些额外信息。

成功响应体：

{
  "id": "diagrams/my-process.bpmn20.xml",
  "url": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resources/diagrams%2Fmy-process.bpmn20.xml",
  "dataUrl": "http://localhost:8081/activiti-rest/service/repository/deployments/10/resourcedata/diagrams%2Fmy-process.bpmn20.xml",
  "mediaType": "text/xml",
  "type": "processDefinition"
}

mediaType ：包含资源的 media-type。这是使用（可插拔的） MediaTypeResolver 处理的，默认已经支持了一些有限的 mime-type 映射。
type : 资源类型，可能的值
- resource : 原始资源.
- processDefinition : 包含一个或多个流程定义的资源。它会被发布器处理。
- processImage : 展示一个已发布流程定义的图形布局。

获取部署资源的内容

GET repository/deployments/{deploymentId}/resourcedata/{resourceId}

Table 15.21.获取部署资源的内容 - URL 参数

参数	是否必须	值	描述
deploymentId	是	String	部署 ID 是请求资源的一部分。
resourceId	是	String	资源 ID 获取数据确保 URL 对资源 ID 进行编码的情况下，包含斜杠，例如：使用'diagrams%2Fmy-process.bpmn20.xml' 代替 'diagrams/Fmy-process.bpmn20.xml'

Table 15.22.获取部署资源的内容 - 响应码

响应码	描述
200	表示部署和资源都已经找到并且部署的资源已经成功返回。
404	表示请求的部署并没有找到或者目前的部署对象并没有该资源 ID。状态描述还包含一些额外信息。

成功响应体：

根据请求的资源响应体将包含二进制的资源内容。响应体的 content-type 的'mimeType'属性将会和资源的返回类型相同。同样，响应头设置 content-disposition，允许浏览器下载该文件而不是去显示它。

流程定义

流程定义列表

GET repository/process-definitions

Table 15.23.流程定义列表 - URL 参数

参数	是否必须	值	描述
version	否	integer	只返回给定版本的流程定义。
name	否	String	只返回给定名称的流程定义。
nameLike	否	String	只返回与给定名称匹配的流程定义。
key	否	String	只返回给定 key 的流程定义。
keyLike	否	String	只返回与给定 key 匹配的流程定义。
resourceName	否	String	只返回给定资源名称的流程定义。
resourceNameLike	否	String	只返回与给定资源名称匹配的流程定义。
category	否	String	只返回给定分类的流程定义。
categoryLike	否	String	只返回与给定分类匹配的流程定义。
categoryNotEquals	否	String	只返回非给定分类的流程定义。
deploymentId	否	String	只返回包含在与给定 id 一致的部署中的流程定义。
startableByUser	否	String	只返回给定用户可以启动的流程定义。
latest	否	Boolean	只返回最新的流程定义版本。只能与'key'或'keyLike'参数一起使用，如果使用了其他参数会返回 400 的响应。
suspended	否	Boolean	如果为 `true` ，只返回挂起的流程定义。如果为 `false` ，只返回活动的（未挂起）的流程定义。
sort	否	'name'（默认），'id'，'key'，'category'，'deploymentId'和'version'	排序的属性，可以与'order'一起使用。
也可以使用通用的分页与排序查询参数。

Table 15.24.流程定义列表 - 响应码

响应码	描述
200	表示请求成功，流程定义已返回。
400	表示传递的参数格式错误，或'latest'与'key'，'keyLike'之外的其他参数一起使用了。状态信息包含更多信息。

成功响应体：

{
  "data": [
    {
      "id" : "oneTaskProcess:1:4",
      "url" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "version" : 1,
      "key" : "oneTaskProcess",
      "category" : "Examples",
      "suspended" : false,
      "name" : "The One Task Process",
      "description" : "This is a process for testing purposes",
      "deploymentId" : "2",
      "deploymentUrl" : "http://localhost:8081/repository/deployments/2",
      "graphicalNotationDefined" : true,
      "resource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.xml",
      "diagramResource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.png",
      "startFormDefined" : false
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

graphicalNotationDefined ：表示流程定义包含图形信息（BPMN DI）。
resource ：包含实际部署的 BPMN 2.0 xml。
diagramResource ：包含流程的图形内容，如果没有图形就返回 null。

获得一个流程定义

GET repository/process-definitions/{processDefinitionId}

Table 15.25.获得一个流程定义 - URL 参数

参数	是否必须	值	描述
processDefinitionId	是	String	希望获取的流程定义的 id。

Table 15.26.获得一个流程定义 - 响应码

响应码	描述
200	表示找到了流程定义，并返回了结果。
404	表示找不到请求的流程定义。

成功响应体：

{
  "id" : "oneTaskProcess:1:4",
  "url" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "version" : 1,
  "key" : "oneTaskProcess",
  "category" : "Examples",
  "suspended" : false,
  "name" : "The One Task Process",
  "description" : "This is a process for testing purposes",
  "deploymentId" : "2",
  "deploymentUrl" : "http://localhost:8081/repository/deployments/2",
  "graphicalNotationDefined" : true,
  "resource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.xml",
  "diagramResource" : "http://localhost:8182/repository/deployments/2/resources/testProcess.png",
  "startFormDefined" : false
}

graphicalNotationDefined ：表示流程定义包含图形信息（BPMN DI）。
resource ：包含实际部署的 BPMN 2.0 xml。
diagramResource ：包含流程的图形内容，如果没有图形就返回 null。

更新流程定义的分类

PUT repository/process-definitions/{processDefinitionId}

请求的 JSON：

{
  "category" : "updatedcategory"
}

Table 15.27.更新流程定义的分类 - 响应码

响应码	描述
200	表示已经修改了流程的分类。
400	表示请求体中没有传递分类。
404	表示找不到请求的流程定义。

成功响应体：参考 repository/process-definitions/{processDefinitionId} .

获得一个流程定义的资源内容

GET repository/process-definitions/{processDefinitionId}/resourcedata

Table 15.28.获得一个流程定义的资源内容 - URL 参数

参数	是否必须	值	描述
processDefinitionId	是	String	期望获得资源数据的流程定义的 id。

响应：

与 GET repository/deployment/{deploymentId}/resourcedata/{resourceId} 的响应码和响应体完全一致。

获得流程定义的 BPMN 模型

GET repository/process-definitions/{processDefinitionId}/model

Table 15.29.获得流程定义的 BPMN 模型 - URL 参数

参数	是否必须	值	描述
processDefinitionId	是	String	期望获得模型的流程定义的 id。

Table 15.30.获得流程定义的 BPMN 模型 - 响应码

响应码	描述
200	表示已找到流程定义，并返回了模型。
404	表示找不到请求的流程定义。

响应体： 响应体是一个转换为 JSON 格式的 org.activiti.bpmn.model.BpmnModel ，包含整个流程定义模型。

{
   "processes":[
      {
         "id":"oneTaskProcess",
         "xmlRowNumber":7,
         "xmlColumnNumber":60,
         "extensionElements":{

         },
         "name":"The One Task Process",
         "executable":true,
         "documentation":"One task process description",

         ...
    ],

    ...
}

暂停流程定义

PUT repository/process-definitions/{processDefinitionId}

请求 JSON 体：

{
  "action" : "suspend",
  "includeProcessInstances" : "false",
  "date" : "2013-04-15T00:42:12Z"
}

Table 15.31.暂停流程定义 - 请求的 JSON 参数

参数	描述	是否必须
action	执行的动作。 `activate` 或 `suspend` 。	是
includeProcessInstances	是否把流程定义下正在运行的流程时也暂停或激活。如果忽略，就不改变流程实例的状态。	否
date	执行暂停或激活的日期（ISO-8601 格式）。如果忽略，会立即执行暂停或激活。	否

Table 15.32.暂停流程定义 - 响应码

响应码	描述
200	表示暂停流程成功。
404	表示找不到请求的流程定义。
409	表示请求的流程定义已经暂停了。

成功响应体： 参考 repository/process-definitions/{processDefinitionId} 的响应。

激活流程定义

PUT repository/process-definitions/{processDefinitionId}

请求 JSON 体：

{
  "action" : "activate",
  "includeProcessInstances" : "true",
  "date" : "2013-04-15T00:42:12Z"
}

参考暂停流程定义的 JSON 参数。

Table 15.33.激活流程定义 - 响应码

响应码	描述
200	表示激活流程成功。
404	表示找不到请求的流程定义
409	表示请求的流程定义已经激活了。

成功响应体： 参考 repository/process-definitions/{processDefinitionId} 的响应。

获得流程定义的所有候选启动者

GET repository/process-definitions/{processDefinitionId}/identitylinks

Table 15.34.获得流程定义的所有候选启动者 - URL 参数

参数	是否必须	值	描述
processDefinitionId	是	String	期望获得 IdentityLink 的流程定义 id。

Table 15.35.获得流程定义的所有候选启动者 - 响应码

响应码	描述
200	表示已找到流程定义，并返回了请求的 IdentityLink。
404	表示找不到请求的流程定义。

成功响应体：

[
   {
      "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/groups/admin",
      "user":null,
      "group":"admin",
      "type":"candidate"
   },
   {
      "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
      "user":"kermit",
      "group":null,
      "type":"candidate"
   }
]

为流程定义添加一个候选启动者

POST repository/process-definitions/{processDefinitionId}/identitylinks

Table 15.36.为流程定义添加一个候选启动者 - URL 参数

参数	是否必填	数据	描述
processDefinitionId	是	String	流程定义的 id。

请求体（用户）：

{
  "user" : "kermit"
}

请求体（组）：

{
  "groupId" : "sales"
}

Table 15.37.为流程定义添加一个候选启动者 - 响应码

响应码	描述
201	表示找到了流程定义，并创建了 IdentityLink。
404	表示找不到请求的流程定义。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

删除流程定义的候选启动者

DELETE repository/process-definitions/{processDefinitionId}/identitylinks/{family}/{identityId}

Table 15.38.删除流程定义的候选启动者 - URL 参数

参数	是否必填	数据	描述
processDefinitionId	是	String	流程定义的 id。
family	是	String	`users` 或 `groups` ，依赖 IdentityLink 的类型。
identityId	是	String	需要删除的候选创建者的身份的 userId 或 groupId。

Table 15.39.删除流程定义的候选启动者 - 响应码

响应码	描述
204	表示找到了流程定义，并删除了 IdentityLink。响应体为空。
404	表示找不到请求的流程定义，或者在流程定义中找不到与 url 匹配的 IdentityLink。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

获得流程定义的一个候选启动者

GET repository/process-definitions/{processDefinitionId}/identitylinks/{family}/{identityId}

Table 15.40.获得流程定义的一个候选启动者 - URL 参数

参数	是否必填	数据	描述
processDefinitionId	是	String	流程定义的 id。
family	是	String	`users` 或 `groups` ，依赖 IdentityLink 的类型。
identityId	是	String	用来获得候选启动者的身份的 userId 或 groupId。

Table 15.41.获得流程定义的一个候选启动者 - 响应码

响应码	描述
200	表示找到了流程定义，并返回了 IdentityLink。
404	表示找不到请求的流程定义，或者在流程定义中找不到与 url 匹配的 IdentityLink。

成功响应体：

{
  "url":"http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4/identitylinks/users/kermit",
  "user":"kermit",
  "group":null,
  "type":"candidate"
}

模型

获得模型列表

GET repository/models

Table 15.42.获得模型列表 - URL 参数

参数	是否必须	值	描述
id	否	String	指返回指定 id 的模型。
category	否	String	只返回指定分类的模型。
categoryLike	否	String	只返回与给定分类匹配的模型。使用 `%` 作为通配符。
categoryNotEquals	否	String	只返回非指定分类的模型。
name	否	String	只返回指定名称的模型。
nameLike	否	String	只返回与指定名称匹配的模型。使用 `%` 作为通配符。
key	否	String	只返回指定 key 的模型。
deploymentId	否	String	只返回包含在指定部署包中的模型。
version	否	Integer	只返回指定版本的模型。
latestVersion	否	Boolean	如果为 `true` ，只返回最新版本的模型。最好与 `key` 一起使用。如果为 `false` ，就会返回所有版本。
deployed	否	Boolean	如果为 `true` ，只返回已部署的模型。如果为 `false` ，只返回未部署的模型（deploymentId 为 null）。
tenantId	否	String	只返回指定 tenantId 的模型。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的模型。
withoutTenantId	否	Boolean	如果为 `true` ，只返回没有设置 tenantId 的模型。如果为 `false` ，会忽略 `withoutTenantId` 参数。
sort	否	'id' (默认), 'category', 'createTime', 'key', 'lastUpdateTime', 'name'，'version'或'tenantId'	排序的字段，和'order'一起使用。
可以使用通用的分页和排序查询参数。

Table 15.43.获得模型列表 - 响应码

响应码	描述
200	表示请求成功，并返回了模型
400	表示传递的参数格式错误。状态信息中包含更多信息。

成功响应体：

{
   "data":[
      {
         "name":"Model name",
         "key":"Model key",
         "category":"Model category",
         "version":2,
         "metaInfo":"Model metainfo",
         "deploymentId":"7",
         "id":"10",
         "url":"http://localhost:8182/repository/models/10",
         "createTime":"2013-06-12T14:31:08.612+0000",
         "lastUpdateTime":"2013-06-12T14:31:08.612+0000",
         "deploymentUrl":"http://localhost:8182/repository/deployments/7",
                 "tenantId":null
      },

      ...

   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获得一个模型

GET repository/models/{modelId}

Table 15.44.获得一个模型 - URL 参数

参数	是否必须	值	描述
modelId	是	String	希望获得的模型 id。

Table 15.45.获得一个模型 - 响应码

响应码	描述
200	表示找到了模型并成功返回了。
404	表示找不到请求的模型。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":null
}

更新模型

PUT repository/models/{modelId}

请求体：

{
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "tenantId":"updatedTenant"
}

所有请求参数都是可选的。比如，你可以只在请求体的 JSON 对象中包含'name'属性，只更新模型的名称，这样其他的字段都不会受到影响。如果显示包含了一个属性，并设置为 null，模型值会被更新为 null。比如： {"metaInfo" : null} 会清空模型的 metaInfo。

Table 15.46.更新模型 - 响应码

响应码	描述
200	表示找到了模型，并成功更新。
404	表示找不到请求的模型。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":2,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":""updatedTenant"
}

新建模型

POST repository/models

请求体：

{
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":1,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "tenantId":"tenant"
}

All request values are optional. For example, you can only include the 'name' attribute in the request body JSON-object, only setting the name of the model, leaving all other fields null.

Table 15.47.新建模型 - 响应码

响应码	描述
201	表示成功创建了模型。

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/repository/models/5",
   "name":"Model name",
   "key":"Model key",
   "category":"Model category",
   "version":1,
   "metaInfo":"Model metainfo",
   "deploymentId":"2",
   "deploymentUrl":"http://localhost:8182/repository/deployments/2",
   "createTime":"2013-06-12T12:31:19.861+0000",
   "lastUpdateTime":"2013-06-12T12:31:19.861+0000",
   "tenantId":"tenant"
}

删除模型

DELETE repository/models/{modelId}

Table 15.48.删除模型 - URL 参数

参数	是否必须	值	描述
modelId	是	String	希望删除的模型 id。

Table 15.49.删除模型 - 响应码

响应码	描述
204	表示找到了模型并成功删除。响应体为空。
404	表示找不到请求的模型。

获得模型的可编译源码

GET repository/models/{modelId}/source

Table 15.50.获得模型的可编译源码 - URL 参数

参数	是否必须	值	描述
modelId	是	String	模型 id。

Table 15.51.获得模型的可编译源码 - 响应码

响应码	描述
200	表示找到了模型并返回了源码。
404	表示找不到请求的模型。

成功响应体： 响应体包含了模型的原始可编译源码。无论源码的内容是什么，响应的 content-type 都设置为 application/octet-stream 。

设置模型的可编辑源码

PUT repository/models/{modelId}/source

Table 15.52.设置模型的可编辑源码 - URL 参数

参数	是否必填	数据	描述
modelId	是	String	模型的 id。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。

Table 15.53.设置模型的可编辑源码 - 响应码

响应码	描述
200	表示找到了模型并更新了源码。
404	表示找不到请求的模型。

成功响应体： 响应体包含了模型的原始可编译源码。无论源码的内容是什么，响应的 content-type 都设置为 application/octet-stream 。

获得模型的附加可编辑源码

GET repository/models/{modelId}/source-extra

Table 15.54.获得模型的附加可编辑源码 - URL 参数

参数	是否必须	值	描述
modelId	是	String	模型 id

Table 15.55.获得模型的附加可编辑源码 - 响应码

响应码	描述
200	表示找到了模型并返回了源码。
404	表示找不到请求的模型。

成功响应体： 响应体包含了模型的原始可编译源码。无论附加源码的内容是什么，响应的 content-type 都设置为 application/octet-stream 。

设置模型的附加可编辑源码

PUT repository/models/{modelId}/source-extra

Table 15.56.设置模型的附加可编辑源码 - URL 参数

参数	是否必填	数据	描述
modelId	是	String	模型 id

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容

Table 15.57.设置模型的附加可编辑源码 - 响应码

响应码	描述
200	表示找到了模型并更新了附加源码。
404	表示找不到请求的模型。

成功响应体： 响应体包含了模型的原始可编译源码。无论附加源码的内容是什么，响应的 content-type 都设置为 application/octet-stream 。

流程实例

获得流程实例

GET runtime/process-instances/{processInstanceId}

Table 15.58.获得流程实例 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	流程实例 id

Table 15.59.获得流程实例 - 响应码

响应码	描述
200	表示找到了流程实例并成功返回。
404	表示找不到请求的流程实例

成功响应体：

{
   "id":"7",
   "url":"http://localhost:8182/runtime/process-instances/7",
   "businessKey":"myBusinessKey",
   "suspended":false,
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
   "activityId":"processTask",
   "tenantId": null
}

删除流程实例

DELETE runtime/process-instances/{processInstanceId}

Table 15.60.删除流程实例 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	希望删除的流程实例 id

Table 15.61.删除流程实例 - 响应码

响应码	描述
204	表示找到了流程实例并已删除。响应内容为空。
404	表示找不到请求的流程实例

激活或挂起流程实例

PUT runtime/process-instances/{processInstanceId}

Table 15.62.激活或挂起流程实例 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	希望激活或挂起的流程实例 id

请求响应体（挂起）：

{
   "action":"suspend"
}

请求响应体（激活）：

{
   "action":"activate"
}

Table 15.63.激活或挂起流程实例 - 响应码

响应码	描述
200	表示找到了流程实例并执行了对应操作。
400	表示提供的操作不合法。
404	表示找不到请求的流程实例
409	表示无法执行请求的流程实例操作，因为流程实例已经激活或挂起了。

启动流程实例

POST runtime/process-instances

请求体（使用流程定义 id 启动）：

{
   "processDefinitionId":"oneTaskProcess:1:158",
   "businessKey":"myBusinessKey",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable",
      },

      ...
   ]
}

请求体（使用流程定义 key 启动）：

{
   "processDefinitionKey":"oneTaskProcess",
   "businessKey":"myBusinessKey",
   "tenantId": "tenant1",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable",
      },

      ...
   ]
}

请求体（使用 message 启动）：

{
   "message":"newOrderMessage",
   "businessKey":"myBusinessKey",
   "tenantId": "tenant1",
   "variables": [
      {
        "name":"myVar",
        "value":"This is a variable",
      },

      ...
   ]
}

请求体中只能使用 processDefinitionId ， processDefinitionKey 或 message 三者之一。参数 businessKey ， variables 和 tenantId 都是可选的。可以在 REST 变量章节了解更多关于变量格式的信息。注意忽略变量作用域，流程变量总是 local 。

Table 15.64.启动流程实例 - 响应码

响应码	描述
201	表示成功启动了流程实例。
400	表示要么找到不到流程定义（基于 id 或 key），要么指定的 message 不会启动流程，要么传递了非法的变量。状态描述中包含了错误相关的额外信息。

成功响应体：

{
   "id":"7",
   "url":"http://localhost:8182/runtime/process-instances/7",
   "businessKey":"myBusinessKey",
   "suspended":false,
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
   "activityId":"processTask",
   "tenantId" : null
}

显示流程实例列表

GET runtime/process-instances

Table 15.65.显示流程实例列表 - URL 参数

参数	是否必须	值	描述
id	否	String	只返回指定 id 的流程实例。
processDefinitionKey	否	String	只返回指定流程定义 key 的流程实例。
processDefinitionId	否	String	只返回指定流程定义 id 的流程实例。
businessKey	否	String	只返回指定 businessKey 的流程实例。
involvedUser	否	String	只返回指定用户参与过的流程实例。
suspended	否	Boolean	如果为 `true` ，只返回挂起的流程实例。如果为 `false` ，只返回未挂起（激活）的流程实例。
superProcessInstanceId	否	String	只返回指定上级流程实例 id 的流程实例（对应 call-activity）。
subProcessInstanceId	否	String	只返回指定子流程 id 的流程实例（对方 call-activity）。
excludeSubprocesses	否	Boolean	只返回非子流程的流程实例。
includeProcessVariables	否	Boolean	表示结果中包含流程变量。
tenantId	否	String	只返回指定 tenantId 的流程实例。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的流程实例。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的流程实例。如果为 `false` ，会忽略 `withoutTenantId` 参数。
sort	否	String	排序字段，应该为 `id` （默认）， `processDefinitionId` ， `tenantId` 或 `processDefinitionKey` 三者之一。
可以使用通用的分页和排序查询参数。

Table 15.66.显示流程实例列表 - 响应码

响应码	描述
200	表示请求成功，并返回了流程实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
   "data":[
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/process-instances/7",
         "businessKey":"myBusinessKey",
         "suspended":false,
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
         "activityId":"processTask",
                 "tenantId" : null
      },

      ...
   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

查询流程实例

POST query/process-instances

请求体：

{
  "processDefinitionKey":"oneTaskProcess",
  "variables":
  [
    {
        "name" : "myVariable",
        "value" : 1234,
        "operation" : "equals",
        "type" : "long"
    },
    ...
  ],
  ...
}

请求体可以包含所有用于显示流程实例列表中的查询参数。除此之外，查询条件中也可以使用变量列表，格式在此。

可以使用通用的分页和排序查询参数。

Table 15.67.查询流程实例 - 响应码

响应码	描述
200	表示请求成功，并返回了流程实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
   "data":[
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/process-instances/7",
         "businessKey":"myBusinessKey",
         "suspended":false,
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
         "activityId":"processTask",
                 "tenantId" : null
      },

      ...
   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

获得流程实例的流程图

GET runtime/process-instances/{processInstanceId}

Table 15.68.获得流程实例的流程图 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	希望获得流程图的流程实例 id。

Table 15.69.获得流程实例的流程图 - 响应码

响应码	描述
200	表示找到了流程实例，并返回了流程图。
400	表示找不到请求的流程实例，流程不包含挺信息（BPMN:DI），所以没有创建图片。
404	表示找不到请求的流程实例

成功响应体：

{
   "id":"7",
   "url":"http://localhost:8182/runtime/process-instances/7",
   "businessKey":"myBusinessKey",
   "suspended":false,
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/processOne%3A1%3A4",
   "activityId":"processTask"
}

获得流程实例的参与者

GET runtime/process-instances/{processInstanceId}/identitylinks

Table 15.70.获得流程实例的参与者 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	关联的流程实例 id。

Table 15.71.获得流程实例的参与者 - 响应码

响应码	描述
200	表示找到了流程实例，并返回了 IdentityLink。
404	表示找不到请求的流程实例

成功响应体：

[
   {
      "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
      "user":"john",
      "group":null,
      "type":"customType"
   },
   {
      "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/paul/candidate",
      "user":"paul",
      "group":null,
      "type":"candidate"
   }
]

注意 groupId 总是 null，因为只有用户才能实际参与到流程实例中。

为流程实例添加一个参与者

POST runtime/process-instances/{processInstanceId}/identitylinks

Table 15.72.为流程实例添加一个参与者 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	关联的流程实例 id。

请求体：

{
  "userId":"kermit",
  "type":"participant"
}

userId 和 type 都是必填项。

Table 15.73.为流程实例添加一个参与者 - 响应码

响应码	描述
201	表示找到了流程实例，并创建了关联。
400	表示请求体没有包含 userId 或 type。
404	表示找不到请求的流程实例

成功响应体：

{
   "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
   "user":"john",
   "group":null,
   "type":"customType"
}

注意 groupId 总是 null，因为只有用户才能实际参与到流程实例中。

删除一个流程实例的参与者

DELETE runtime/process-instances/{processInstanceId}/identitylinks/users/{userId}/{type}

Table 15.74.删除一个流程实例的参与者 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	流程实例 id
userId	是	String	要删除关联的用户 id
type	是	String	删除的关联类型

Table 15.75.删除一个流程实例的参与者 - 响应码

响应码	描述
204	表示找到了流程实例，并删除了关联。响应体为空。
404	表示找不到请求的流程实例，或找不到期望删除的关联。响应状态包含了错误的详细信息。

成功响应体：

{
   "url":"http://localhost:8182/runtime/process-instances/5/identitylinks/users/john/customType",
   "user":"john",
   "group":null,
   "type":"customType"
}

注意 groupId 总是 null，因为只有用户才能实际参与到流程实例中。

列出流程实例的变量

GET runtime/process-instances/{processInstanceId}/variables

Table 15.76.列出流程实例的变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	变量对应的流程实例 id

Table 15.77.列出流程实例的变量 - 响应码

响应码	描述
200	表示找到了流程实例，并返回了变量。
404	表示找不到请求的流程实例

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   },
   {
      "name":"byteArrayProcVar",
      "type":"binary",
      "value":null,
      "valueUrl":"http://localhost:8182/runtime/process-instances/5/variables/byteArrayProcVar/data",
      "scope":"local"
   },

   ...
]

当变量为二进制或序列化类型时， valueUrl 给出了获得原始数据的 URL。如果是普通变量，变量值就会直接包含在响应中。注意只会返回 local 作用域的变量，因为流程实例变量没有 global 作用域。

获得流程实例的一个变量

GET runtime/process-instances/{processInstanceId}/variables/{variableName}

Table 15.78.获得流程实例的一个变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	变量对应的流程实例 id
variableName	是	String	获取变量的名称

Table 15.79.获得流程实例的一个变量 - 响应码

响应码	描述
200	表示找到了流程实例和变量，并返回了变量。
400	表示请求体不完全，或包含非法值。状态描述包含对应错误的详细信息。
404	表示找不到请求的流程实例，或流程实例中不包含指定名称的变量。状态描述中包含对应错误的详细信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }

创建（或更新）流程实例变量

POST runtime/process-instances/{processInstanceId}/variables

PUT runtime/process-instances/{processInstanceId}/variables

使用 POST 时，会创建所有传递的变量。如果流程实例中已经存在了其中一个变量，就会返回一个错误（409 - CONFLICT）。使用 PUT 时，流程实例中不存在的变量会被创建，已存在的变量会被更新，不会有任何错误。

Table 15.80.创建（或更新）流程实例变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	变量对应的流程实例 id

请求体：

[
   {
      "name":"intProcVar"
      "type":"integer"
      "value":123
   },

   ...
]

请求体的数组中可以包含任意多个变量。关于变量格式的更多信息可以参考 REST 变量章节。注意此处忽略作用域，流程实例只能设置 local 作用域。

Table 15.81.创建（或更新）流程实例变量 - 响应码

响应码	描述
201	表示找到了流程实例，并创建了变量。
400	表示请求体不完整，或包含非法值。状态描述包含对应错误的详细信息。
404	表示找不到请求的流程实例
409	表示找到了流程实例，但是已经存在一个相同名称的变量（只在使用 POST 方法时抛出）。可以使用更新方法替代。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   },

   ...

]

更新一个流程实例变量

PUT runtime/process-instances/{processInstanceId}/variables/{variableName}

Table 15.82.更新一个流程实例变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	变量对应的流程实例 id
variableName	是	String	希望获得的变量名称

请求体：

 {
    "name":"intProcVar"
    "type":"integer"
    "value":123
 }

请求体的数组中可以包含任意多个变量。关于变量格式的更多信息可以参考 REST 变量章节。注意此处忽略作用域，流程实例只能设置 local 作用域。

Table 15.83.更新一个流程实例变量 - 响应码

响应码	描述
200	表示找到了流程实例和变量，并更新了变量。
404	表示找不到请求的流程实例，或找不到给定名称的流程实例变量。状态描述包含对应错误的详细信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }

创建一个新的二进制流程变量

POST runtime/process-instances/{processInstanceId}/variables

Table 15.84.创建一个新的二进制流程变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	创建新变量对应的流程实例 id

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/process-instances/123/variables/binaryVariable/data"
}

Table 15.85.创建一个新的二进制流程变量 - 响应码

响应码	描述
201	表示成功创建了变量，并返回了结果
400	表示没有提供希望创建的变量名称。状态消息包含详细信息。
404	表示找不到请求的流程实例
409	表示流程实例中已经包含了给定名称的变量。可以使用 PUT 方法来更新变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

更新一个二进制的流程实例变量

PUT runtime/process-instances/{processInstanceId}/variables

Table 15.86.更新一个二进制的流程实例变量 - URL 参数

参数	是否必须	值	描述
processInstanceId	是	String	创建新变量对应的流程实例 id

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/process-instances/123/variables/binaryVariable/data"
}

Table 15.87.更新一个二进制的流程实例变量 - 响应码

响应码	描述
200	表示成功更新了变量，并返回了结果。
400	表示未提供希望更新的变量名称。状态消息包含了详细信息。
404	表示找不到请求的流程实例 id，或找不到指定名称的流程实例变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

分支

获取一个分支

GET runtime/executions/{executionId}

Table 15.88.获取一个分支 - URL 参数

参数	是否必须	值	描述
executionId	是	String	获取分支的 id

Table 15.89.获取一个分支 - 响应码

响应码	描述
200	表示找到了分支，并成功返回。
404	表示找不到分支

成功响应体：

{
   "id":"5",
   "url":"http://localhost:8182/runtime/executions/5",
   "parentId":null,
   "parentUrl":null,
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "suspended":false,
   "activityId":null,
   "tenantId": null
}

对分支执行操作

PUT runtime/executions/{executionId}

Table 15.90.对分支执行操作 - URL 参数

参数	是否必须	值	描述
executionId	是	String	希望执行操作的分支 id

请求体（继续执行分支）：

{
  "action":"signal"
}

请求体（分支接收了信号事件）：

{
  "action":"signalEventReceived",
  "signalName":"mySignal"
  "variables": [ ... ]
}

提醒分支接收了一个信号事件，要使用一个 signalName 参数。还可以传递 variables 参数，它会在执行操作之前设置到分支中。

请求体（分支接收了消息事件）：

{
  "action":"messageEventReceived",
  "messageName":"myMessage"
  "variables": [ ... ]
}

提醒分支接收了一个消息事件，要使用一个 messageName 参数。还可以传递 variables 参数，它会在执行操作之前设置到分支中。

Table 15.91.对分支执行操作 - 响应码

响应码	描述
200	表示找到了分支，并执行了操作。
204	表示找到了分支，执行了操作，并且操作导致分支结束了。
400	表示请求的操作不合法，请求中缺少必须的参数，或传递了非法的变量。状态描述中包含了错误相关的详细信息。
404	表示找不到分支

成功响应体（当操作没有导致分支结束的情况）：

{
   "id":"5",
   "url":"http://localhost:8182/runtime/executions/5",
   "parentId":null,
   "parentUrl":null,
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "suspended":false,
   "activityId":null,
   "tenantId" : null
}

获得一个分支的所有活动节点

GET runtime/executions/{executionId}/activities

返回分支以及子分支当前所有活动的节点（递归所有下级）。

Table 15.92.获得一个分支的所有活动节点 - URL 参数

参数	是否必须	值	描述
executionId	是	String	获取节点对应的分支 id。

Table 15.93.获得一个分支的所有活动节点 - 响应码

响应码	描述
200	表示找到了分支，并返回了节点。
404	表示找不到分支

成功响应体：

[
  "userTaskForManager",
  "receiveTask"
]

获取分支列表

GET repository/executions

Table 15.94.获取分支列表 - URL 参数

参数	是否必须	值	描述
id	否	String	只返回指定 id 的分支。
processDefinitionKey	否	String	只返回指定流程定义 key 的分支。
processDefinitionId	否	String	只返回指定流程定义 id 的分支。
processInstanceId	否	String	只返回作为指定流程实例 id 一部分的分支。
messageEventSubscriptionName	否	String	只返回订阅了指定名称消息的分支。
signalEventSubscriptionName	否	String	只返回订阅了指定名称信号的分支。
parentId	否	String	只返回指定分支直接下级的分支。
tenantId	否	String	只返回指定 tenantId 的分支。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的分支。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的分支。如果为 `false` ，会忽略 `withoutTenantId` 参数。
sort	否	String	排序字段，应该和 `processInstanceId` （默认）， `processDefinitionId` ， `processDefinitionKey` 或 `tenantId` 之一一起使用。
可以使用通用的分页和排序查询参数。

Table 15.95.获取分支列表 - 响应码

响应码	描述
200	表示请求成功，并返回了分支。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
   "data":[
      {
         "id":"5",
         "url":"http://localhost:8182/runtime/executions/5",
         "parentId":null,
         "parentUrl":null,
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":null,
                 "tenantId":null
      },
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/executions/7",
         "parentId":"5",
         "parentUrl":"http://localhost:8182/runtime/executions/5",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":"processTask",
                 "tenantId":null
      }
   ],
   "total":2,
   "start":0,
   "sort":"processInstanceId",
   "order":"asc",
   "size":2
}

查询分支

POST query/executions

请求体：

{
  "processDefinitionKey":"oneTaskProcess",
  "variables":
  [
    {
        "name" : "myVariable",
        "value" : 1234,
        "operation" : "equals",
        "type" : "long"
    },
    ...
  ],
  "processInstanceVariables":
  [
    {
        "name" : "processVariable",
        "value" : "some string",
        "operation" : "equals",
        "type" : "string"
    },
    ...
  ],
  ...
}

请求体可以包含在获取分支列表中可以使用的查询条件。除此之外，也可以在查询中提供 variables 和 processInstanceVariables 列表，关于变量的格式可以参考此处。

可以使用通用的分页和排序查询参数。

Table 15.96.查询分支 - 响应码

响应码	描述
200	表示请求成功，并返回了分支。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
   "data":[
      {
         "id":"5",
         "url":"http://localhost:8182/runtime/executions/5",
         "parentId":null,
         "parentUrl":null,
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":null,
                 "tenantId":null
      },
      {
         "id":"7",
         "url":"http://localhost:8182/runtime/executions/7",
         "parentId":"5",
         "parentUrl":"http://localhost:8182/runtime/executions/5",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "suspended":false,
         "activityId":"processTask",
                 "tenantId":null
      }
   ],
   "total":2,
   "start":0,
   "sort":"processInstanceId",
   "order":"asc",
   "size":2
}

获取分支的变量列表

GET runtime/executions/{executionId}/variables?scope={scope}

Table 15.97.获取分支的变量列表 - URL 参数

参数	是否必须	值	描述
executionId	是	String	变量对应的分支 id。
scope	否	String	`local` 或 `global` 。如果忽略，会返回 local 和 global 作用域下的所有变量。

Table 15.98.获取分支的变量列表 - 响应码

响应码	描述
200	表示找到了分支，并返回了变量。
404	表示找不到请求的分支。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"global"
   },
   {
      "name":"byteArrayProcVar",
      "type":"binary",
      "value":null,
      "valueUrl":"http://localhost:8182/runtime/process-instances/5/variables/byteArrayProcVar/data",
      "scope":"local"
   },

   ...
]

当变量为二进制或序列化类型时， valueUrl 给出了获得原始数据的 URL。如果是普通变量，变量值就会直接包含在响应中。

获得分支的一个变量

GET runtime/executions/{executionId}/variables/{variableName}?scope={scope}

Table 15.99.获得分支的一个变量 - URL 参数

参数	是否必须	值	描述
executionId	是	String	变量对应的分支 id
variableName	是	String	获取的变量名称。
scope	否	String	`local` 或 `global` 。如果忽略，返回 local 变量（如果存在）。如果不存在局部变量，返回 global 变量（如果存在）。

Table 15.100.获得分支的一个变量 - 响应码

响应码	描述
200	表示找到了分支和变量，并返回了变量。
400	表示请求体不完全，或包含非法数值。状态描述中包含了错误相关的详细信息。
404	表示找不到请求的分支，或分支在请求作用域中不包含指定名称的变量（如果忽略 scope 参数，既不存在 local 变量也不存在 global 变量）。状态描述中包含了错误相关的详细信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   }

当变量为二进制或序列化类型时， valueUrl 给出了获得原始数据的 URL。如果是普通变量，变量值就会直接包含在响应中。

新建（或更新）分支变量

POST runtime/executions/{executionId}/variables

PUT runtime/executions/{executionId}/variables

Table 15.101.新建（或更新）分支变量 - URL 参数

参数	是否必须	值	描述
executionId	是	String	变量对应的分支 id

请求体：

[
   {
      "name":"intProcVar"
      "type":"integer"
      "value":123,
      "scope":"local"
   },

   ...
]

注意你只能提供作用域相同的变量。如果请求体数组中包含了不同作用域的变量，请求会返回一个错误（400 - BAD REQUEST）。请求体数据中可以传递任意个数的变量。关于变量格式的详细信息可以参考 REST 变量章节。注意，如果忽略了作用域，只有 local 作用域的比那两可以设置到流程实例中。

Table 15.102.新建（或更新）分支变量 - 响应码

响应码	描述
201	表示找到了分支，并成功创建了变量。
400	表示请求体不完全或包含了非法数据。状态描述中包含了错误相关的详细信息。
404	表示找不到请求的分支。
409	表示找到了流程实例，但是已经存在一个相同名称的变量（只在使用 POST 方法时抛出）。可以使用更新方法替代。

成功响应体：

[
   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"local"
   },

   ...

]

更新分支变量

PUT runtime/executions/{executionId}/variables/{variableName}

Table 15.103.更新分支变量 - URL 参数

参数	是否必须	值	描述
executionId	是	String	希望更新的变量对应的分支 id。
variableName	是	String	希望更新的变量名称。

请求体：

 {
    "name":"intProcVar"
    "type":"integer"
    "value":123,
    "scope":"global"
 }

关于变量格式的详细信息可以参考 REST 变量章节。

Table 15.104.更新分支变量 - 响应码

响应码	描述
200	表示找到了分支和变量，并成功更新了变量。
404	表示找不到请求的分支，或分支不包含指定名称的变量。状态描述中包含了错误相关的详细信息。

成功响应体：

   {
      "name":"intProcVar",
      "type":"integer",
      "value":123,
      "scope":"global"
   }

当变量为二进制或序列化类型时， valueUrl 给出了获得原始数据的 URL。如果是普通变量，变量值就会直接包含在响应中。

创建一个二进制变量

POST runtime/executions/{executionId}/variables

Table 15.105.创建一个二进制变量 - URL 参数

参数	是否必须	值	描述
executionId	是	String	希望创建的新变量对应的分支 id。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/executions/123/variables/binaryVariable/data"
}

Table 15.106.创建一个二进制变量 - 响应码

响应码	描述
201	表示成功创建了变量，并返回了结果。
400	表示没有提供希望创建的变量名称。状态信息包含了详细信息。
404	表示找不到请求的分支。
409	表示分支已经拥有了一个与指定名称相关的变量。使用 PUT 方法来代替更新分支变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

更新已经已存在的二进制分支变量

PUT runtime/executions/{executionId}/variables/{variableName}

Table 15.107.更新已经已存在的二进制分支变量 - URL 参数

参数	是否必须	值	描述
executionId	是	String	希望更新的变量对应的分支 id。
variableName	是	String	希望更新的变量名称。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。
scope ：创建的变量作用于。如果忽略，假设是 local 。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/executions/123/variables/binaryVariable/data"
}

Table 15.108.更新已经已存在的二进制分支变量 - 响应码

响应码	描述
200	表示变量已成功工薪，并返回了结果。
400	表示没有提供希望更新的变量名称。状态信息包含了详细信息。
404	表示没有找到分支，或分支不包含指定名称的变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

任务

获取任务

GET runtime/tasks/{taskId}

Table 15.109.获取任务 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望获得的任务 id。

Table 15.110.获取任务 - 响应码

响应码	描述
200	表示找到了任务并返回。
404	表示找不到任务。

成功响应体：

{
  "assignee" : "kermit",
  "createTime" : "2013-04-17T10:17:43.902+0000",
  "delegationState" : "pending",
  "description" : "Task description",
  "dueDate" : "2013-04-17T10:17:43.902+0000",
  "execution" : "http://localhost:8182/runtime/executions/5",
  "id" : "8",
  "name" : "My task",
  "owner" : "owner",
  "parentTask" : "http://localhost:8182/runtime/tasks/9",
  "priority" : 50,
  "processDefinition" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "processInstance" : "http://localhost:8182/runtime/process-instances/5",
  "suspended" : false,
  "taskDefinitionKey" : "theTask",
  "url" : "http://localhost:8182/runtime/tasks/8",
  "tenantId" : null
}

delegationState ：任务的代理状态。可以为 null ， "pending" 或 "resolved" 。

任务列表

GET runtime/tasks

Table 15.111.任务列表 - URL 参数

参数	是否必须	值	描述
name	否	String	只返回指定的名称。
nameLike	否	String	只返回与指定名称匹配的任务。
description	否	String	只返回指定描述的任务。
priority	否	Integer	只返回指定优先级的任务。
minimumPriority	否	Integer	只返回比指定优先级大的任务。
maximumPriority	否	Integer	只返回比指定优先级小的任务。
assignee	否	String	只返回分配给指定用户的任务。
assigneeLike	否	String	只返回负责人与指定值匹配的任务。
owner	否	String	只返回原拥有人为指定用户的任务。
ownerLike	否	String	只返回原拥有人与指定值匹配的任务。
unassigned	否	Boolean	只返回没有分配给任何人的任务。如果传递 `false` ，这个值就会被忽略。
delegationState	否	String	只返回指定代理状态的任务。可选值为 `pending` 和 `resolved` 。
candidateUser	否	String	只返回可以被指定用户领取的任务。这包含将用户设置为直接候选人和用户作为候选群组一员的情况。
candidateGroup	否	String	只返回可以被指定群组中用户领取的任务。
involvedUser	否	String	只返回指定用户参与过的任务。
taskDefinitionKey	否	String	只返回指定任务定义 id 的任务。
taskDefinitionKeyLike	否	String	只返回任务定义 id 与指定值匹配的任务。
processInstanceId	否	String	只返回作为指定 id 的流程实例的一部分的任务。
processInstanceBusinessKey	否	String	只返回作为指定 key 的流程实例的一部分的任务。
processInstanceBusinessKeyLike	否	String	只返回业务 key 与指定值匹配的流程实例的一部分的任务。
processDefinitionKey	否	String	只返回作为指定流程定义 key 的流程实例的一部分的任务。
processDefinitionKeyLike	否	String	只返回指定流程定义 key 与指定值匹配的流程实例的一部分的任务。
processDefinitionName	否	String	只返回作为指定流程定义名称的流程实例的一部分的任务。
processDefinitionNameLike	否	String	只返回流程定义名称与指定值匹配的流程实例的一部分的任务。
executionId	否	String	只返回作为指定 id 分支的一部分的任务。
createdOn	否	ISO Date	只返回指定创建时间的任务。
createdBefore	否	ISO Date	只返回在指定时间之前创建的任务。
createdAfter	否	ISO Date	只返回在指定时间之后创建的任务。
dueOn	否	ISO Date	只返回指定持续时间的任务。
dueBefore	否	ISO Date	只返回持续时间在指定时间之前的任务。
dueAfter	否	ISO Date	只返回持续时间在指定时间之后的任务。
withoutDueDate	否	boolean	只返回没有设置持续时间的任务。如果值为 `false` 就会忽略这个属性。
excludeSubTasks	否	Boolean	只返回非子任务的任务。
active	否	Boolean	如果为 `true` ，只返回未挂起的任务（作为未挂起流程的一部分，或者不属于任何流程）。如果为 false，只返回作为挂起流程一部分的任务。
includeTaskLocalVariables	否	Boolean	Indication to include task local variables in the result.
includeProcessVariables	否	Boolean	表示在结果中包含变量。
tenantId	否	String	只返回指定 tenantId 的任务。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的任务。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的任务。如果为 `false` ，会忽略 `withoutTenantId` 参数。
可以使用通用的分页和排序查询参数。

Table 15.112.任务列表 - 响应码

响应码	描述
200	表示请求成功，并返回任务。
400	表示传递的参数格式错误，或'delegationState'使用了不合法的数据('pending' 和 'resolved'以外的数据)。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "assignee" : "kermit",
      "createTime" : "2013-04-17T10:17:43.902+0000",
      "delegationState" : "pending",
      "description" : "Task description",
      "dueDate" : "2013-04-17T10:17:43.902+0000",
      "execution" : "http://localhost:8182/runtime/executions/5",
      "id" : "8",
      "name" : "My task",
      "owner" : "owner",
      "parentTask" : "http://localhost:8182/runtime/tasks/9",
      "priority" : 50,
      "processDefinition" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstance" : "http://localhost:8182/runtime/process-instances/5",
      "suspended" : false,
      "taskDefinitionKey" : "theTask",
      "url" : "http://localhost:8182/runtime/tasks/8",
          "tenantId" : null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询任务

POST query/tasks

请求体：

{
  "name" : "My task",
  "description" : "The task description",

  ...

  "taskVariables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ],

    "processInstanceVariables" : [
      {
         ...
      }
    ]
  ]
}

此处所有被支持的 JSON 参数都和获得任务集合完全一样，只是使用 JSON 体参数的方式替代 URL 参数，这样就可以使用更加高级的查询方式，并能预防请求 uri 过长导致的问题。除此之外，可以基于任务和流程变量进行查询。 taskVariables 和 processInstanceVariables 都可以包含此处描述的 json 数组。

Table 15.113.查询任务 - 响应码

响应码	描述
200	表示请求成功，并返回任务。
400	表示传递了格式错误的参数，或'delegationState'传递了非法数据 ( 'pending' 和 'resolved'之外的值)。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "assignee" : "kermit",
      "createTime" : "2013-04-17T10:17:43.902+0000",
      "delegationState" : "pending",
      "description" : "Task description",
      "dueDate" : "2013-04-17T10:17:43.902+0000",
      "execution" : "http://localhost:8182/runtime/executions/5",
      "id" : "8",
      "name" : "My task",
      "owner" : "owner",
      "parentTask" : "http://localhost:8182/runtime/tasks/9",
      "priority" : 50,
      "processDefinition" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstance" : "http://localhost:8182/runtime/process-instances/5",
      "suspended" : false,
      "taskDefinitionKey" : "theTask",
      "url" : "http://localhost:8182/runtime/tasks/8",
          "tenantId" : null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

更新任务

PUT runtime/tasks/{taskId}

请求 JSON 体：

{
  "assignee" : "assignee",
  "delegationState" : "resolved",
  "description" : "New task description",
  "dueDate" : "2013-04-17T13:06:02.438+02:00",
  "name" : "New task name",
  "owner" : "owner",
  "parentTaskId" : "3",
  "priority" : 20
}

所有请求参数都是可选的。比如，你可以在请求体的 JSON 对象中只包含'assignee'属性，只更新任务的负责人，其他字段都不填。当包含的字段值为 null 时，任务的对应属性会被更新为 null。比如： {"dueDate" : null} 会清空任务的持续时间。

Table 15.114.更新任务 - 响应码

响应码	描述
200	表示成功更新了任务。
404	表示找不到任务。
409	表示请求的任务正在被更新。

成功响应体： 参考 runtime/tasks/{taskId} 的响应。

操作任务

POST runtime/tasks/{taskId}

完成任务 - JSON 体：

{
  "action" : "complete",
  "variables" : ...
}

完成任务。可以使用 variables 参数传递可选的 variable 数组。关于变量格式的详细信息可以参考 REST 变量章节。注意，此处忽略变量作用域，变量会设置到上级作用域，除非本地作用域应包含了同名变量。这与 TaskService.completeTask(taskId, variables) 的行为是相同的。

认领任务 - JSON 体：

{
  "action" : "claim",
  "assignee" : "userWhoClaims"
}

根据指定的 assignee 认领任务。如果 assignee 为 null ，任务的执行人会变成空，又可以重新认领了。

代理任务 - JSON 体：

{
  "action" : "delegate",
  "assignee" : "userToDelegateTo"
}

指定 assignee 代理任务。assignee 是必填项。

处理任务 - JSON 体：

{
  "action" : "resolve"
}

处理任务代理。任务会返回给任务的原负责人（如果存在）。

Table 15.115.操作任务 - 响应码

响应码	描述
200	表示操作成功执行。
400	当请求包含了非法数据或当操作需要 assignee 参数时，却没有传。
404	表示找不到任务。
409	表示因为冲突导致无法执行操作。可能任务正在被更新，或者，在' `claim` '认清任务时，任务已经被其他用户认领了。

成功响应体： 参考 runtime/tasks/{taskId} 的响应。

删除任务

DELETE runtime/tasks/{taskId}?cascadeHistory={cascadeHistory}&deleteReason={deleteReason}

Table 15.116.>删除任务 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望删除的任务 id。
cascadeHistory	False	Boolean	删除任务时是否删除对应的任务历史（如果存在）。如果没有设置这个参数，默认为 false。
deleteReason	False	String	删除任务的原因。 `cascadeHistory` 为 true 时，忽略此参数。

Table 15.117.>删除任务 - 响应码

响应码	描述
204	表示找到任务，并成功删除。响应体为空。
403	表示无法删除任务，因为它是流程的一部分。
404	表示找不到任务。

获得任务的变量

GET runtime/tasks/{taskId}/variables?scope={scope}

Table 15.118.获得任务的变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	变量对应的任务 id。
scope	False	String	返回的变量作用于。如果为 ' `local` '，只返回任务本身的变量。如果为 ' `global` '，只返回任务上级分支的变量。如果不指定这个变量，会返回所有局部和全局的变量。

Table 15.119.获得任务的变量 - 响应码

响应码	描述
200	表示找到了任务并返回了请求的变量。
404	表示找不到任务。

成功响应体：

[
  {
    "name" : "doubleTaskVar",
    "scope" : "local",
    "type" : "double",
    "value" : 99.99
  },
  {
    "name" : "stringProcVar",
    "scope" : "global",
    "type" : "string",
    "value" : "This is a ProcVariable"
  },

  ...

]

返回 JSON 数组型的变量。对响应的详细介绍可以参考 REST 变量章节。

获取任务的一个变量

GET runtime/tasks/{taskId}/variables/{variableName}?scope={scope}

Table 15.120.获取任务的一个变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取变量对应的任务 id。
variableName	是	String	获取变量对应的名称。
scope	False	String	返回的变量作用于。如果为 ' `local` '，只返回任务本身的变量。如果为 ' `global` '，只返回任务上级分支的变量。如果不指定这个变量，会返回所有局部和全局的变量。

Table 15.121.获取任务的一个变量 - 响应码

响应码	描述
200	表示找到了任务并返回了请求的变量。
404	表示找不到任务，或者任务不包含指定名称的变量（在指定作用域下）。状态信息包含了详细信息。

成功响应体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}

对响应的详细介绍可以参考 REST 变量章节。

获取变量的二进制数据

GET runtime/tasks/{taskId}/variables/{variableName}/data?scope={scope}

Table 15.122.获取变量的二进制数据 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取变量数据对应的任务 id。
variableName	是	String	获取数据对应的变量名称。只能使用 `binary` 和 `serializable` 类型的变量。如果使用了其他类型的变量，会返回 `404` 。
scope	False	String	返回的变量作用于。如果为 ' `local` '，只返回任务本身的变量。如果为 ' `global` '，只返回任务上级分支的变量。如果不指定这个变量，会返回所有局部和全局的变量。

Table 15.123.获取变量的二进制数据 - 响应码

响应码	描述
200	表示找到了任务并返回了请求的变量。
404	表示找不到任务，或者任务不包含指定名称的变量（在指定作用域下），或变量的二进制流不可用。状态信息包含了详细信息。

成功响应体： 响应体包含了变量的二进制值。当类型为 binary 时，无论请求的 accept-type 头部设置了什么值，响应的 content-type 都为 application/octet-stream 。当类型为 serializable 时， content-type 为 application/x-java-serialized-object 。

创建任务变量

POST runtime/tasks/{taskId}/variables

Table 15.124.创建任务变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	创建新变量对应的任务 id。

创建简单（非二进制）变量的请求体：

[
  {
    "name" : "myTaskVariable",
    "scope" : "local",
    "type" : "string",
    "value" : "Hello my friend"
  },
  {
    ...
  }
]

请求体应该是包含一个或多个 JSON 对象的数组，对应应该创建的变量。

name ：必须的变量名称。
scope :创建的变量的作用域。如果忽略，假设为 local 。
type ：创建的变量的类型。如果忽略，转换为对应的 JSON 的类型 (string, boolean, integer 或 double)。
value ：变量值。

关于变量格式的详细信息可以参考 REST 变量章节。

成功响应体：

[
  {
    "name" : "myTaskVariable",
    "scope" : "local",
    "type" : "string",
    "value" : "Hello my friend"
  },
  {
    ...
  }
]

Table 15.125.创建任务变量 - 响应码

响应码	描述
201	表示创建了变量，并返回了结果。
400	表示没有传变量名，或尝试使用 `global` 作用域为独立任务（没有关联到流程）创建变量，或请求中的变量为空，或请求没有包含变量数组。状态信息包含了详细信息。
404	表示找不到任务。
409	表示任务已经存在指定名称的变量了。可以使用 PUT 方法来更新任务变量。

创建二进制任务变量

POST runtime/tasks/{taskId}/variables

Table 15.126.创建二进制任务变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	创建新变量对应的任务 id。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
scope ：创建的变量的作用域。如果忽略，假设使用 local 。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/tasks/123/variables/binaryVariable/data"
}

Table 15.127.创建二进制任务变量 - 响应码

响应码	描述
201	表示创建了变量，并返回了结果。
400	表示没有传变量名，或尝试使用 `global` 作用域为独立任务（没有关联到流程）创建变量。状态信息包含了详细信息。
404	表示找不到任务。
409	表示任务已经存在指定名称的变量了。可以使用 PUT 方法来更新任务变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

更新任务的一个已有变量

PUT runtime/tasks/{taskId}/variables/{variableName}

Table 15.128.更新任务的一个已有变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望更新的变量对应的任务 id。
variableName	是	String	希望更新的变量名称。

更新简单（非二进制）变量的请求体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}

name ：必须的变量名称。
scope ：更新的变量的作用域。如果忽略，假设为 local 。
type ：更新的变量的类型。如果忽略，转换为对应的 JSON 的类型 (string, boolean, integer 或 double)。
value ：变量值。

关于变量格式的详细信息可以参考 REST 变量章节。

成功响应体：

{
  "name" : "myTaskVariable",
  "scope" : "local",
  "type" : "string",
  "value" : "Hello my friend"
}

Table 15.129.更新任务的一个已有变量 - 响应码

响应码	描述
200	表示成功更新了变量并返回了结果。
400	表示没有传变量名，或尝试使用 `global` 作用域为独立任务（没有关联到流程）创建变量。状态信息包含了详细信息。
404	表示找不到任务，或任务在指定作用域不包含指定名称的变量。状态信息包含错误的详细信息。

更新一个二进制任务变量

PUT runtime/tasks/{taskId}/variables/{variableName}

Table 15.130.更新一个二进制任务变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望更新的变量对应的任务 id。
variableName	是	String	希望更新的变量名称。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
scope ：创建的变量的作用域。如果忽略，假设使用 local 。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
  "name" : "binaryVariable",
  "scope" : "local",
  "type" : "binary",
  "value" : null,
  "valueUrl" : "http://.../runtime/tasks/123/variables/binaryVariable/data"
}

Table 15.131.更新一个二进制任务变量 - 响应码

响应码	描述
200	表示更新了变量，并返回了结果。
400	表示没有传变量名，或尝试使用 `global` 作用域为独立任务（没有关联到流程）创建变量。状态信息包含了详细信息。
404	表示找不到任务，或任务在指定作用域不包含指定名称的变量。
415	表示序列化数据包含的对象的类并不在运行 Activiti 引擎的 JVM 中，所以无法反序列化。

删除任务变量

DELETE runtime/tasks/{taskId}/variables/{variableName}?scope={scope}

Table 15.132.删除任务变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望删除的变量对应的任务 id。
variableName	是	String	希望删除的变量名称。
scope	否	String	希望删除的变量的作用域。可以是 `local` 或 `global` 。如果忽略，假设为 `local` 。

Table 15.133.删除任务变量 - 响应码

响应码	描述
204	表示找到了任务变量，并成功删除。响应体为空。
404	表示找不到任务，或任务不包含指定名称的变量。状态信息包含错误的详细信息。

删除任务的所有局部变量

DELETE runtime/tasks/{taskId}/variables

Table 15.134.删除任务的所有局部变量 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望删除的变量对应的任务 id。

Table 15.135.删除任务的所有局部变量 - 响应码

响应码	描述
204	表示已经删除了任务的所有局部变量。响应体为空。
404	表示找不到任务。

获得任务的所有 IdentityLink

GET runtime/tasks/{taskId}/identitylinks

Table 15.136.获得任务的所有 IdentityLink - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望获得 IdentityLink 对应的任务 id。

Table 15.137.获得任务的所有 IdentityLink - 响应码

响应码	描述
200	表示找到了任务，并返回了 IdentityLink。
404	表示找不到任务。

成功响应体：

[
  {
    "userId" : "kermit",
    "groupId" : null,
    "type" : "candidate",
    "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/identitylinks/users/kermit/candidate"
  },
  {
    "userId" : null,
    "groupId" : "sales",
    "type" : "candidate",
    "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
  },

  ...
]

获得一个任务的所有组或用户的 IdentityLink

GET runtime/tasks/{taskId}/identitylinks/users
GET runtime/tasks/{taskId}/identitylinks/groups

返回对应于用户或组的 IdentityLink。响应体与状态码与获得一个任务的所有 IdentityLink 完全一样。

获得一个任务的一个 IdentityLink

GET runtime/tasks/{taskId}/identitylinks/{family}/{identityId}/{type}

Table 15.138.获得一个任务的所有组或用户的 IdentityLink - URL 参数

参数	是否必填	数据	描述
taskId	是	String	任务的 id。
family	是	String	`groups` 或 `users` ，对应期望获得哪种 IdentityLink。
identityId	是	String	IdentityLink 的 id。
type	是	String	IdentityLink 的类型。

Table 15.139.获得一个任务的所有组或用户的 IdentityLink - 响应码

响应码	描述
200	表示找到了任务和 IdentityLink，并成功返回。
404	表示找不到任务，或任务不包含请求的 IdentityLink。状态包含了错误的详细信息。

成功响应体：

{
  "userId" : null,
  "groupId" : "sales",
  "type" : "candidate",
  "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
}

为任务创建一个 IdentityLink

POST runtime/tasks/{taskId}/identitylinks

Table 15.140.为任务创建一个 IdentityLink - URL 参数

参数	是否必填	数据	描述
taskId	是	String	任务的 id。

请求体（用户）：

{
  "userId" : "kermit",
  "type" : "candidate",
}

请求体（组）：

{
  "groupId" : "sales",
  "type" : "candidate",
}

Table 15.141.为任务创建一个 IdentityLink - 响应码

响应码	描述
201	表示找到了任务，并创建了 IdentityLink。
404	表示找不到任务，或任务不包含请求的 IdentityLink。状态包含了错误的详细信息。

成功响应体：

{
  "userId" : null,
  "groupId" : "sales",
  "type" : "candidate",
  "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/identitylinks/groups/sales/candidate"
}

删除任务的一个 IdentityLink

DELETE runtime/tasks/{taskId}/identitylinks/{family}/{identityId}/{type}

Table 15.142.删除任务的一个 IdentityLink - URL 参数

参数	是否必填	数据	描述
taskId	是	String	任务的 id。
family	是	String	`groups` 或 `users` ，对应 IdentityLink 的种类。
identityId	是	String	IdentityLink 的 id。
type	是	String	IdentityLink 的类型。

Table 15.143.删除任务的一个 IdentityLink - 响应码

响应码	描述
204	表示找到了任务和 IdentityLInk，并成功删除了 IdentityLink。响应体为空。
404	表示找不到任务，或任务不包含请求的 IdentityLink。状态包含了错误的详细信息。

为任务创建评论

POST runtime/tasks/{taskId}/comments

Table 15.144.为任务创建评论 - URL 参数

参数	是否必须	值	描述
taskId	是	String	创建评论对应的任务 id。

请求体：

{
  "message" : "This is a comment on the task."
}

成功响应体：

{
  "id" : "123",
  "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/comments/123",
  "message" : "This is a comment on the task.",
  "author" : "kermit"
}

Table 15.145.为任务创建评论 - 响应码

响应码	描述
201	表示创建了评论，并返回了结果。
400	表示请求不包含评论。
404	表示找不到任务。

获得任务的所有评论

GET runtime/tasks/{taskId}/comments

Table 15.146.获得任务的所有评论 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取评论对应的任务 id。

成功响应体：

[
  {
    "id" : "123",
    "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/comments/123",
    "message" : "This is a comment on the task.",
    "author" : "kermit"
  },
  {
    "id" : "456",
    "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/comments/456",
    "message" : "This is another comment on the task.",
    "author" : "gonzo"
  }
]

Table 15.147.获得任务的所有评论 - 响应码

响应码	描述
200	表示找到了任务，并返回了评论。
404	表示找不到任务。

获得任务的一个评论

GET runtime/tasks/{taskId}/comments/{commentId}

Table 15.148.获得任务的一个评论 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取评论对应的任务 id。
commentId	是	String	评论的 id。

成功响应体：

{
  "id" : "123",
  "url" : "http://localhost:8081/activiti-rest/service/runtime/tasks/100/comments/123",
  "message" : "This is a comment on the task.",
  "author" : "kermit"
}

Table 15.149.获得任务的一个评论 - 响应码

响应码	描述
200	表示找到了任务和评论，并返回了评论。
404	表示找不到任务，或任务不包含指定 id 的评论。

删除任务的一条评论

DELETE runtime/tasks/{taskId}/comments/{commentId}

Table 15.150.删除任务的一条评论 - URL 参数

参数	是否必须	值	描述
taskId	是	String	删除评论对应的任务 id。
commentId	是	String	评论的 id。

Table 15.151.删除任务的一条评论 - 响应码

响应码	描述
204	表示找到了任务和评论，并删除了评论。响应体为空。
404	表示找不到任务，或任务不包含 id 的评论。

获得任务的所有事件

GET runtime/tasks/{taskId}/events

Table 15.152.获得任务的所有事件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获得事件对应的任务 id。

成功响应体：

[
  {
    "action" : "AddUserLink",
    "id" : "4",
    "message" : [ "gonzo", "contributor" ],
    "taskUrl" : "http://localhost:8182/runtime/tasks/2",
    "time" : "2013-05-17T11:50:50.000+0000",
    "url" : "http://localhost:8182/runtime/tasks/2/events/4",
    "userId" : null
  },

  ...

]

Table 15.153.获得任务的所有事件 - 响应码

响应码	描述
200	表示找到了任务，并返回了事件。
404	表示找不到任务。

获得任务的一个事件

GET runtime/tasks/{taskId}/events/{eventId}

Table 15.154.获得任务的一个事件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获得事件对应的任务 id。
eventId	是	String	事件的 id。

成功响应体：

{
  "action" : "AddUserLink",
  "id" : "4",
  "message" : [ "gonzo", "contributor" ],
  "taskUrl" : "http://localhost:8182/runtime/tasks/2",
  "time" : "2013-05-17T11:50:50.000+0000",
  "url" : "http://localhost:8182/runtime/tasks/2/events/4",
  "userId" : null
}

Table 15.155.获得任务的一个事件 - 响应码

响应码	描述
200	表示找到了任务和事件，并返回了事件。
404	表示找不到任务，或任务不包含对应 id 的事件。

为任务创建一个附件，包含外部资源的链接

POST runtime/tasks/{taskId}/attachments

Table 15.156.为任务创建一个附件，包含外部资源的链接 - URL 参数

参数	是否必须	值	描述
taskId	是	String	创建附件对应的任务 id。

请求体：

{
  "name":"Simple attachment",
  "description":"Simple attachment description",
  "type":"simpleType",
  "externalUrl":"http://activiti.org"
}

创建附件只有 name 是必填的。

成功响应体：

{
  "id":"3",
  "url":"http://localhost:8182/runtime/tasks/2/attachments/3",
  "name":"Simple attachment",
  "description":"Simple attachment description",
  "type":"simpleType",
  "taskUrl":"http://localhost:8182/runtime/tasks/2",
  "processInstanceUrl":null,
  "externalUrl":"http://activiti.org",
  "contentUrl":null
}

Table 15.157.为任务创建一个附件，包含外部资源的链接 - 响应码

响应码	描述
201	表示创建了附件，并返回了结果。
400	表示请求中缺少了附件名称。
404	表示找不到任务。

为任务创建一个附件，包含附件文件

POST runtime/tasks/{taskId}/attachments

Table 15.158.为任务创建一个附件，包含附件文件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	创建附件对应的任务 id。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

name ：必须的变量名称。
description ：附件的描述，可选。
type ：创建的变量类型。如果忽略，会假设使用 binary ，请求的二进制数据会当做二进制数组保存起来。

成功响应体：

{
      "id":"5",
      "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
      "name":"Binary attachment",
      "description":"Binary attachment description",
      "type":"binaryType",
      "taskUrl":"http://localhost:8182/runtime/tasks/2",
      "processInstanceUrl":null,
      "externalUrl":null,
      "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
   }

Table 15.159.为任务创建一个附件，包含附件文件 - 响应码

响应码	描述
201	表示创建了附件，并返回了结果。
400	表示请求中缺少附件名称，或请求中未包含文件。错误信息中包含了详细信息。
404	表示找不到任务。

获得任务的所有附件

GET runtime/tasks/{taskId}/attachments

Table 15.160.获得任务的所有附件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取附件对应的任务 id。

成功响应体：

[
  {
    "id":"3",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/3",
    "name":"Simple attachment",
    "description":"Simple attachment description",
    "type":"simpleType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":"http://activiti.org",
    "contentUrl":null
  },
  {
    "id":"5",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
    "name":"Binary attachment",
    "description":"Binary attachment description",
    "type":"binaryType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":null,
    "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
  }
]

Table 15.161.获得任务的所有附件 - 响应码

响应码	描述
200	表示找到了任务，并返回了附件。
404	表示找不到任务。

获得任务的一个附件

GET runtime/tasks/{taskId}/attachments/{attachmentId}

Table 15.162.获得任务的一个附件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取附件对应的任务 id。
attachmentId	是	String	附件的 id。

成功响应体：

  {
    "id":"5",
    "url":"http://localhost:8182/runtime/tasks/2/attachments/5",
    "name":"Binary attachment",
    "description":"Binary attachment description",
    "type":"binaryType",
    "taskUrl":"http://localhost:8182/runtime/tasks/2",
    "processInstanceUrl":null,
    "externalUrl":null,
    "contentUrl":"http://localhost:8182/runtime/tasks/2/attachments/5/content"
  }

externalUrl - contentUrl： 如果附件是一个外部资源链接， externalUrl 包含外部内容的 URL。如果附件内容保存在 Activiti 引擎中， contentUrl 会包含获取二进制流内容的 URL。
type： 可以是任何有效值。包含一个格式合法的 media-type 时（比如 application/xml, text/plain），二进制 HTTP 响应的 content-type 会被设置为对应值。

Table 15.163.获得任务的一个附件 - 响应码

响应码	描述
200	表示找到了任务和附件，并返回了附件。
404	表示找不到任务，或任务不包含对应 id 的附件。

获取附件的内容

GET runtime/tasks/{taskId}/attachment/{attachmentId}/content

Table 15.164.获取附件的内容 - URL 参数

参数	是否必须	值	描述
taskId	是	String	获取附件数据对应的任务 id。
attachmentId	是	String	附件的 id，当附件指向外部 URL，而不是 Activiti 中的内容，就会返回 `404` 。

Table 15.165.获取附件的内容 - 响应码

响应码	描述
200	表示找到了任务和附件，并返回了请求的内容。
404	表示找不到任务，或任务不包含对应 id 的任务，或附件不包含二进制流。状态信息包含了详细信息。

成功响应体： 响应体包含了二进制内容。默认，响应的 content-type 设置为 application/octet-stream ，除非附件类型包含了合法的 Content-Type。

删除任务的一个附件

DELETE runtime/tasks/{taskId}/attachments/{attachmentId}

Table 15.166.删除任务的一个附件 - URL 参数

参数	是否必须	值	描述
taskId	是	String	希望删除附件对应的任务 id。
attachmentId	是	String	附件的 id。

Table 15.167.删除任务的一个附件 - 响应码

响应码	描述
204	表示找到了任务和附件，并删除了附件。响应体为空。
404	表示找不到任务，或任务不包含对应 id 的附件。

历史

获得历史流程实例

GET history/historic-process-instances/{processInstanceId}

Table 15.168.获得历史流程实例 - 响应码

响应码	描述
200	表示找到了历史流程实例。
404	表示找不到历史流程实例。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "businessKey" : "myKey",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "startUserId" : "kermit",
      "startActivityId" : "startEvent",
      "endActivityId" : "endEvent",
      "deleteReason" : null,
      "superProcessInstanceId" : "3",
      "url" : "http://localhost:8182/history/historic-process-instances/5",
      "variables": null,
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

历史流程实例列表

GET history/historic-process-instances

Table 15.169.历史流程实例列表 - URL 参数

参数	是否必填	数据	描述
processInstanceId	否	String	历史流程实例 id。
processDefinitionKey	否	String	历史流程实例的流程定义 key。
processDefinitionId	否	String	历史流程实例的流程定义 id。
businessKey	否	String	历史流程实例的 businessKey。
involvedUser	否	String	历史流程实例的参与者。
finished	否	Boolean	表示历史流程实例是否结束了。
superProcessInstanceId	否	String	历史流程实例的上级流程实例 id。
excludeSubprocesses	否	Boolean	只返回非子流程的历史流程实例。
finishedAfter	否	Date	只返回指定时间之后结束的历史流程实例。
finishedBefore	否	Date	只返回指定时间之前结束的历史流程实例。
startedAfter	否	Date	只返回指定时间之后开始的历史流程实例。
startedBefore	否	Date	只返回指定时间之前开始的历史流程实例。
startedBy	否	String	只返回由指定用户启动的历史流程实例。
includeProcessVariables	否	Boolean	表示是否应该返回历史流程实例变量。
tenantId	否	String	只返回指定 tenantId 的实例。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的实例。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的实例。如果为 `false` ，会忽略 `withoutTenantId` 参数。
可以使用通用的分页和排序查询参数。

Table 15.170.历史流程实例列表 - 响应码

响应码	描述
200	表示成功返回了历史流程实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "businessKey" : "myKey",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "startUserId" : "kermit",
      "startActivityId" : "startEvent",
      "endActivityId" : "endEvent",
      "deleteReason" : null,
      "superProcessInstanceId" : "3",
      "url" : "http://localhost:8182/history/historic-process-instances/5",
      "variables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史流程实例

POST query/historic-process-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  ...

  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有支持的 JSON 参数字段和获得历史流程实例集合完全一样，但是传递的是 JSON 参数，而不是 URL 参数，这样可以支持更高级的参数，同时避免请求 uri 过长。除此之外，查询支持基于流程变量查询。 variables 属性是一个 json 数组，包含此处描述的格式。

Table 15.171.查询历史流程实例 - 响应码

响应码	描述
200	表示请求成功，并返回结果。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "businessKey" : "myKey",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "startUserId" : "kermit",
      "startActivityId" : "startEvent",
      "endActivityId" : "endEvent",
      "deleteReason" : null,
      "superProcessInstanceId" : "3",
      "url" : "http://localhost:8182/history/historic-process-instances/5",
      "variables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

删除历史流程实例

DELETE history/historic-process-instances/{processInstanceId}

Table 15.172.响应码

响应码	描述
200	表示成功删除了历史流程实例。
404	表示找不到历史流程实例。

获取历史流程实例的 IdentityLink

GET history/historic-process-instance/{processInstanceId}/identitylinks

Table 15.173.响应码

响应码	描述
200	表示请求成功，并返回了 IdentityLink。
404	表示找不到历史流程实例。

成功响应体：

[
 {
  "type" : "participant",
  "userId" : "kermit",
  "groupId" : null,
  "taskId" : null,
  "taskUrl" : null,
  "processInstanceId" : "5",
  "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5"
 }
]

获取历史流程实例变量的二进制数据

GET history/historic-process-instances/{processInstanceId}/variables/{variableName}/data

Table 15.174.获取历史流程实例变量的二进制数据 - 响应码

响应码	描述
200	表示找到了历史流程实例，并返回了请求的变量数据。
404	表示找不到请求的历史流程实例，或流程实例不包含指定名称的变量，或变量不是二进制流。状态信息包含了详细信息。

为历史流程实例创建一条新评论

POST history/historic-process-instances/{processInstanceId}/comments

Table 15.175.为历史流程实例创建一条新评论 - URL 参数

参数	必须	值	描述
processInstanceId	是	String	需要创建评论的流程实例 id。

请求体：

{
  "message" : "This is a comment."
}

成功响应体：

{
  "id" : "123",
  "url" : "http://localhost:8081/activiti-rest/history/historic-process-instances/100/comments/123",
  "message" : "This is a comment.",
  "author" : "kermit"
}

Table 15.176.为历史流程实例创建一条新评论 - 响应码

响应码	描述
201	表示创建了评论，并返回了结果。
400	表示请求中未包含评论。
404	表示找不到请求的历史流程实例。

获得一个历史流程实例的所有评论

GET history/historic-process-instances/{processInstanceId}/comments

Table 15.177.获得流程实例的所有评论 - URL 参数

参数	必填	值	描述
processInstanceId	是	String	获取评论对应的流程实例 id。

成功响应体：

[
  {
    "id" : "123",
    "url" : "http://localhost:8081/activiti-rest/service/history/historic-process-instances/100/comments/123",
    "message" : "This is a comment",
    "author" : "kermit"
  },
  {
    "id" : "456",
    "url" : "http://localhost:8081/activiti-rest/service/history/historic-process-instances/100/comments/456",
    "message" : "This is a 否 ther comment.",
    "author" : "gonzo"
  }
]

Table 15.178.获得流程实例的所有评论 - 响应码

响应码	描述
200	表示找到了流程实例，并返回了评论。
404	表示找不到请求的流程实例。

获得历史流程实例的一条评论

GET history/historic-process-instances/{processInstanceId}/comments/{commentId}

Table 15.179.获得历史流程的一条评论 - URL 参数

参数	必填	值	描述
processInstanceId	是	String	获得评论对应的历史流程实例。
commentId	Yes	String	评论的 id。

成功响应体：

{
  "id" : "123",
  "url" : "http://localhost:8081/activiti-rest/history/historic-process-instances/100/comments/123",
  "message" : "This is a comment.",
  "author" : "kermit"
}

Table 15.180.获得历史流程的一条评论 - 响应码

响应码	描述
200	表示找到了历史流程实例和评论，并返回了评论。
404	表示找不到请求的历史流程实例，或历史流程实例不包含指定 id 的评论。

删除历史流程实例的一条评论

DELETE history/historic-process-instances/{processInstanceId}/comments/{commentId}

Table 15.181.删除历史流程实例的一条评论 - URL 参数

参数	必填	值	描述
processInstanceId	是	String	需要删除的评论对应的历史流程实例的 id。
commentId	Yes	String	评论的 id。

Table 15.182.删除历史流程实例的一条评论 - 响应码

响应码	描述
204	表示找到了历史流程实例，并删除了评论。响应体为空。
404	表示找不到请求的历史流程实例，或历史流程实例不包含指定 id 的评论。

获得单独历史任务实例

GET history/historic-task-instances/{taskId}

Table 15.183.获得单独历史任务实例 - 响应码

响应码	描述
200	表示找到了历史任务实例。
404	表示找不到历史任务实例。

成功响应体：

{
  "id" : "5",
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
  "processInstanceId" : "3",
  "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
  "executionId" : "4",
  "name" : "My task name",
  "description" : "My task description",
  "deleteReason" : null,
  "owner" : "kermit",
  "assignee" : "fozzie",
  "startTime" : "2013-04-17T10:17:43.902+0000",
  "endTime" : "2013-04-18T14:06:32.715+0000",
  "durationInMillis" : 86400056,
  "workTimeInMillis" : 234890,
  "claimTime" : "2013-04-18T11:01:54.715+0000",
  "taskDefinitionKey" : "taskKey",
  "formKey" : null,
  "priority" : 50,
  "dueDate" : "2013-04-20T12:11:13.134+0000",
  "parentTaskId" : null,
  "url" : "http://localhost:8182/history/historic-task-instances/5",
  "variables": null,
  "tenantId":null
}

获取历史任务实例

GET history/historic-task-instances

Table 15.184.获取历史任务实例 - URL 参数

参数	是否必填	数据	描述
taskId	否	String	历史任务实例 id。
processInstanceId	否	String	历史任务实例的流程实例 id。
processDefinitionKey	否	String	历史任务实例的流程定义 key。
processDefinitionKeyLike	否	String	历史任务实例的流程定义 key 与指定值匹配。
processDefinitionId	否	String	历史任务实例的流程定义 id。
processDefinitionName	否	String	历史任务实例的流程定义名称。
processDefinitionNameLike	否	String	历史任务实例的流程定义名称与指定值匹配。
processBusinessKey	否	String	历史任务实例的流程实例 businessKey。
processBusinessKeyLike	否	String	历史任务实例的流程实例业务 key 与指定值匹配。
executionId	否	String	历史任务实例的分支 id。
taskDefinitionKey	否	String	流程的任务部分的流程定义 key。
taskName	否	String	历史任务实例的任务名称。
taskNameLike	否	String	对任务名称使用'like'查询历史任务实例。
taskDescription	否	String	历史任务实例的任务描述。
taskDescriptionLike	否	String	对任务描述使用'like'查询历史任务实例。
taskDefinitionKey	否	String	历史任务实例对应的流程定义的任务定义 key。
taskDeleteReason	否	String	历史任务实例的删除任务原因。
taskDeleteReasonLike	否	String	对删除任务原因使用'like'查询历史任务实例。
taskAssignee	否	String	历史任务实例的负责人。
taskAssigneeLike	否	String	对负责人使用'like'查询历史任务实例。
taskOwner	否	String	历史任务实例的原拥有者。
taskOwnerLike	否	String	对原拥有者使用'like'查询历史任务实例。
taskInvolvedUser	否	String	历史任务实例的参与者。
taskPriority	否	String	历史任务实例的优先级。
finished	否	Boolean	表示是否历史任务实例已经结束了。
processFinished	否	Boolean	表示历史任务实例的流程实例是否已经结束了。
parentTaskId	否	String	历史任务实例的可能的上级任务 id。
dueDate	否	Date	只返回指定持续时间的历史任务实例。
dueDateAfter	否	Date	只返回指定持续时间之后的历史任务实例。
dueDateBefore	否	Date	只返回指定持续时间之前的历史任务实例。
withoutDueDate	否	Boolean	只返回没有设置持续时间的历史任务实例。当设置为 `false` 时会忽略这个参数。
taskCompletedOn	否	Date	只返回在指定时间完成的历史任务实例。
taskCompletedAfter	否	Date	只返回在指定时间之后完成的历史任务实例。
taskCompletedBefore	否	Date	只返回在指定时间之前完成的历史任务实例。
taskCreatedOn	否	Date	只返回指定创建时间的历史任务实例。
taskCreatedBefore	否	Date	只返回在指定时间前创建的历史任务实例。
taskCreatedAfter	否	Date	只返回在指定时间后创建的历史任务实例。
includeTaskLocalVariables	否	Boolean	表示是否应该返回历史任务实例局部变量。
includeProcessVariables	否	Boolean	表示是否应该返回历史任务实例全局变量。
tenantId	否	String	只返回指定 tenantId 的历史任务。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的历史任务。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的历史任务。如果为 `false` ，会忽略 `withoutTenantId` 参数。
可以使用通用的分页和排序查询参数。

Table 15.185.获取历史任务实例 - 响应码

响应码	描述
200	表示可以查询的历史任务实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "name" : "My task name",
      "description" : "My task description",
      "deleteReason" : null,
      "owner" : "kermit",
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "workTimeInMillis" : 234890,
      "claimTime" : "2013-04-18T11:01:54.715+0000",
      "taskDefinitionKey" : "taskKey",
      "formKey" : null,
      "priority" : 50,
      "dueDate" : "2013-04-20T12:11:13.134+0000",
      "parentTaskId" : null,
      "url" : "http://localhost:8182/history/historic-task-instances/5",
      "taskVariables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "processVariables": [
        {
          "name": "processTest",
          "variableScope": "global",
          "value": "myProcessTest"
        }
      ],
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史任务实例

POST query/historic-task-instances

查询历史任务实例 - 请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  ...

  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有支持的 JSON 参数字段和获得历史任务实例集合完全一样，但是传递的是 JSON 参数，而不是 URL 参数，这样可以支持更高级的参数，同时避免请求 uri 过长。除此之外，查询支持基于流程变量查询。 taskVariables 和 processVariables 属性是一个 json 数组，包含此处描述的格式。

Table 15.186.查询历史任务实例 - 响应码

响应码	描述
200	表示请求成功，并返回任务。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "name" : "My task name",
      "description" : "My task description",
      "deleteReason" : null,
      "owner" : "kermit",
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
      "workTimeInMillis" : 234890,
      "claimTime" : "2013-04-18T11:01:54.715+0000",
      "taskDefinitionKey" : "taskKey",
      "formKey" : null,
      "priority" : 50,
      "dueDate" : "2013-04-20T12:11:13.134+0000",
      "parentTaskId" : null,
      "url" : "http://localhost:8182/history/historic-task-instances/5",
      "taskVariables": [
        {
          "name": "test",
          "variableScope": "local",
          "value": "myTest"
        }
      ],
      "processVariables": [
        {
          "name": "processTest",
          "variableScope": "global",
          "value": "myProcessTest"
        }
      ]
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

删除历史任务实例

DELETE history/historic-task-instances/{taskId}

Table 15.187.响应码

响应码	描述
200	表似乎删除了历史任务实例。
404	表示找不到历史任务实例。

获得历史任务实例的 IdentityLink

GET history/historic-task-instance/{taskId}/identitylinks

Table 15.188.响应码

响应码	描述
200	表示请求成功，并返回了 IdentityLink。
404	表示找不到任务实例。

成功响应体：

[
 {
  "type" : "assignee",
  "userId" : "kermit",
  "groupId" : null,
  "taskId" : "6",
  "taskUrl" : "http://localhost:8182/history/historic-task-instances/5",
  "processInstanceId" : null,
  "processInstanceUrl" : null
 }
]

获取历史任务实例变量的二进制值

GET history/historic-task-instances/{taskId}/variables/{variableName}/data

Table 15.189.获取历史任务实例变量的二进制值 - 响应码

响应码	描述
200	表示找到了任务实例，并返回了请求的变量数据。
404	表示找不到任务实例，或任务实例不包含指定名称的变量，或变量没有有效的二进制流。状态信息包含了详细信息。

获取历史活动实例

GET history/historic-activity-instances

Table 15.190.获取历史活动实例 - URL 参数

参数	是否必填	数据	描述
activityId	否	String	活动实例 id。
activityInstanceId	否	String	历史活动实例 id。
activityName	否	String	历史活动实例的名称。
activityType	否	String	历史活动实例的元素类型。
executionId	否	String	历史活动实例的分支 id。
finished	否	Boolean	表示历史活动实例是否完成。
taskAssignee	否	String	历史活动实例的负责人。
processInstanceId	否	String	历史活动实例的流程实例 id。
processDefinitionId	否	String	历史活动实例的流程定义 id。
tenantId	否	String	只返回指定 tenantId 的实例。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的实例
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的历史。如果为 `false` ，会忽略 `withoutTenantId` 参数。
可以使用通用的分页和排序查询参数。

Table 15.191.获取历史活动实例 - 响应码

响应码	描述
200	表示反悔了查询的历史活动实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "activityId" : "4",
      "activityName" : "My user task",
      "activityType" : "userTask",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "taskId" : "4",
      "calledProcessInstanceId" : null,
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史活动实例

POST query/historic-activity-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4"
}

所有支持的 JSON 参数字段和获得历史任务实例集合完全一样，但是传递的是 JSON 参数，而不是 URL 参数，这样可以支持更高级的参数，同时避免请求 uri 过长。

Table 15.192.查询历史活动实例 - 响应码

响应码	描述
200	表示请求充公，并返回了活动。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "5",
      "activityId" : "4",
      "activityName" : "My user task",
      "activityType" : "userTask",
      "processDefinitionId" : "oneTaskProcess%3A1%3A4",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definitions/oneTaskProcess%3A1%3A4",
      "processInstanceId" : "3",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/3",
      "executionId" : "4",
      "taskId" : "4",
      "calledProcessInstanceId" : null,
      "assignee" : "fozzie",
      "startTime" : "2013-04-17T10:17:43.902+0000",
      "endTime" : "2013-04-18T14:06:32.715+0000",
      "durationInMillis" : 86400056,
          "tenantId":null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

列出历史变量实例

GET history/historic-variable-instances

Table 15.193.列出历史变量实例 - URL 参数

参数	是否必填	数据	描述
processInstanceId	否	String	历史变量实例的流程实例 id。
taskId	否	String	历史变量实例的任务 id。
excludeTaskVariables	否	Boolean	表示从结果中排除任务变量。
variableName	否	String	历史变量实例的变量名称。
variableNameLike	否	String	对变量名称使用'like'操作历史变量实例。
可以使用通用的分页和排序查询参数。

Table 15.194.列出历史变量实例 - 响应码

响应码	描述
200	表示获得了历史变量实例。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "14",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "taskId" : "6",
      "variable" : {
        "name" : "myVariable",
        "variableScope", "global",
        "value" : "test"
      }
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史变量实例

POST query/historic-variable-instances

请求体：

{
  "processDefinitionId" : "oneTaskProcess%3A1%3A4",
  ...

  "variables" : [
    {
      "name" : "myVariable",
      "value" : 1234,
      "operation" : "equals",
      "type" : "long"
    }
  ]
}

所有支持的 JSON 参数字段和获得历史变量实例集合完全一样，但是传递的是 JSON 参数，而不是 URL 参数，这样可以支持更高级的参数，同时避免请求 uri 过长。除此之外，查询支持基于流程变量查询。 variables 属性是一个 json 数组，包含此处描述的格式。

Table 15.195.查询历史变量实例 - 响应码

响应码	描述
200	表示请求成功，并返回任务。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "14",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "taskId" : "6",
      "variable" : {
        "name" : "myVariable",
        "variableScope", "global",
        "value" : "test"
      }
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

获取历史任务实例变量的二进制值

GET history/historic-variable-instances/{varInstanceId}/data

Table 15.196.获取历史任务实例变量的二进制值 - 响应码

响应码	描述
200	表示找到了变量实例，并返回了请求的变量数据。
404	表示找不到变量实例，或找不到对应名称的变量实例，或变量不包含合法的二进制流。状态信息包含了详细信息。

获取历史细节

GET history/historic-detail

Table 15.197.获取历史细节 - URL 参数

参数	是否必填	数据	描述
id	否	String	历史细节的 id。
processInstanceId	否	String	历史细节的流程实例 id。
executionId	否	String	历史细节的分支 id。
activityInstanceId	否	String	历史细节的活动实例 id。
taskId	否	String	历史细节的任务 id。
selectOnlyFormProperties	否	Boolean	表示结果中只返回 FormProperties。
selectOnlyVariableUpdates	否	Boolean	表示结果中只返回变量更新信息。
可以使用通用的分页和排序查询参数。

Table 15.198.获取历史细节 - 响应码

响应码	描述
200	表示返回了查询的历史细节。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "26",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "executionId" : "6",
      "activityInstanceId", "10",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/history/historic-task-instances/6",
      "time" : "2013-04-17T10:17:43.902+0000",
      "detailType" : "variableUpdate",
      "revision" : 2,
      "variable" : {
        "name" : "myVariable",
        "variableScope", "global",
        "value" : "test"
      },
      "propertyId", null,
      "propertyValue", null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

查询历史细节

POST query/historic-detail

请求体：

{
  "processInstanceId" : "5",
}

所有支持的 JSON 参数字段和获得历史变量实例集合完全一样，但是传递的是 JSON 参数，而不是 URL 参数，这样可以支持更高级的参数，同时避免请求 uri 过长。

Table 15.199.查询历史细节 - 响应码

响应码	描述
200	表示请求成功，并返回了历史细节。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

成功响应体：

{
  "data": [
    {
      "id" : "26",
      "processInstanceId" : "5",
      "processInstanceUrl" : "http://localhost:8182/history/historic-process-instances/5",
      "executionId" : "6",
      "activityInstanceId", "10",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/history/historic-task-instances/6",
      "time" : "2013-04-17T10:17:43.902+0000",
      "detailType" : "variableUpdate",
      "revision" : 2,
      "variable" : {
        "name" : "myVariable",
        "variableScope", "global",
        "value" : "test"
      },
      "propertyId", null,
      "propertyValue", null
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

获取历史细节变量的二进制数据

GET history/historic-detail/{detailId}/data

Table 15.200.获取历史细节变量的二进制数据 - 响应码

响应码	描述
200	表示找到了历史细节实例，并返回了请求的变量数据。
404	表示找不到历史细节实例，或历史细节实例不包含指定名称的变量，或变量不包含合法的二进制流。状态信息包含了详细信息。

表单

获取表单数据

GET form/form-data

Table 15.201.获取表单数据 - URL 参数

参数	是否必填	数据	描述
taskId	是（如果没有 processDefinitionId）	String	获取表单数据需要对应的任务 id。
processDefinitionId	是（如果没有 taskId）	String	获取 startEvent 表单数据需要对应的流程定义 id。

Table 15.202.获取表单数据 - 响应码

响应码	描述
200	表示返回了查询的表单数据。
404	表示找不到表单数据。

成功响应体：

{
  "data": [
    {
      "formKey" : null,
      "deploymentId" : "2",
      "processDefinitionId" : "3",
      "processDefinitionUrl" : "http://localhost:8182/repository/process-definition/3",
      "taskId" : "6",
      "taskUrl" : "http://localhost:8182/runtime/task/6",
      "formProperties" : [
        {
          "id" : "room",
          "name" : "Room",
          "type" : "string",
          "value" : null,
          "readable" : true,
          "writable" : true,
          "required" : true,
          "datePattern" : null,
          "enumValues" : [
            {
              "id" : "normal",
              "name" : "Normal bed"
            },
            {
              "id" : "kingsize",
              "name" : "Kingsize bed"
            },
          ]
        }
      ]
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "name",
  "order": "asc",
  "size": 1
}

提交任务表单数据

POST form/form-data

任务表单的请求体：

{
  "taskId" : "5",
  "properties" : [
    {
      "id" : "room",
      "value" : "normal"
    }
  ]
}

startEvent 表单的请求体：

{
  "processDefinitionId" : "5",
  "businessKey" : "myKey", (optional)
  "properties" : [
    {
      "id" : "room",
      "value" : "normal"
    }
  ]
}

Table 15.203.提交任务表单数据 - 响应码

响应码	描述
200	表示请求成功，并提交了表单数据。
400	表示传递了错误格式的参数。状态信息包含了详细信息。

startEvent 表单数据的成功响应体（任务表单数据没有响应）：

{
  "id" : "5",
  "url" : "http://localhost:8182/history/historic-process-instances/5",
  "businessKey" : "myKey",
  "suspended", false,
  "processDefinitionId" : "3",
  "processDefinitionUrl" : "http://localhost:8182/repository/process-definition/3",
  "activityId" : "myTask"
}

数据库表

表列表

GET management/tables

Table 15.204.表列表 - 响应码

响应码	描述
200	表示请求成功。

成功响应体：

[
   {
      "name":"ACT_RU_VARIABLE",
      "url":"http://localhost:8182/management/tables/ACT_RU_VARIABLE",
      "count":4528
   },
   {
      "name":"ACT_RU_EVENT_SUBSCR",
      "url":"http://localhost:8182/management/tables/ACT_RU_EVENT_SUBSCR",
      "count":3
   },

   ...

]

获得一张表

GET management/tables/{tableName}

Table 15.205.获得一张表 - URL 参数

参数	是否必须	值	描述
tableName	是	String	获取表的名称。

成功响应体：

{
      "name":"ACT_RE_PROCDEF",
      "url":"http://localhost:8182/management/tables/ACT_RE_PROCDEF",
      "count":60
}

Table 15.206.获得一张表 - 响应码

响应码	描述
200	表示表存在，并返回了表的记录数。
404	表示表不存在。

获得表的列信息

GET management/tables/{tableName}/columns

Table 15.207.获得表的列信息 - URL 参数

参数	是否必须	值	描述
tableName	是	String	获取表的名称。

成功响应体：

{
   "tableName":"ACT_RU_VARIABLE",
   "columnNames":[
      "ID_",
      "REV_",
      "TYPE_",
      "NAME_",
      ...
   ],
   "columnTypes":[
      "VARCHAR",
      "INTEGER",
      "VARCHAR",
      "VARCHAR",
      ...
   ]
}

Table 15.208.获得表的列信息 - 响应码

响应码	描述
200	表示表存在，并返回了表的列信息。
404	表示表不存在。

获得表的行数据

GET management/tables/{tableName}/data

Table 15.209.获得表的行数据 - URL 参数

参数	是否必须	值	描述
tableName	是	String	获取表的名称。

Table 15.210.获得表的行数据 - URL 参数

参数	是否必须	值	描述
start	否	Integer	从哪一行开始获取。默认为 0。
size	否	Integer	获取行数，从 `start` 开始。默认为 10。
orderAscendingColumn	否	String	对结果行进行排序的字段，正序。
orderDescendingColumn	否	String	对结果行进行排序的字段，倒序。

成功响应体：

{
  "total":3,
   "start":0,
   "sort":null,
   "order":null,
   "size":3,

   "data":[
      {
         "TASK_ID_":"2",
         "NAME_":"var1",
         "REV_":1,
         "TEXT_":"123",
         "LONG_":123,
         "ID_":"3",
         "TYPE_":"integer"
      },
      ...
   ]

}

Table 15.211.获得表的行数据 - 响应码

响应码	描述
200	表示表存在，并返回了行数据。
404	表示表不存在。

引擎

获得引擎属性

GET management/properties

返回引擎内部使用的只读属性。

成功响应体：

{
   "next.dbid":"101",
   "schema.history":"create(5.14)",
   "schema.version":"5.14"
}

Table 15.212.获得引擎属性 - 响应码

响应码	描述
200	表示返回了属性。

获得引擎信息

GET management/engine

获得 REST 服务使用的引擎的只读信息。

成功响应体：

{
   "name":"default",
   "version":"5.14",
   "resourceUrl":"file://activiti/activiti.cfg.xml",
   "exception":null
}

Table 15.213.获得引擎信息 - 响应码

响应码	描述
200	表示返回了引擎信息。

运行时

接收信号事件

POST runtime/signals

提醒引擎，接收了一个信号事件，不会特别针对某个流程。

JSON 体：

{
  "signalName": "My Signal",
  "tenantId" : "execute",
  "async": true,
  "variables": [
      {"name": "testVar", "value": "This is a string"},
      ...
  ]
}

Table 15.214.接收信号事件 - JSON 体参数

参数	描述	必填
signalName	signal 的名称	是
tenantId	信号事件应该执行在的 tenantId	否
async	如果为 `true` ，处理信号应该是异步的。返回码为 `202 - Accepted` 表示请求已接受，但尚未执行。如果为 `false` ，会立即处理信号，结果为 ( `200 - OK` ) 会在成功完成后返回。如果忽略，默认为 `false` 。	否
variables	变量数组（通用的参数格式）用来向信号传递载荷。不能把 `async` 设置为 `true` ，它会导致返回错误。	否

成功响应体：

Table 15.215.接收信号事件 - 响应码

响应码	描述
200	表示已经处理了信号，没有发生错误。
202	表示信号处理已经进入一个异步作业的队列，准备执行了。
400	信号没有处理。缺少信号名，或同时使用了变量和异步，这是不允许的。响应体包含了错误的额外信息。

作业

获取一个作业

GET management/jobs/{jobId}

Table 15.216.获取一个作业 - URL 参数

参数	是否必须	值	描述
jobId	是	String	获取的作业 id。

成功响应体：

{
   "id":"8",
   "url":"http://localhost:8182/management/jobs/8",
   "processInstanceId":"5",
   "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
   "processDefinitionId":"timerProcess:1:4",
   "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
   "executionId":"7",
   "executionUrl":"http://localhost:8182/runtime/executions/7",
   "retries":3,
   "exceptionMessage":null,
   "dueDate":"2013-06-04T22:05:05.474+0000",
   "tenantId":null
}

Table 15.217.获取一个作业 - 响应码

响应码	描述
200	表示作业存在，并成功返回。
404	表示作业不存在。

删除作业

DELETE management/jobs/{jobId}

Table 15.218.删除作业 - URL 参数

参数	是否必须	值	描述
jobId	是	String	期望删除的作业 id。.

Table 15.219.删除作业 - 响应码

响应码	描述
204	表示找到了作业，并成功删除。响应体为空。
404	表示找不到作业。

执行作业

POST management/jobs/{jobId}

请求 JSON 体：

{
  "action" : "execute"
}

Table 15.220.执行作业 - 请求的 JSON 参数

参数	描述	是否必填
action	执行的操作。只支持 `execute` 。	是

Table 15.221.执行作业 - 响应码

响应码	描述
204	表示成功执行了操作。响应体为空。
404	表示找不到作业。
500	表示执行作业时出现了异常。状态描述包含了错误的详细信息。如果需要可以后续获取错误堆栈。

获得作业的异常堆栈

GET management/jobs/{jobId}/exception-stracktrace

Table 15.222.获得作业的异常堆栈 - URL 参数

参数	描述	是否必填
jobId	获取堆栈的作业 id。	是

Table 15.223.获得作业的异常堆栈 - 响应码

响应码	描述
200	表示找到了作业，并返回了堆栈。响应包含了原始堆栈，Content-Type 永远是 `text/plain` 。
404	表示找不到作业，或作业不包含错误堆栈。状态描述包含错误的详细信息。

获得作业列表

GET management/jobs

Table 15.224.获得作业列表 - URL 参数

参数	描述	类型
id	只返回指定 id 的作业。	String
processInstanceId	只返回指定 id 流程一部分的作业。	String
executionId	只返回指定 id 分支一部分的作业。	String
processDefinitionId	只返回指定流程定义 id 的作业。	String
withRetriesLeft	如果为 `true` ，只返回尝试剩下的。如果为 false，会忽略此参数。	Boolean
executable	如果为 `true` ，只返回可执行的作业。如果为 false，会忽略此参数。	Boolean
timersOnly	如果为 `true` ，只返回类型为定时器的作业。如果为 false，会忽略此参数。不能与 `'messagesOnly'` 一起使用。	Boolean
messagesOnly	如果为 `true` ，只返回类型为消息的作业。如果为 false，会忽略此参数。不能与 `'timersOnly'` 一起使用。	Boolean
withException	如果为 `true` ，只返回执行时出现了异常的作业。如果为 false，会忽略此参数。	Boolean
dueBefore	只返回在指定时间前到期的作业。如果使用了这个参数，就不会返回没有设置持续时间的作业。	Date
dueAfter	只返回在指定时间后到期的作业。如果使用了这个参数，就不会返回没有设置持续时间的作业。	Date
exceptionMessage	Only return jobs with the given exception message	String
tenantId	否	String	只返回指定 tenantId 的作业。
tenantIdLike	否	String	只返回与指定 tenantId 匹配的作业。
withoutTenantId	否	Boolean	如果为 `true` ，只返回未设置 tenantId 的作业。如果为 `false` ，会忽略 `withoutTenantId` 参数。
sort	对结果进行排序的字段，可以是 `id` , `dueDate` , `executionId` , `processInstanceId` ， `retries` 或 `tenantId` 其中之一。	String
可以使用通用的分页和排序查询参数。

成功响应体：

{
   "data":[
      {
         "id":"13",
         "url":"http://localhost:8182/management/jobs/13",
         "processInstanceId":"5",
         "processInstanceUrl":"http://localhost:8182/runtime/process-instances/5",
         "processDefinitionId":"timerProcess:1:4",
         "processDefinitionUrl":"http://localhost:8182/repository/process-definitions/timerProcess%3A1%3A4",
         "executionId":"12",
         "executionUrl":"http://localhost:8182/runtime/executions/12",
         "retries":0,
         "exceptionMessage":"Can't find scripting engine for 'unexistinglanguage'",
         "dueDate":"2013-06-07T10:00:24.653+0000"
      },

      ...
   ],
   "total":2,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":2
}

Table 15.225.获得作业列表 - 响应码

响应码	描述
200	表示返回了作业。
400	表示在 url 参数中使用了非法的值，或参数中同时使用了 `'messagesOnly'` 和 `'timersOnly'` 。状态描述包含了错误的详细信息。

用户

获得一个用户

GET identity/users/{userId}

Table 15.226.获得一个用户 - URL 参数

参数	是否必须	值	描述
userId	是	String	获取用户的 id。

成功响应体：

{
   "id":"testuser",
   "firstName":"Fred",
   "lastName":"McDonald",
   "url":"http://localhost:8182/identity/users/testuser",
   "email":"no-reply@activiti.org"
}

Table 15.227.获得一个用户 - 响应码

响应码	描述
200	表示用户存在，并成功返回。
404	表示用户不存在。

获取用户列表

GET identity/users

Table 15.228.获取用户列表 - URL 参数

参数	描述	类型
id	只返回指定 id 的用户。	String
firstName	只返回指定 firstname 的用户。	String
lastName	只返回指定 lastname 的用户。	String
email	只返回指定 email 的用户。	String
firstNameLike	只返回 firstname 与指定值匹配的用户。使用 `%` 通配符。	String
lastNameLike	只返回 lastname 与指定值匹配的用户。使用 `%` 通配符。	String
emailLike	只返回 email 与指定值匹配的用户。使用 `%` 通配符。	String
memberOfGroup	只返回指定组成员的用户。	String
potentialStarter	只返回指定流程定义 id 的默认启动人。	String
sort	结果排序的字段，应该是 `id` , `firstName` , `lastname` 或 `email` 其中之一。	String
可以使用通用的分页和排序查询参数。

成功响应体：

{
   "data":[
      {
         "id":"anotherUser",
         "firstName":"Tijs",
         "lastName":"Barrez",
         "url":"http://localhost:8182/identity/users/anotherUser",
         "email":"no-reply@alfresco.org"
      },
      {
         "id":"kermit",
         "firstName":"Kermit",
         "lastName":"the Frog",
         "url":"http://localhost:8182/identity/users/kermit",
         "email":null
      },
      {
         "id":"testuser",
         "firstName":"Fred",
         "lastName":"McDonald",
         "url":"http://localhost:8182/identity/users/testuser",
         "email":"no-reply@activiti.org"
      }
   ],
   "total":3,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":3
}

Table 15.229.获取用户列表 - 响应码

响应码	描述
200	表示成功返回了请求的用户。

更新用户

PUT identity/users/{userId}

请求 JSON 体：

{
  "firstName":"Tijs",
  "lastName":"Barrez",
  "email":"no-reply@alfresco.org",
  "password":"pass123"
}

所有请求值都是可选的。比如，你可以在请求体 JSON 对象中只包含'firstName'属性，只更新用户的 firstName，其他值都不受影响。当包含的属性设置为 null，用户的属性会被更新为 null，比如： {"firstName" : null} 会清空用户的 firstName。

Table 15.230.更新用户 - 响应码

响应码	描述
200	表示成功更新了用户。
404	表示找不到用户。
409	表示请求的用户被其他地方更新了。

成功响应体： 参考 identity/users/{userId} 的响应。

创建用户

POST identity/users

请求 JSON 体：

{
  "id":"tijs",
  "firstName":"Tijs",
  "lastName":"Barrez",
  "email":"no-reply@alfresco.org",
  "password":"pass123"
}

Table 15.231.创建用户 - 响应码

响应码	描述
201	表示成功创建了用户。
400	表示没有传用户的 id。

成功响应体： 参考 identity/users/{userId} 的响应。

删除用户

DELETE identity/users/{userId}

Table 15.232.删除用户 - URL 参数

参数	是否必填	数据	描述
userId	是	String	期望删除的用户 id。

Table 15.233.删除用户 - 响应码

响应码	描述
204	表示找到了用户，并成功删除了。响应体为空。
404	表示找不到用户。

获取用户图片

GET identity/users/{userId}/picture

Table 15.234.获取用户图片 - URL 参数

参数	是否必填	数据	描述
userId	是	String	期望获得图片的用户 id。

响应体： 响应体包含了演示图片数据，展示用户的图片。响应的 Content-Type 对应着创建图片时设置的 mimeType。

Table 15.235.获取用户图片 - 响应码

响应码	描述
200	表示找到了用户和图片，图片在响应体中返回。
404	表示找不到用户，或用户没有图片。状态描述包含错误的详细信息。

更新用户图片

GET identity/users/{userId}/picture

Table 15.236.更新用户图片 - URL 参数

参数	是否必填	数据	描述
userId	是	String	获得图片对应的用户 id。

请求体： 请求应该是 multipart/form-data 类型。应该只有一个文件区域，包含源码的二进制内容。除此之外，需要提供以下表单域：

mimeType ：上传的图片的 mime-type。如果省略，默认会使用 image/jpeg 作为图片的 mime-type。

Table 15.237.更新用户图片 - 响应码

响应码	描述
200	表示找到了用户，并更新了图片。响应体为空。
404	表示找不到用户。

列出用户列表

PUT identity/users/{userId}/info

Table 15.238.列出用户列表 - URL 参数

参数	是否必填	数据	描述
userId	是	String	获取信息的用户 id。

响应体：

[
   {
      "key":"key1",
      "url":"http://localhost:8182/identity/users/testuser/info/key1"
   },
   {
      "key":"key2",
      "url":"http://localhost:8182/identity/users/testuser/info/key2"
   }
]

Table 15.239.列出用户列表 - 响应码

响应码	描述
200	表示找到了用户，并返回了信息列表（key 和 url）。
404	表示找不到用户。

获取用户信息

GET identity/users/{userId}/info/{key}

Table 15.240.获取用户信息 - URL 参数

参数	是否必填	数据	描述
userId	是	String	获取信息的用户 id。
key	是	String	希望获取的用户信息的 key。

响应体：

{
   "key":"key1",
   "value":"Value 1",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

Table 15.241.获取用户信息 - 响应码

响应码	描述
200	表示找到了用户和指定 key 的用户信息。
404	表示找不到用户，并用户没有指定 key 的信息。状态描述中包含了错误相关的详细信息。

更新用户的信息

PUT identity/users/{userId}/info/{key}

Table 15.242.更新用户的信息 - URL 参数

参数	是否必填	数据	描述
userId	是	String	期望更新的信息对应的用户 id。
key	是	String	期望更新的用户信息的 key。

请求体：

{
   "value":"The updated value"
}

响应体：

{
   "key":"key1",
   "value":"The updated value",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

Table 15.243.更新用户的信息 - 响应码

响应码	描述
200	表示找到了用户，并更新了信息。
400	表示请求体中缺少数据。
404	表示找到用户，或找不到指定 key 的用户信息。状态描述中包含了错误相关的详细信息。

创建用户信息条目

POST identity/users/{userId}/info

Table 15.244.创建用户信息条目 - URL 参数

参数	是否必填	数据	描述
userId	是	String	期望创建信息的用户 id。

请求体：

{
   "key":"key1",
   "value":"The value"
}

响应体：

{
   "key":"key1",
   "value":"The value",
   "url":"http://localhost:8182/identity/users/testuser/info/key1"
}

Table 15.245.创建用户信息条目 - 响应码

响应码	描述
201	表示找到了用户，并创建了信息。
400	表示请求体中缺少 key 或 value。状态描述中包含了错误相关的详细信息。
404	表示找不到用户。
409	表示用户已经有了一条指定 key 的信息条目，可以更新资源实例（ `PUT` ）。

删除用户的信息

DELETE identity/users/{userId}/info/{key}

Table 15.246.删除用户的信息 - URL 参数

参数	是否必填	数据	描述
userId	是	String	希望删除信息的用户 id。
key	是	String	期望删除的用户信息的 key。

Table 15.247.删除用户的信息 - 响应码

响应码	描述
204	表示找到了用户和信息，并删除了指定 key 的条目。响应体为空。
404	表示找不到用户，或用户不包含指定 key 的信息。状态描述中包含了错误相关的详细信息。

群组

获得群组

GET identity/groups/{groupId}

Table 15.248.获得群组 - URL 参数

参数	是否必须	值	描述
groupId	是	String	希望获得的群组 id。

成功响应体：

{
   "id":"testgroup",
   "url":"http://localhost:8182/identity/groups/testgroup",
   "name":"Test group",
   "type":"Test type"
}

Table 15.249.获得群组 - 响应码

响应码	描述
200	表示群组存在，并成功返回。
404	表示群组不存在。

获取群组列表

GET identity/groups

Table 15.250.获取群组列表 - URL 参数

参数	描述	类型
id	只返回指定 id 的群组。	String
name	只返回指定名称的群组。	String
type	只返回指定类型的群组。	String
nameLike	只返回名称与指定值匹配的群组使用 `%` 作为通配符。	String
member	只返回成员与指定用户 ing 相同的群组。	String
potentialStarter	只返回成员作为指定 id 流程定义的潜在启动者的劝阻。	String
sort	结果排序的字段。应该是 `id` , `name` 或 `type` 其中之一。	String
可以使用通用的分页和排序查询参数。

成功响应体：

{
   "data":[
     {
        "id":"testgroup",
        "url":"http://localhost:8182/identity/groups/testgroup",
        "name":"Test group",
        "type":"Test type"
     },

      ...
   ],
   "total":3,
   "start":0,
   "sort":"id",
   "order":"asc",
   "size":3
}

Table 15.251.获取群组列表 - 响应码

响应码	描述
200	表示返回了请求的群组。

更新群组

PUT identity/groups/{groupId}

请求 JSON 体：

{
   "name":"Test group",
   "type":"Test type"
}

所有请求值都是可选的。比如，你可以在请求体 JSON 对象中只包含'name'属性，只更新群组的名称，其他属性都不会受到英系那个。如果把一个属性设置为 null，群组的数据就会更新为 null。

Table 15.252.更新群组 - 响应码

响应码	描述
200	表示成功更新了群组。
404	表示找不到请求的群组。
409	表示请求的群组正在被其他地方更新。

成功响应体： 参考 identity/groups/{groupId} 的响应。

创建群组

POST identity/groups

请求 JSON 体：

{
   "id":"testgroup",
   "name":"Test group",
   "type":"Test type"
}

Table 15.253.创建群组 - 响应码

响应码	描述
201	表示创建了群组。
400	表示丢失了群组的 id。

成功响应体： 参考 identity/groups/{groupId} 的响应。

删除群组

DELETE identity/groups/{groupId}

Table 15.254.删除群组 - URL 参数

参数	是否必填	数据	描述
groupId	是	String	期望删除的群组 id。

Table 15.255.删除群组 - 响应码

响应码	描述
204	表示找到了群组，并成功删除了。响应体为空。
404	表示找不到请求的群组。

获取群组的成员

identity/groups/members 不允许使用 GET。使用 identity/users?memberOfGroup=sales URL 来获得某个群组下的所有成员。

为群组添加一个成员

POST identity/groups/{groupId}/members

Table 15.256.为群组添加一个成员 - URL 参数

参数	是否必填	数据	描述
groupId	是	String	期望添加成员的群组 id。

请求 JSON 体：

{
   "userId":"kermit"
}

Table 15.257.为群组添加一个成员 - 响应码

响应码	描述
201	表示找到了群组，并添加了成员。
404	表示请求体中未包含 userId。
404	表示找不到请求的群组。
409	表示请求的用户已经是群组的一员了。

响应体：

{
   "userId":"kermit",
   "groupId":"sales",
    "url":"http://localhost:8182/identity/groups/sales/members/kermit"
}

删除群组的成员

DELETE identity/groups/{groupId}/members/{userId}

Table 15.258.删除群组的成员 - URL 参数

参数	是否必填	数据	描述
groupId	是	String	期望删除成员的群组 id。
userId	是	String	期望删除的用户 id。

Table 15.259.删除群组的成员 - 响应码

响应码	描述
204	表示找到了群组，并删除了成员。响应体为空。
404	表示找不到请求的群组，或用户不是群组的成员。状态描述中包含了错误相关的详细信息。

响应体：

{
   "userId":"kermit",
   "groupId":"sales",
    "url":"http://localhost:8182/identity/groups/sales/members/kermit"
}

传统 REST - 通用方法

下面的章节中包含了传统的 REST-api，它们在 5.14 版本中已经废弃了。REST url 不会在未来删除，但是也不会维护了。未来的所有改进都会放到新 REST API 中。

Activiti 包含了一套引擎的 REST API，可以把 activiti-rest.war 部署到像 Apache Tomcat 一样的 Servlet 容器里。默认 Activiti 引擎会连接一个单独运行的 h2 数据库。你可以修改 WEB-INF/classes 目录下的 db.properties 文件来修改数据库配置。 REST API 使用 JSON 格式（http://www.json.org），内部使用 Restlet 构建（http://www.restlet.org）。

每个 REST API 调用都会使用单独的校验级别，你必须登录到系统中，来调用 REST API（除了/login 服务）。认证是通过 Basic HTTP 认证实现的，如果你登录为管理员（比如 kermit），你应该可以访问下面介绍的所有接口。

API 遵守着通常的 REST API 约定，对读取操作使用 GET，对创建对象使用 POST，对更新和执行操作使用 PUT，对删除对象使用 DELETE。在执行应先过很多次对象的操作时，使用 POST 来执行这些操作来保证传递的参数不受限制。使用 POST 的原因是 HTTP DELETE 方法不允许使用请求体。使用 DELETE 的调用，理论上，它的请求体会被代理剔除。为了保证不发生这种事情，我们使用了 POST，虽然 PUT 也可以更新多个对象，为了保持一致。

所有 rest 调用都使用"application/json"作为 Content-Type（除了上传请求使用"multipart/form-data"）。

执行 REST 调用的 url 基础地址是 http://localhost:8080/activiti-rest/service/。比如，列出引擎中流程定义的方法，在你的浏览器中应该是： http://localhost:8080/activiti-rest/service/process-definitions

你就也可以使用 curl 来通过 REST API 执行查询，比如：

curl --basic --user kermit:kermit http://localhost:8080/activiti-rest/service/tasks?assignee=kermit

请参考下面的描述，来了解哪些 REST API 是目前可用的。请参考"API"章节作为，“一行的注释”，来了解核心 API 的功能，实现 REST API 的调用。

资源

上传发布

上传并安装发布.bpmn20.xml, .bpmn, .bar 或 .zip 格式，使用普通的“html 表单上传”（enctype=multipart/form-data）换句话说不是 json 请求。如果发布操作成功，发布信息会包含在返回的响应中。

请求： POST /deployment
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().createDeployment().name(fileName).deploymentBuilder.deploy()

响应：

{
  "id": "10",
  "name": "activiti-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": "examples"
}

获取发布

返回分页发布列表，可以通过"id", "name" 或 "deploymentTime"排序。

请求： GET /deployments?start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().createDeploymentQuery().listPage()

响应：

{
  "data": [
    {
      "id": "10",
      "name": "activiti-examples.bar",
      "deploymentTime": "2010-10-13T14:54:26.750+02:00",
      "category": "examples"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获取发布资源

返回发布的所有资源。实例： /deployment/10/resources

请求： GET /deployment/{deploymentId}/resources
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().getDeploymentResourceNames(deploymentId)

响应：

{
  "id": "10",
  "name": "activiti-examples.bar",
  "deploymentTime": "2010-10-13T14:54:26.750+02:00",
  "category": "examples",
  "resources": ["resource1", "resource2"]
}

获取发布的一个资源

获取发布的一个资源。实例： /deployment/10/resource/org/activiti/examples/bpmn/usertask/FinancialReportProcess.bpmn20.xml

请求： GET /deployment/{deploymentId}/resource/{resourceName}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().getResourceAsStream(deploymentId, resourceName)

响应：

比如，一个.bpmn20.xml 文件，一个图片或其他发布资源包含的文件类型。

删除发布

删除一个发布。

请求： DELETE /deployment/{deploymentId}?cascade={cascade?}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().deleteDeployment(deploymentId)
响应：
```
{
  "success": true
}
```

删除发布

删除多个发布。

请求： POST /deployments/delete?cascade={cascade?}
```
{
"deploymentIds": [ "10", "11" ]
}
```
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().deleteDeployment(deploymentId)
响应：
```
{
  "success": true
}
```

引擎

获取流程引擎

返回流程引擎安装细节。如果启动时出现了问题，错误的细节会包含在响应的"exception"属性中。

请求： GET /process-engine
API: ProcessEngines.getProcessEngine(configuredProcessEngineName)

响应：

{
  "name": "default",
  "resourceUrl": "jar:file:\//<path-to-deployment>\/activiti-cfg.jar!\/activiti.properties",
  "exception": null,
  "version": "5.11"
}

流程

流程定义列表

返回发布的流程定义的信息，可以通过"id", "name", "version" 或 "deploymentId"排序。BPMN2.0 XML 的流程图的名字包含在"resourceName"属性中，结合"deploymentId"属性，可以通过上面的获取发布资源 REST API 调用获得。

分页请求： GET /process-definitions?start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRepositoryService().createProcessDefinitionQuery().listPage()

分页响应：

{
  "data": [
    {
      "id": "financialReport:1",
      "key": "financialReport",
      "version": 1,
      "name": "Monthly financial report",
      "resourceName": "org/activiti/examples/bpmn/usertask/FinancialReportProcess.bpmn20.xml",
      "diagramResourceName": "org/activiti/examples/bpmn/usertask/FinancialReportProcess.png",
      "deploymentId": "10",
      "startFormResourceKey": null,
      "isGraphicNotationDefined": true
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获得流程定义表单属性

返回流程定义表单属性。

请求： GET /process-definition/{processDefinitionId}/properties
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getFormService().getStartFormData(processDefinitionId)

响应：

                "data": [
    {
      "id": "fullName",
      "name": "Full name",
      "value": "${name}",
      "type": "String",
      "required": false,
      "readable": true,
      "writeable": true
    }
  ]

获得流程定义表单资源

返回流程定义表单。

请求： GET /process-definition/{processDefinitionId}/form
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().getRenderedStartFormById(processDefinitionId)
响应：
```
<user-defined-response>
```

获取流程定义图

如果存在，就返回一个流程定义的 PNG 图。

请求： GET /process-definition/{processDefinitionId}/diagram
API: repositoryService.getResourceAsStream(processDefinition.getDeploymentId(), processDefinition.getDiagramResourceName());
响应：
```
流程定义的 PNG 图。
```

启动流程实例

根据流程定义创建流程实例，返回新创建流程实例的细节信息。可以使用请求体对象传递额外的变量（通过表单）。换句话说，就是"processDefinitionId"属性旁边的属性。

注意如果提交的值为 true（不是"true"），会被当做 Boolean，即使没有使用描述符。这与数字的处理方式相同。比如，123 会当做整数。 "123"会当做字符串（除非使用描述符定义）。

请求： POST /process-instance

{
  "processDefinitionId":"financialReport:1:1700",
  "businessKey":"order-4711"
}

API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getRuntimeService().startProcessInstanceById(processDefinitionId[, businessKey][, variables])

响应：

{
  "id": "217",
  "processDefinitionId": "financialReport:1:1700",
  "businessKey": "order-4711",
  "processInstanceId": "217"
}

流程实例列表

返回活动的流程实例细节，可以通过"id", "startTime", "businessKey" 或 "processDefinitionId"排序。你可以使用"processDefinitionId" and "businessKey"进行查询。

分页请求： GET /process-instances?start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}&businessKey={businessKey}&processDefinitionId={processDefinitionId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getHistoryService().createHistoricProcessInstanceQuery().xxx.listPages()

分页响应：

  {
    "data": [
      {
        "id": "2",
        "processDefinitionId": "financialReport:1",
        "businessKey": "55",
        "startTime": "2010-10-13T14:54:26.750+02:00",
        "startUserId": "kermit"
      }
    ],
    "total": 1,
    "start": 0,
    "sort": "id",
    "order": "asc",
    "size": 1
  }

获得流程实例细节

返回指定流程实例的所有细节。可以是运行中或已结束的流程实例。

请求： GET /process-instance/{processInstanceId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getHistoryService().createHistoricProcessInstanceQuery().processInstanceId(..).singleResult()

响应：

  {
    "id": "2",
    "processDefinitionId": "financialReport:1",
    "businessKey": "55",
    "startTime": "2010-10-13T14:54:26.750+02:00",
    "startActivityId": "startFinancialAnalysis",
    "startUserId": "kermit",
    "completed": false,
    "tasks": [
      {
        "taskId": "3",
        "taskName": "Analyze report",
        "owner": null,
        "assignee": "Kermit",
        "startTime": "2010-10-13T14:53:26.750+02:00",
        "completed": false
      }
    ],
    "activities": [
      {
        "activityId": "4",
        "activityName": "Get report",
        "activityType": "ServiceTask",
        "startTime": "2010-10-13T14:53:25.750+02:00",
        "completed": true,
        "startTime": "2010-10-13T14:53:25.950+02:00",
        "duration": 200
      }
    ],
    "variables": [
      {
        "variableName": "reportName",
        "variableValue": "classified.pdf",
      }
    ]
    "historyVariables": [
      {
        "variableName": "reportName",
        "variableValue": "classified.pdf",
        "variableType": "String",
        "revision": 1,
        "time": "2010-10-13T14:53:26.750+02:00"
      }
    ]

  }

获得流程实例图

返回高亮的活动流程 PNG 图。如果流程定义未包含 DI 信息就会返回 404。

请求： GET /process-instance/{processInstanceId}/diagram
API: ProcessDiagramGenerator.generateDiagram(pde, "png", getRuntimeService().getActiveActivityIds(processInstanceId));
响应：
```
返回高亮的活动流程 PNG 图。
```

获得流程实例的任务

返回运行中流程实例的任务列表。

请求： GET /process-instance/{processInstanceId}/tasks
API: taskService.createTaskQuery().processInstanceId(processInstanceId);

分页响应：

{
  "data": [
    {
      "id": "127",
      "name": "Handle vacation request",
      "description": "Vacation request by Kermit",
      "delegationState": "pending",
      "dueDate": "2010-10-13T14:54:26.750+02:00",
      "priority": 50,
      "assignee": null,
      "executionId": "118",
      "formResourceKey": "org/activiti/examples/taskforms/approve.form",
      "owner": "Kermit",
      "parentTaskId": "120",
      "processDefinitionId": "financialReport:1",
      "processInstanceId": "123",
      "taskDefinitionKey": "125"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

继续特定流程实例的活动（receiveTask）

继续一个活动分支（receiveTask）。

请求： POST /process-instance/{processInstanceId}/signal

{
  "activityId":"receiveTask",
  "variable1":"value",
  "variable2":"value"
}

API: runtimeService.signal(execution.getId(), variables);
响应：
```
{
  "success": true
}
```

触发特定流程实例的信号

向特定流程实例发送一个信号，会触发所有订阅的信号事件。可以通过请求体发送额外的变量。如果你不想发送任何变量，可以使用空的请求体。

请求： POST /process-instance/{processInstanceId}/event/{signalName}
```
{
  "variable1":"value",
  "variable2":"value"
}
```
API: runtimeService.signalEventReceived(signalName, execution.getId()[, variables]);
响应：
```
{
  "success": true
}
```

任务

获得任务简介

为特定用户返回任务简介：分配给用户的任务数量，用户可以认领的未分配任务的数量，用户作为成员的群组可以认领的未分配任务。

请求： GET /tasks-summary?user={userId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().createTaskQuery().xxx().count()

响应：

{
  "assigned": {
    "total": 0
  },
  "unassigned": {
    "total": 1,
    "groups":
    {
      "accountancy": 1,
      "sales": 0,
      "engineering": 0,
      "management": 0
    }
  }
}

任务列表

返回分页的任务列表，可以同构"id", "name", "description", "priority", "assignee", "executionId" 或 "processInstanceId"排序。列表必须基于特定角色的用户：负责人（分配给用户的任务列表）或候选人（用户可以领取的任务列表）或候选群组（用户作为成员的群组可以认领的任务列表）。如果任务通过"formResourceKey"属性指定了一个表单。任务的表单可以通过获取任务表单 REST API 获得。

分页请求： GET /tasks?[assignee={userId}|candidate={userId}|candidate-group={groupId}]&start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}

实例：

curl --basic --user kermit:kermit http://localhost:8080/activiti-rest/service/tasks?assignee=kermit

API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().createTaskQuery().xxx().listPage()

分页响应：

{
  "data": [
    {
      "id": "127",
      "name": "Handle vacation request",
      "description": "Vacation request by Kermit",
      "delegationState": "pending",
      "dueDate": "2010-10-13T14:54:26.750+02:00",
      "priority": 50,
      "assignee": null,
      "executionId": "118",
      "formResourceKey": "org/activiti/examples/taskforms/approve.form",
      "owner": "Kermit",
      "parentTaskId": "120",
      "processDefinitionId": "financialReport:1",
      "processInstanceId": "123",
      "taskDefinitionKey": "125"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获取任务

通过任务 id 获取任务的细节。

请求： GET /task/{taskId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().createTaskQuery().taskId(taskId).singleResult()

响应：

{
      "id": "127",
      "name": "Handle vacation request",
      "description": "Vacation request by Kermit",
      "delegationState": "pending",
      "dueDate": "2010-10-13T14:54:26.750+02:00",
      "priority": 50,
      "assignee": null,
      "executionId": "118",
      "formResourceKey": "org/activiti/examples/taskforms/approve.form",
      "owner": "Kermit",
      "parentTaskId": "120",
      "processDefinitionId": "financialReport:1",
      "processInstanceId": "123",
      "taskDefinitionKey": "125",
      "subTaskList": [
        {
          "id": "129",
          "name": "Analyze request",
          "description": "Analyze request",
          "delegationState": "pending",
          "dueDate": "2010-10-13T14:54:26.750+02:00",
          "priority": 50,
          "assignee": null,
          "executionId": "118",
          "owner": "Kermit",
          "parentTaskId": "127"
        }
      ],
      "identityLinkList" : [
        {
          "type": "candidate",
          "userId": "Fozzie",
          "groupId": null
        }
      ],
      "attachmentList" : [
        {
          "id": "130",
          "name": "vacation_request.xls",
          "description": "Vacation request",
          "type": "application/pdf",
          "url": null
        }
      ]
}

获取任务表单

获取任务表单。

请求： GET /task/{taskId}/form
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().getRenderedTaskForm(taskId)
响应：
```
<user-defined-response>
```

执行任务操作

对任务执行操作（认领，释放，分配或完成）。对于“完成”操作的额外变量（通过表单）可以通过请求体传递。要从表单读取更多变量，可以参考启动流程实例章节。

请求： PUT /task/{taskId}/[claim|unclaim|complete|assign] 认领和释放不需要 JSON 体，对于完成你可以提供一些变量，分配必须使用 userId。例如，完成操作的请求体：
```
{
      "variableName1": "variableValue1",
      "variableName2": "variableValue2"
}
```
例如，分配操作的请求体：
```
{
      "userId": "newAssignee"
}
```
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().xxx(taskId ...)
响应：
```
{
  "success": true
}
```

表单属性列表

返回运行中任务的表单的属性列表，由流程定义。

请求： GET /form/{taskId}/properties
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getFormService().getTaskFormData(taskId).getFormProperties()

响应：

{
  "data": [
    {
      "id": "userName",
      "name": "User",
      "value": "foobar",
      "type": "string",
      "required": "true",
      "readable": "true",
      "writable": "true"
    }
]
}

为任务添加一个附件

为任务实例添加一个附件。

请求： PUT /task/{taskId}/attachment
```
{}
```
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().createAttachment(...)

响应：

        {
          "id": "130",
          "name": "vacation_request.xls",
          "description": "Vacation request",
          "type": "application/pdf",
          "url": null
        }

获得任务附件

返回任务附件

请求： GET /attachment/{attachmentId}
API: taskService.getAttachment(attachmentId);
响应：
```
附件。
```

为任务添加一个 url

为任务实例添加一个 url

请求： PUT /task/{taskId}/url
```
{}
```
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getTaskService().createAttachment(...)

响应：

        {
          "id": "130",
          "name": "google.com",
          "description": "Good search sitet",
          "type": null,
          "url": "http://www.google.com"
        }

身份

获得用户

返回用户的细节。

请求： GET /user/{userId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().createUserQuery().userId(userId).singleResult();

响应：

{
  "id": "kermit",
  "firstName": "Kermit",
  "lastName": "the Frog",
  "email": "kermit@server.com"
}

列出用户的群组

返回用户对应的群组分页列表，可以使用"id", "name" 或 "type"排序。

分页请求： GET /user/{userId}/groups?start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().xxx(userId)

分页响应：

{
  data: [
    {
      "id": "admin",
      "name": "System administrator",
      "type": "security-role"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

查询用户

返回用户列表，通过查询的文本搜索 firstname 和 lastname。

分页请求： GET /users?searchText=ker
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().createUserQuery().userFirstNameLike(searchText).list() ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().createUserQuery().userLastNameLike(searchText).list()

响应：

{
  data: [
    {
      "id": "kermit",
      "firstName": "Kermit",
      "lastName": "the Frog",
      "email": "kermit@server.com"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

创建用户

创建一个新用户。

请求： PUT /user

{
  "id": "kermit",
  "firstName": "Kermit",
  "lastName": "the Frog",
  "email": "kermit@server.com",
  "password": "kermit"
}

API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().newUser(); ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().saveUser();
响应：
```
{
  "success": true
}
```

为群组添加用户

为群组添加用户，通过这个 REST 服务。

请求： POST /user/{userId}/groups
```
["management", "sales"]
```
API: identityService().createMembership(userId, groupId);
响应：
```
{
  "success": true
}
```

从群组删除用户

从群组删除用户。

请求： DELETE /user/{userId}/groups/{groupId}
API: identityService().deleteMembership(userId, groupId);
响应：
```
{
  "success": true
}
```

获得用户图片

返回用户图片

请求： GET /user/{userId}/picture
API: identityService.getUserPicture(userId);
响应：
```
The user picture.
```

获得群组

返回群组细节。

请求： GET /group/{groupId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().createGroupQuery().groupId(groupId).singleResult();

响应：

{
  "id": "admin",
  "name": "System administrator",
  "type": "security-role"
}

群组用户列表

返回一个群组的用户细节，可以通过"id", "firstName", "lastName" 或 "email"排序。

分页请求： GET /group/{groupId}/users
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getIdentityService().createUserQuery().memberOfGroup(groupId).list()

分页响应：

{
  data: [
    {
      "id": "kermit",
      "firstName": "Kermit",
      "lastName": "the Frog",
      "email": "kermit@server.com"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

查询群组

返回群组列表，通过查询的文本搜索 id 或 name。

分页请求： GET /groups?searchText=ad
API: identityService.createGroupQuery().list()

响应：

{
  data: [
    {
      "id": "admin",
      "name": "System administrator",
      "type": "security-role"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

创建群组

创建新群组。

请求： PUT /group

{
  "id": "admin",
  "name": "System administrator",
  "type": "security-role"
}

API: identityService.newGroup(); identityService.saveGroup();
响应：
```
{
  "success": true
}
```

为群组添加用户

为群组添加用户。

请求： POST /group/{groupId}/users
```
["kermit", "fozzie"]
```
API: identityService().createMembership(userId, groupId);
响应：
```
{
  "success": true
}
```

为群组删除用户

为群组删除用户。

请求： DELETE /group/{groupId}/users/{userId}
API: identityService().deleteMembership(userId, groupId);
响应：
```
{
  "success": true
}
```

管理

作业列表

返回分页的作业列表，可以通过"id", "process-instance-id", "execution-id", "due-date", "retries" 或一些自定义的属性 id 排序。列表可以通过 process instance id, due date 或作业是否重试，是否可执行，只是消息或定时器来查询。

分页请求： GET /management/jobs?process-instance={processInstanceId?}&with-retries-left={withRetriesLeft=false}&executable={axecutable=false}&only-timers={onlyTimers=false}&only-messages={onlyMessage=false}&duedate-lt={iso8601Date}&duedate-ltoe={iso8601Date}&duedate-ht={iso8601Date}&duedate-htoe={iso8601Date}&start={start=0}&size={size=10}&sort={sort=id}&order={order=asc}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).createJobQuery().xxx().listPage()

分页响应：

{
  "data": [
    {
      "id": "212",
      "executionId": "211",
      "retries": -1,
      "processInstanceId": "210",
      "dueDate": null,
      "assignee": null,
      "exceptionMessage": "Can\'t find scripting engine for \'groovy\'"
    }
  ],
  "total": 1,
  "start": 0,
  "sort": "id",
  "order": "asc",
  "size": 1
}

获得作业

返回作业的细节。

请求： GET /management/job({jobId}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).createJobQuery().id(jobId).singleResult()

响应：

{
  "id": "212",
  "executionId": "211",
  "retries": -1,
  "processInstanceId": "210",
  "dueDate": null,
  "assignee": null,
  "exceptionMessage": "Can\'t find scripting engine for \'groovy\'",
  "stacktrace": "org.activiti.engine.ActivitiException: Can't find scripting engine for 'groovy'\n\tat ..."
}

执行一个作业

执行一个作业。

请求： PUT /management/job/{jobId}/execute
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getManagementService().executeJob(jobId)
响应：
```
{
  "success": true
}
```

执行多个作业

执行多个作业。

请求： POST /management/jobs/execute
```
{
  "jobIds": [ "212" ]
}
```
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getManagementService().executeJob(jobId)
响应：
```
{
  "success": true
}
```

数据库表列表

返回引擎中的所有数据库表的元数据。

请求： GET /management/tables
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getManagementService().getTableCount()

响应：

{
  "data": [
    {
      "tableName": "ACT_GE_PROPERTY",
      "noOfResults": 2
    }
  ]
}

获得表元数据

返回一个数据库表的元数据。

请求： GET /management/table/{tableName}
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getManagementService().getTableMetaData(tableName))

响应：

{
  "tableName": "ACT_GE_PROPERTY",
  "columnNames": ["REV_","NAME_","VALUE_"],
  "columnNames": ["class java.lang.Integer", "class java.lang.String", "class java.lang.String"]
}

获得表数据

返回分页的数据库表数据列表。

分页请求： GET /management/table/{tableName}/data
API: ProcessEngines.getProcessEngine(configuredProcessEngineName).getManagementService().createTablePageQuery().tableName(tableName).start(start).size(size).orderXXX(sort).singleResult();

分页响应：

{
  "data": [
    {
      "NAME_": "schema.version",
      "REV_": "1",
      "VALUE_": "5.10"
    },
    {
      "NAME_": "next.dbid",
      "REV_": "4",
      "VALUE_": "310"
    }
  ],
  "total": 2,
  "start": 0,
  "sort": "NAME_",
  "order": "asc",
  "size": 2
}

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

列表为空，暂无数据