容缺补办实现

xiangpei

2025-03-09 5b4e7ae2998e9c947f0f6b36aa6063aa9a5a7cb9

容缺补办实现

 business/src/main/java/com/ycl/controller/FlowTaskController.java

@@ -98,9 +98,9 @@
    }

    @ApiOperation(value = "查看任务", response = FormDetailVO.class)
    @GetMapping(value = "/detail/{taskId}")
    public AjaxResult detail(@ApiParam(value = "流程任务Id") @PathVariable(value = "taskId") String taskId) {
        return flowTaskService.detail(taskId);
    @GetMapping(value = "/detail/{processInsId}/{taskId}")
    public AjaxResult detail(@ApiParam(value = "流程实例Id") @PathVariable(value = "processInsId") String processInsId, @ApiParam(value = "流程任务Id") @PathVariable(value = "taskId") String taskId) {
        return flowTaskService.detail(processInsId, taskId);
    }


@@ -112,6 +112,14 @@
        return flowTaskService.completeSubmitForm(taskId, variables, Boolean.TRUE);
    }

    @ApiOperation(value = "容缺补交")
    @Log(title = "容缺补交", businessType = BusinessType.INSERT)
    @PostMapping("/wait/complete/form/{taskId}")
    public AjaxResult waitCompleteSubmitForm(@ApiParam(value = "流程定义id") @PathVariable(value = "taskId") String taskId,
                                         @ApiParam(value = "变量集合,json对象") @RequestBody Map<String, Object> variables) throws IOException {
        return flowTaskService.waitCompleteSubmitForm(taskId, variables, Boolean.TRUE);
    }

    @ApiOperation(value = "完成审批任务")
    @Log(title = "审批任务", businessType = BusinessType.UPDATE)
    @PostMapping(value = "/complete")

 business/src/main/java/com/ycl/domain/vo/FlowableVarVO.java

New file
@@ -0,0 +1,57 @@
package com.ycl.domain.vo;

import lombok.Data;

import java.util.Date;

/**
 * flowable变量
 *
 * @author：xp
 * @date：2025/3/9 19:07
 */
@Data
public class FlowableVarVO {

    private String ID_;

    /**
     * 流程实例id
     */
    private String PROC_INST_ID_;

    /**
     * 执行id
     */
    private String EXECUTION_ID_;

    /**
     * 变量key
     */
    private String NAME_;

    /**
     * 值类型
     */
    private String VAR_TYPE_;

    /**
     * 二进制数据id，一般就是json格式数据，如表单json
     */
    private String BYTEARRAY_ID_;

    private Double DOUBLE_;

    private Long LONG_;

    private String TEXT_;

    private String TEXT2_;

    private Date CREATE_TIME_;

    private Date LAST_UPDATED_TIME_;



}

 business/src/main/java/com/ycl/mapper/ProjectProcessMapper.java

@@ -5,6 +5,7 @@
import com.ycl.domain.entity.ProjectProcess;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ycl.domain.vo.FlowableVarVO;
import com.ycl.domain.vo.ProjectEngineeringVO;
import com.ycl.domain.vo.ProjectProcessVO;
import com.ycl.domain.form.ProjectProcessForm;
@@ -54,4 +55,32 @@
     * @return
     */
    List<String> getNormalInsIds();

    /**
     * 查询flowable中的某个变量的数据存储id
     *
     * @param processInsId
     * @param keyName
     * @return
     */
    FlowableVarVO getHisByteId(@Param("processInsId") String processInsId, @Param("keyName") String keyName);
    FlowableVarVO getRuByteId(@Param("processInsId") String processInsId, @Param("keyName") String keyName);

    /**
     * 保存flowable变量
     *
     * @param v
     */
    void insertHisFlowableVar(@Param("v") FlowableVarVO v);
    void insertRunFlowableVar(@Param("v") FlowableVarVO v);

    /**
     * 保存flowable变量值
     *
     * @param bytearray_id_
     * @param rev_
     * @param name_
     * @param objectToBytes
     */
    void insertByteArray(@Param("id_") String bytearray_id_, @Param("rev_") int rev_, @Param("name_") String name_, @Param("bytes_") Object objectToBytes);
}

 business/src/main/java/com/ycl/service/IFlowTaskService.java

@@ -4,6 +4,7 @@
import com.ycl.domain.vo.FlowQueryVo;
import com.ycl.domain.vo.FlowTaskVo;

import java.io.IOException;
import java.io.InputStream;
import java.util.Map;

@@ -225,11 +226,15 @@
     */
    AjaxResult completeSubmitForm(String taskId, Map<String, Object> variables, Boolean addLog);

    AjaxResult waitCompleteSubmitForm(String taskId, Map<String, Object> variables, Boolean addLog) throws IOException;

    /**
     * 查看任务
     *
     *
     * @param processInsId
     * @param taskId
     * @return
     */
    AjaxResult detail(String taskId);
    AjaxResult detail(String processInsId, String taskId);
}

 business/src/main/java/com/ycl/service/impl/FlowTaskServiceImpl.java

