Flowable & Groovy

1. 操作流程变量

// 获取流程变量
def returnUser = execution.getVariable("returnUser")

// 设置流程变量，如果流程变量已存在，会用新值覆盖老值
execution.setVariable("forwardPayload", message_str)

execution的所有api可以在groovyTask中直接使用

2. 流程变量打包&解析操作

打包操作

import groovy.json.*
def deviceID=execution.getVariable("deviceId")
def alertDesc=execution.getVariable("alertDesc")
def moreinfo=execution.getVariable("moreinfo")
def reasons=execution.getVariable("reasons")
def suggest=execution.getVariable("suggest")
def fixComment=execution.getVariable("fixComment")
def message=[
        deviceID: deviceID,
        alertDesc: alertDesc,
        moreinfo: moreinfo,
        reasons: reasons,
        suggest: suggest,
        fixComment: fixComment
]

// 将对象变为字符串
def message_str=JsonOutput.toJson(message)
execution.setVariable("forwardPayload", message_str);

解析操作

```groovy
import groovy.json.*
def payload_str=execution.getVariable("forwardPayload")
def jsonSlurper = new JsonSlurper()
def payload = jsonSlurper.parseText(payload_str)

payload.each{entry -> 
   //动态设置多个流程变量
  execution.setVariable(entry.key,entry.value)
}

3. 日志打印

org.slf4j.LoggerFactory.getLogger(" it is a message from groovy ").info("after save is returnSum:${newReturnSum}");

4. 定义radio动态数据

// 定义一个三个选项的radio
def radiolist1=["严重","一般","轻微"]
// 要在表单定义中使用 ${dynamicRadio1}定义动态数据来自于流程变量
execution.setVariable("dynamicRadio1", radiolist1)


// 定义包含了两个选项，并且默认值得radio动态数据
def radiolist2=["男","女"]
// 要在表单定义中使用 ${dynamicRadio2}定义动态数据来自于流程变量
execution.setVariable("dynamicRadio2", radiolist2)
// delfaultRadio是表单定义中的组件的key，实现默认值
execution.setVariable("delfaultRadio", "男")

5. 定义select动态数据

// 定义三个选项的drop list，并且value等于label
def dynamicSelect1 = ["第一项","第二项","第三项"]
// 要在表单定义中使用 ${dynamicSelect1}定义动态数据来自于流程变量
execution.setVariable("dynamicSelect1", dynamicSelect1)

// 定义三个选项的drop list，并且制定了默认和
def dynamicSelect2 = ["今天","明天","后天"]
// 要在表单定义中使用 ${dynamicSelect2}定义动态数据来自于流程变量
execution.setVariable("dynamicSelect2", dynamicSelect2)
// defaultSelect是表单定义中的组件的key，实现默认值 
execution.setVariable("delfaultSelect", "后天")

// key与value不同的以及默认值得定义方式
def dynamicSelect3 = [
        [
                label: "矩阵革命",
                value: "revelo"
        ],
        [
                label: "明日帝国",
                value: "tomorrow"
        ],
        [
                label: "神奇女侠",
                value: "ww1984"
        ]

]
execution.setVariable("dynamicSelect3", dynamicSelect3)
execution.setVariable("delfaultSelect3", "ww1984")

6. Http请求

6.1 Get

def employee1 = new URL('http://dcom-http:8080/bj/employee/getCascaderForDisplay').text
// 或者 
def supply2 = 'http://dcom-http:8080/bj/supplier/getCascaderForFlow'.toURL().text
// 如果要使用get带参数，最好将参数内容通过urlencode编码，而且使用new url方式调用，例如
def sendcondLines_text = new URL('http://dcom-http:8080/bj/post/getSecondLineListByProfessionId?professionId='+URLEncoder.encode(professionId,'UTF-8')).text

6.2 Post

import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method


//开始借出时间，数据来自第一个表单填写
def rawGetUseTime=execution.getVariable("startDateTime");
// 注意格式，后台需要的是long类型，这里转换下

def getUseTimeDate = Date.parse( "yyyy-MM-dd HH:mm:ss",rawGetUseTime);
def getUseTime = getUseTimeDate.getTime();
// 借出人，来自流程的发起人，注意人员的代号不一样，后台程序要处理，转换
def borrowPersion=execution.getVariable("initiator");
// 借出的工具代号，是数组，结果来自第一个表单选择的结果
def toolIds=execution.getVariable("toolsID");
//所有参数
def params = [
"getUseTime": getUseTime,
"borrowPersion": borrowPersion,
"toolIds": toolIds
]
//访问的URL
def path = 'http://dcom-http:8080/bj/tool/rest/putout'

def http = new HTTPBuilder(path)
http.request(Method.POST) {
    requestContentType = ContentType.JSON
    body = params
    response.failure = { resp ->
        // 打印错误日志
        org.slf4j.LoggerFactory.getLogger("--->from groovy ").warn( "Request failed with status ${resp.status}")
    }
}

7. 操作JSON

import groovy.json.*


def jsonSlurper = new JsonSlurper()
def deviceProperty_string=execution.getVariable("scpchange");
// 从流程变量中获得数据,将字符串转换为json对象
def deviceProperty_json = jsonSlurper.parseText(deviceProperty_string)

// 动态构造keyname并读取其值
def key_name="keyname"
def runType_boolean=deviceProperty_json."${key_name}"

// 删除一个属性
deviceProperty_json.remove('removedkey')

// 最后把json转换为字符串
//很奇怪的是一个json 对象转换为字符串需要自己在前后增加双引号，否则提交时解析失败！
def deviceProperty = '"'+new JsonBuilder(deviceProperty_json).toString()+'"'

8. 使用List的json对象

// 后端java定义post的json对象内容为ArrayList时，需要增加注解
public class OnlyNotifyBean {
    @JsonFormat(with = JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
    private List<String> uids;  // 多选，通知谁，使用flowable认可的uid,其他信息自己关联查询
    @JsonFormat(with = JsonFormat.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY)
    private List<String> types; // 多选，可选的通知方式，比如电话，短信，APP，微信，钉钉等
    private String message; //具体通知内容
}


// 前端代码示例
import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method


//需要通知的人员，这里假设是项目经理级别，具体数值前面设定了
def uids=execution.getVariable("managers");



// 要通知的内容
def message='一线人员未能如期处理，已经通知二线人员处理'
//所有参数
def params = [
        "uids": uids, // 可以是多个人
        "types": ["GJ","SMS"],  // 可以有多种通知方式，假设有极光和短信，两种
        "message": message
]
//访问的URL
def path = 'http://dflow-notify:8080/notify'

def http = new HTTPBuilder(path)
http.request(Method.POST) {
    requestContentType = ContentType.JSON
    body = params
    response.failure = { resp ->
        // 打印错误日志
        org.slf4j.LoggerFactory.getLogger("--->from groovy ").warn( "Request failed with status ${resp.status}")
    }
}

9. 发送kafka消息

import org.apache.kafka.clients.producer.KafkaProducer
import org.apache.kafka.clients.producer.ProducerRecord
import org.apache.kafka.common.serialization.Serializer
import org.apache.kafka.common.serialization.StringSerializer

import groovy.json.JsonOutput

class JsonSerializer implements Serializer {
    @Override
    void configure(Map<String, ?> configs, boolean isKey) {
    }

    @Override
    byte[] serialize(String topic, data) {
        JsonOutput.toJson(data).getBytes('UTF-8')
    }

    @Override
    void close() {
    }
}

def props = [
        'bootstrap.servers': 'kafka-svc:9092',
        'key.serializer': StringSerializer,
        'value.serializer': JsonSerializer
]

def topic = 'channeldest'

def producer = new KafkaProducer(props)

def message=[
        desc: "it is desc",
        name: "it is name message"
    ]


    def record = new ProducerRecord(topic, 'starteventkey',message)

    // org.slf4j.LoggerFactory.getLogger("xiao test").info("Record  ${record}");
    def metadata = producer.send(record).get()

    // org.slf4j.LoggerFactory.getLogger("xiao test").info("Record sent to partition ${metadata.partition()}, with offset ${metadata.offset()}");

10. DCOM常用

10.1 生成工单号

def BaseNo = new URL('http://dcom-http:8080/bj/process/v3/getBaseNo?category=GYS').text
execution.setVariable("gysBaseNo", BaseNo);

10.2 供应商评价

import groovy.json.JsonSlurper
import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method

def jsonSlurper = new JsonSlurper()

// 取出流程变量中的供应商用户ID(流转)
def jjgyslxr = execution.getVariable("jjgyslxr")
// 取出流程变量中的实施人用户Name(显示)
def jjgysssrNEW = execution.getVariable("jjgysssrNEW")

def jjgyslxr_array = []
if (jjgyslxr.class.isArray()) {
    // 是数组，直接复制
    jjgyslxr_array = jjgyslxr
} else {
    // 从流程变量中获得数据,将字符串转换为json对象
    jjgyslxr_array = jsonSlurper.parseText(jjgyslxr).value
}

def jjgysssrNEW_array = []
if (jjgysssrNEW.class.isArray()) {
    // 是数组，直接复制
    jjgysssrNEW_array = jjgysssrNEW
} else {
    // 从流程变量中获得数据,将字符串转换为json对象
    jjgysssrNEW_array = jsonSlurper.parseText(jjgysssrNEW).value
}


def implementer = jjgysssrNEW_array.join(',')
def userID = jjgyslxr_array[0]
org.slf4j.LoggerFactory.getLogger("--->from groovydynamic userID ").info("userID:$userID")

// 查询专业ID
def supplier_JSON = new URL('http://dcom-http:8080/bj/appraise/getSupplier?supplierID=' + userID).text
def supplier = jsonSlurper.parseText(supplier_JSON)

// 定义评价对象
def params = [
        "supplierId"       : supplier.supplierID,
        "supplierName"     : supplier.supplierName,
        "baseNo"           : execution.getVariable("BaseNo"),
        "baseName"         : execution.getVariable("baseName"),
        "closeTime"        : new Date().time,
        "implementer"      : implementer,
        "appraise"         : execution.getVariable("appraise"),
        "appraiseDesc"     : execution.getVariable("jjgysjljyjNEW"),
        "processInstanceId": execution.getVariable("processInstanceId")
]

org.slf4j.LoggerFactory.getLogger("--->from groovydynamic appraise ").info("appraise:$params")


// 保存评价的URL
def path = 'http://dcom-http:8080/bj/appraise/add'

def http = new HTTPBuilder(path)
http.request(Method.POST) {
    requestContentType = ContentType.JSON
    body = params
    response.failure = { resp ->
        // 打印错误日志
        org.slf4j.LoggerFactory.getLogger("--->from groovy ").warn("Save appraise Request failed with status ${resp.status}")
    }
}

10.3 工具领用

10.3.1 出库领用

import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method
import groovy.json.*

//开始借出时间，数据来自第一个表单填写
def rawGetUseTime = execution.getVariable("startDateTime")
// 注意格式，后台需要的是long类型，这里转换下
def getUseTimeDate = Date.parse("yyyy-MM-dd HH:mm:ss", rawGetUseTime)
def getUseTime = getUseTimeDate.getTime()

// 借出人，来自流程的发起人，注意人员的代号不一样，后台程序要处理，转换
def borrowPersion = execution.getVariable("initiator")

// 借出的工具代号，是数组，结果来自第一个表单选择的结果
def org_toolIds = execution.getVariable("toolsID")

// 以前这里就是一个数组，现在是一个字符串，里面是json对象，对象里包含了label，也包含value，里面分别是显示和数据的数组
// 所以要进行判断和处理
def toolIds = []
if (org_toolIds.class.isArray()) {
    // 是数组，直接复制
    toolIds = org_toolIds
} else {
    // 不是数组，尝试转换为json对象并取得对象的结果
    def jsonSlurper = new JsonSlurper()
    // 从流程变量中获得数据,将字符串转换为json对象
    def toolIds_json = jsonSlurper.parseText(org_toolIds)

    toolIds = toolIds_json.value
    
}

// 保存一个新的流程变量，需要时一个数组，后面的多实例需要使用
execution.setVariable("toolsIDArray", toolIds)

//所有参数
def params = [
        "getUseTime"   : getUseTime,
        "borrowPersion": borrowPersion,
        "toolIds"      : toolIds
]
//访问的URL
def path = 'http://dcom-http:8080/bj/tool/rest/putout'

def http = new HTTPBuilder(path)
http.request(Method.POST) {
    requestContentType = ContentType.JSON
    body = params
    response.failure = { resp ->
        org.slf4j.LoggerFactory.getLogger("--->from groovy ").warn("Request failed with status ${resp.status}")
    }
}

10.3.2 汇总归还情况

returnUser = execution.getVariable("returnUser");
returnDate = execution.getVariable("returnDate");
returnItem = execution.getVariable("returnItem");
returnID = execution.getVariable("returnID");

return_desc=returnUser+" 于 "+returnDate+" 归还 "+returnItem+"\r\n";


returnSum = execution.getVariable("returnSum");
if (returnSum == null){returnSum=""}

org.slf4j.LoggerFactory.getLogger("--->from tools return  multi instance  ").info("returnUser:${returnUser}, returnDate:${returnDate},returnItem:${returnItem},returnID:${returnID},returnSum:${returnSum}");

newReturnSum = "${returnSum}${return_desc}".values;
execution.setVariable("returnSum", newReturnSum);
org.slf4j.LoggerFactory.getLogger("--->from tools return  multi instance  ").info("after save is returnSum:${newReturnSum}");

10.4 SCP变更

import com.fasterxml.jackson.databind.ObjectMapper
import groovyx.net.http.ContentType
import groovyx.net.http.HTTPBuilder
import groovyx.net.http.Method
import groovy.json.*

// scpchange 数据格式
//[{
//    "org": "{\"设备状态(开机:true,关机:false)\":false}",
//    "modify": "{\"设备状态(开机:true,关机:false)\":true}",
//    "label": "消防设备/消防报警系统/消防报警按钮（手报）/1楼消防报警按钮（手报）",
//    "value": "消防报警按钮（手报）/1楼消防报警按钮（手报）"
//}]

def jsonSlurper = new JsonSlurper()


// 解析SCP变更内容
def scpchangeVariable = execution.getVariable("scpchange")
def scpchange_json_array = jsonSlurper.parseText(scpchangeVariable)

scpchange_json_array.each {
    scpchange_json ->
        {
            // 解析设备ID
            def deviceId = scpchange_json.value.split("/")[1]

            // 解析设备状态
            def key_name = "设备状态(开机:true,关机:false)"
            def scpchange =  jsonSlurper.parseText(scpchange_json.modify)
            def runType_boolean = scpchange."${key_name}"
            int runType = runType_boolean ? 1 : 0

            // 解决中文显示unicode编码问题
            scpchange.remove(key_name)
            ObjectMapper mapper = new ObjectMapper();
            def deviceProperty = '"' + mapper.writeValueAsString(scpchange) + '"'

            //所有参数
            def params = [
                    "deviceId"      : deviceId,
                    "runType"       : runType,
                    "deviceProperty": deviceProperty
            ]
            org.slf4j.LoggerFactory.getLogger("------------->from groovy ").info("body ${params}")
            //访问的URL
            def path = 'http://dcom-http:8080/bj/scp/update'

            def http = new HTTPBuilder(path)
            http.request(Method.POST) {
                requestContentType = ContentType.JSON
                body = params
                response.failure = { resp ->
                    org.slf4j.LoggerFactory.getLogger("--->from groovy ").warn("Request failed with status ${resp.status}")
                }
            }
        }
}