@@ -51,6 +51,7 @@
import org.flowable.bpmn.model.*;
import org.flowable.common.engine.api.FlowableException;
import org.flowable.common.engine.api.FlowableObjectNotFoundException;
import org.flowable.common.engine.impl.persistence.StrongUuidGenerator;
import org.flowable.engine.ProcessEngineConfiguration;
import org.flowable.engine.history.HistoricActivityInstance;
import org.flowable.engine.history.HistoricProcessInstance;
@@ -70,10 +71,11 @@
import org.flowable.task.api.history.HistoricTaskInstanceQuery;
import org.springframework.beans.BeanUtils;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.InputStream;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.*;
@@ -186,6 +188,134 @@
                    null));
        }
        return AjaxResult.success("提交成功");
    }

    /**
     * 容缺补交
     *
     * @param taskId    任务id
     * @param variables 表单数据
     * @param addLog
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult waitCompleteSubmitForm(String taskId, Map<String, Object> variables, Boolean addLog) throws IOException {
        List<HistoricTaskInstance> hisTasks = historyService.createHistoricTaskInstanceQuery().taskId(taskId).orderByHistoricTaskInstanceStartTime().desc().list();
        if (CollectionUtils.isEmpty(hisTasks) || Objects.isNull(hisTasks.get(0))) {
            return AjaxResult.error("任务不存在");
        }
        HistoricTaskInstance task = hisTasks.get(0);
        ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(projectProcessMapper)
                .eq(ProjectProcess::getProcessInsId, task.getProcessInstanceId())
                .eq(ProjectProcess::getProcessDefId, task.getProcessDefinitionId())
                .one();
        if (Objects.isNull(projectProcess)) {
            return AjaxResult.error("项目流程未绑定");
        }
        // 查出字典中需要注入的字段信息
        List<String> dictList = sysDictDService.selectDictDataByType("flow_variables").stream().map(SysDictData::getDictValue).collect(Collectors.toList());
        Map<String, Object> newV = new HashMap<>(2);
        if (!org.springframework.util.CollectionUtils.isEmpty(variables)) {
            for (String key : variables.keySet()) {
                newV.put(task.getTaskDefinitionKey() + "&" + key, variables.get(key));
                // 字典里有就不做处理
                if (!CollectionUtils.isEmpty(dictList) && dictList.contains(key)) {
                    newV.put(key,variables.get(key));
                }
            }
        }
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
        Date now = new Date();
        for (String key : newV.keySet()) {
            FlowableVarVO var = null;
            if (Objects.isNull(processInstance)) {
                // 查询历史流程变量
                var = projectProcessMapper.getHisByteId(projectProcess.getProcessInsId(), key);
            } else {
                // 查询运行时流程变量
                var = projectProcessMapper.getRuByteId(projectProcess.getProcessInsId(), key);
            }

            if (Objects.isNull(var)) {
                // 没有这个变量新增即可
                FlowableVarVO run = new FlowableVarVO();
                FlowableVarVO v = new FlowableVarVO();
                v.setNAME_(key);
                v.setPROC_INST_ID_(task.getProcessInstanceId());
                v.setEXECUTION_ID_(task.getProcessInstanceId());
                v.setCREATE_TIME_(now);
                v.setLAST_UPDATED_TIME_(now);
                v.setID_(new StrongUuidGenerator().getNextId());

                BeanUtils.copyProperties(v, run);
                run.setID_(new StrongUuidGenerator().getNextId());
                if (newV.get(key) instanceof String) {
                    v.setVAR_TYPE_("string");
                    v.setTEXT_((String) newV.get(key));
                    run.setVAR_TYPE_("string");
                    run.setTEXT_((String) newV.get(key));
                } else if (newV.get(key) instanceof Integer) {
                    v.setVAR_TYPE_("integer");
                    v.setLONG_((Long) newV.get(key));
                    v.setTEXT_((String) newV.get(key));
                    run.setVAR_TYPE_("integer");
                    run.setLONG_((Long) newV.get(key));
                    run.setTEXT_((String) newV.get(key));
                } else if (newV.get(key) instanceof Long) {
                    v.setVAR_TYPE_("long");
                    v.setLONG_((Long) newV.get(key));
                    v.setTEXT_((String) newV.get(key));
                    run.setVAR_TYPE_("long");
                    run.setLONG_((Long) newV.get(key));
                    run.setTEXT_((String) newV.get(key));
                } else if (newV.get(key) instanceof Boolean) {
                    v.setVAR_TYPE_("boolean");
                    v.setLONG_((Long) newV.get(key));
                    v.setTEXT_((String) newV.get(key));
                    run.setVAR_TYPE_("boolean");
                    run.setLONG_((Long) newV.get(key));
                    run.setTEXT_((String) newV.get(key));
                } else {
                    // 其它类型的表单数据：如图片、文件单独存表的。历史、运行中的流程需各存一份
                    v.setVAR_TYPE_("serializable");
                    v.setBYTEARRAY_ID_(new StrongUuidGenerator().getNextId());
                    projectProcessMapper.insertByteArray(v.getBYTEARRAY_ID_(), 1, "hist.var-" + key, newV.get(key));

                    run.setVAR_TYPE_("serializable");
                    run.setBYTEARRAY_ID_(new StrongUuidGenerator().getNextId());
                    projectProcessMapper.insertByteArray(run.getBYTEARRAY_ID_(), 1, "var-" + key, newV.get(key));
                }

                projectProcessMapper.insertHisFlowableVar(v);
                projectProcessMapper.insertRunFlowableVar(run);
            }
        }
        // 保存日志
        publisher.publishEvent(new TaskLogEvent(this, null,
                SecurityUtils.getUserId(),
                projectProcess.getProjectId(),
                projectProcess.getProcessInsId(),
                taskId,
                task.getTaskDefinitionKey(),
                task.getName(),
                ProcessLogEventTypeEnum.FINISHED,
                null));

        return AjaxResult.success("提交成功");
    }

    // 将对象转换为 byte[]
    public static byte[] objectToBytes(Object obj) throws IOException {
        if (Objects.isNull(obj)) {
            return null;
        }
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            oos.writeObject(obj); // 序列化对象
            oos.flush();
            return bos.toByteArray(); // 返回字节数组
        }
    }

    /**
@@ -1320,24 +1450,30 @@
    }

    @Override
    public AjaxResult detail(String taskId) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
    public AjaxResult detail(String processInsId, String taskId) {
        ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().includeProcessVariables().processInstanceId(processInsId).singleResult();
        // 流程变量
        Map<String, Object> parameters = new HashMap<>();
        if (Objects.isNull(task)) {
            // 如果为空，可能是任务已经结束
        if (Objects.isNull(processInstance)) {

            // 如果为空，表明流程已经结束
            HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery().includeProcessVariables().processInstanceId(processInsId).singleResult();
            if (Objects.isNull(historicProcessInstance)) {
                throw new RuntimeException("流程不存在");
            }

            List<HistoricTaskInstance> hisTasks = historyService.createHistoricTaskInstanceQuery()
                    .taskId(taskId)
                    .finished()
                    .includeProcessVariables()
                    .orderByTaskCreateTime()
                    .orderByHistoricTaskInstanceStartTime()
                    .desc()
                    .list();
            if (CollectionUtils.isNotEmpty(hisTasks) && Objects.isNull(hisTasks.get(0))) {
                throw new RuntimeException("该任务不存在");
            }
            HistoricTaskInstance hisTask = hisTasks.get(0);
            parameters = hisTask.getProcessVariables();
            parameters = historicProcessInstance.getProcessVariables();
            List<FormDetailVO> beforeNodes = this.getBeforeNodeForm(parameters, hisTask.getFormKey(), hisTask.getName(), hisTask.getProcessDefinitionId(), hisTask.getTaskDefinitionKey(), Boolean.TRUE);
            List<FormDetailVO> dataList = new ArrayList<>(2);
            Map<String, List<FormDetailVO>> map = new HashMap<>(2);
@@ -1389,8 +1525,25 @@
            }).collect(Collectors.toList());
            return AjaxResult.success(vos);
        } else {
            parameters = taskService.getVariables(taskId);
            List<FormDetailVO> beforeNodes = this.getBeforeNodeForm(parameters, task.getFormKey(), task.getName(), task.getProcessDefinitionId(), task.getTaskDefinitionKey(), Boolean.TRUE);
            parameters = processInstance.getProcessVariables();
            Task task = taskService.createTaskQuery().taskId(taskId).processInstanceId(processInsId).singleResult();
            List<FormDetailVO> beforeNodes = new ArrayList<>();
            if (Objects.nonNull(task)) {
                beforeNodes = this.getBeforeNodeForm(parameters, task.getFormKey(), task.getName(), task.getProcessDefinitionId(), task.getTaskDefinitionKey(), Boolean.TRUE);
            } else {
                List<HistoricTaskInstance> hisTasks = historyService.createHistoricTaskInstanceQuery()
                        .taskId(taskId)
                        .finished()
                        .includeProcessVariables()
                        .orderByHistoricTaskInstanceStartTime()
                        .desc()
                        .list();
                if (CollectionUtils.isNotEmpty(hisTasks) && Objects.isNull(hisTasks.get(0))) {
                    throw new RuntimeException("该任务不存在");
                }
                HistoricTaskInstance hisTask = hisTasks.get(0);
                beforeNodes = this.getBeforeNodeForm(parameters, hisTask.getFormKey(), hisTask.getName(), hisTask.getProcessDefinitionId(), hisTask.getTaskDefinitionKey(), Boolean.TRUE);
            }
            List<FormDetailVO> dataList = new ArrayList<>(2);
            Map<String, List<FormDetailVO>> map = new HashMap<>(2);
            beforeNodes.stream().forEach(node -> {
@@ -1398,7 +1551,7 @@
                    dataList.add(node);
                } else {
                    List<HistoricTaskInstance> beforeTasks = historyService.createHistoricTaskInstanceQuery()
                            .processInstanceId(task.getProcessInstanceId())
                            .processInstanceId(processInsId)
                            .finished()
                            .taskDefinitionKey(node.getBeforeNodeDefId())
                            .orderByTaskCreateTime()
@@ -1422,14 +1575,14 @@
            }
            List<DoFormDetailVO> vos = dataList.stream().map(node -> {
                if (node.getCurrent()) {
                    if (processLogService.taskIsHangup(taskId, task.getProcessInstanceId())) {
                    if (processLogService.taskIsHangup(taskId, processInsId)) {
                        node.setTaskStatus(TaskStatusEnum.HANGUP);
                    }
                }
                // 判断任务是否存在特殊操作(如跳过、转办等)，需要在前端展示出来
                ProcessLogQuery query = new ProcessLogQuery();
                query.setTaskDefKey(node.getUserTask().getId());
                query.setProcessInsId(task.getProcessInstanceId());
                query.setProcessInsId(processInsId);
                Result result = processLogService.projectProcessLogPage(query);
                List<ProcessLogVO> logList = (List<ProcessLogVO>) result.get("data");
                DoFormDetailVO vo = new DoFormDetailVO();

 business/src/main/resources/mapper/ProjectProcessMapper.xml

@@ -178,4 +178,27 @@
        SELECT TPP.process_ins_id FROM t_project_engineering TPE INNER JOIN t_project_process TPP ON TPE.id = TPP.project_id AND TPE.deleted = 0 AND TPP.project_type = 'ENGINEERING'
    </select>

    <select id="getHisByteId" resultType="com.ycl.domain.vo.FlowableVarVO">
        SELECT ID_, PROC_INST_ID_, EXECUTION_ID_, NAME_, VAR_TYPE_, BYTEARRAY_ID_ FROM act_hi_varinst WHERE PROC_INST_ID_ = #{processInsId} AND NAME_ = #{keyName}
    </select>

    <select id="getRuByteId" resultType="com.ycl.domain.vo.FlowableVarVO">
        SELECT ID_, PROC_INST_ID_, EXECUTION_ID_, NAME_, TYPE_ as VAR_TYPE_, BYTEARRAY_ID_ FROM act_ru_variable WHERE PROC_INST_ID_ = #{processInsId} AND NAME_ = #{keyName}
    </select>


    <insert id="insertHisFlowableVar" parameterType="com.ycl.domain.vo.FlowableVarVO">
        insert into act_hi_varinst(ID_,REV_, PROC_INST_ID_, EXECUTION_ID_, NAME_, VAR_TYPE_,BYTEARRAY_ID_,DOUBLE_,LONG_, TEXT_, CREATE_TIME_, LAST_UPDATED_TIME_)
        values (#{v.ID_}, 0,  #{v.PROC_INST_ID_}, #{v.EXECUTION_ID_}, #{v.NAME_}, #{v.VAR_TYPE_}, #{v.BYTEARRAY_ID_}, #{v.DOUBLE_}, #{v.LONG_}, #{v.TEXT_}, #{v.CREATE_TIME_}, #{v.LAST_UPDATED_TIME_})
    </insert>

    <insert id="insertRunFlowableVar" parameterType="com.ycl.domain.vo.FlowableVarVO">
        insert into act_ru_variable(ID_,REV_, PROC_INST_ID_, EXECUTION_ID_, NAME_, TYPE_,BYTEARRAY_ID_,DOUBLE_,LONG_, TEXT_)
        values (#{v.ID_}, 1,  #{v.PROC_INST_ID_}, #{v.EXECUTION_ID_}, #{v.NAME_}, #{v.VAR_TYPE_}, #{v.BYTEARRAY_ID_}, #{v.DOUBLE_}, #{v.LONG_}, #{v.TEXT_})
    </insert>

    <insert id="insertByteArray">
        insert into act_ge_bytearray(ID_, REV_, NAME_, BYTES_) values (#{id_}, #{rev_}, #{name_}, #{bytes_, jdbcType=BLOB})
    </insert>

</mapper>