Merge remote-tracking branch 'origin/master'

luohairen

2024-12-05 cea2ecb470537a52e6a17d09703a9f770b220cdf

Merge remote-tracking branch 'origin/master'

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

@@ -74,6 +74,13 @@
        return projectProcessService.taskList(query);
    }

    @GetMapping("/detail/task/is/auditing")
    @ApiOperation(value = "获取任务是否是审批节点", notes = "获取任务是否是审批节点")
//    @PreAuthorize("@ss.hasPermi('projectProcess:detail')")
    public Result taskIsAuditing(String processDefId, String taskId) {
        return projectProcessService.taskIsAuditing(processDefId, taskId);
    }


    @GetMapping("/to_do_task")
    @ApiOperation(value = "分页", notes = "分页")

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

@@ -1,5 +1,6 @@
package com.ycl.domain.vo;

import com.ycl.common.enums.business.HandlerTypeEnum;
import com.ycl.common.enums.business.TaskStatusEnum;
import lombok.Data;

@@ -108,4 +109,10 @@
     * 任务创建时间
     */
    private Date createTime;

    /**
     * 处理人类型
     *
     */
    private HandlerTypeEnum handlerType;
}

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

@@ -69,4 +69,13 @@
    void getAllTodoTask(String taskName, int pageSize, int pageNum, Result result);

    Result detailByProcessInsId(TaskQuery query);

    /**
     * 查询是否是审批任务
     *
     * @param processDefinitionId 流程定义id
     * @param processDefinitionId 任务id
     * @return
     */
    Result taskIsAuditing(String processDefinitionId, String taskId);
}

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

@@ -12,6 +12,7 @@
import com.ycl.common.core.domain.entity.SysRole;
import com.ycl.common.core.domain.entity.SysUser;
import com.ycl.common.enums.FlowComment;
import com.ycl.common.enums.business.HandlerTypeEnum;
import com.ycl.common.enums.business.TaskStatusEnum;
import com.ycl.common.utils.SecurityUtils;
import com.ycl.constant.TaskTypeConstant;
@@ -52,6 +53,7 @@
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.stream.Collectors;
@@ -286,6 +288,7 @@
            for (IdentityLink identityLink : identityLinksForTask) {
                // 绑定的是用户，查出用户姓名、部门
                if (StringUtils.isNotBlank(identityLink.getUserId())) {
                    taskVO.setHandlerType(HandlerTypeEnum.USER);
                    SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                    if (Objects.nonNull(sysUser)) {
                        taskVO.setHandlerId(sysUser.getUserId());
@@ -295,14 +298,30 @@
                        }
                        taskVO.setHandlerName(sysUser.getNickName());
                    }
                    // 绑定的是角色，查出角色名称
                    // 绑定的是角色或者部门
                } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                    SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                    if (Objects.nonNull(role)) {
                        taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
                        taskVO.setHandlerUnitName("由拥有角色：【" + role.getRoleName() + "】的人处理");
                        taskVO.setHandlerName("暂未处理");
                        taskVO.setHandlerId(null);
                    if (identityLink.getGroupId().startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                        taskVO.setHandlerType(HandlerTypeEnum.DEPT);
                        String[] split = identityLink.getGroupId().split(":");
                        if (split.length > 1) {
                            // 部门
                            SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
                            if (Objects.nonNull(dept)) {
                                taskVO.setHandlerUnitId(dept.getDeptId());
                                taskVO.setHandlerUnitName(dept.getDeptName());
                                taskVO.setHandlerName("暂未处理");
                                taskVO.setHandlerId(null);
                            }
                        }
                    } else {
                        taskVO.setHandlerType(HandlerTypeEnum.ROLE);
                        SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                        if (Objects.nonNull(role)) {
                            taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
                            taskVO.setHandlerUnitName("由拥有角色：【" + role.getRoleName() + "】的人处理");
                            taskVO.setHandlerName("暂未处理");
                            taskVO.setHandlerId(null);
                        }
                    }
                }
            }
@@ -318,6 +337,30 @@
                .eq(ProjectProcess::getProcessDefId, query.getProcessDefId())
                .list();
        return Result.ok().data(list);
    }

    @Override
    public Result taskIsAuditing(String processDefinitionId, String taskId) {
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
        Collection<Process> processes = bpmnModel.getProcesses();
        for (Process process : processes) {
            Collection<FlowElement> flowElements = process.getFlowElements();
            for (FlowElement flowElement : flowElements) {
                if (flowElement instanceof UserTask) {
                    UserTask userTask = (UserTask) flowElement;
                    List<ExtensionElement> extensionElements = userTask.getExtensionElements().get("flowable:properties");
                    if (! CollectionUtils.isEmpty(extensionElements)) {
                        for (ExtensionElement extensionElement : extensionElements) {
                            String fieldName = extensionElement.getAttributeValue(taskId,"name");
                            String fieldValue = extensionElement.getAttributeValue(taskId,"value");
                            System.out.println("Field Name: " + fieldName + ", Field Value: " + fieldValue);
                        }
                    }
                }

            }
        }
        return null;
    }

    /**
@@ -373,6 +416,7 @@
            for (IdentityLink identityLink : identityLinksForTask) {
                // 绑定的是用户，查出用户姓名、部门
                if (StringUtils.isNotBlank(identityLink.getUserId())) {
                    taskVO.setHandlerType(HandlerTypeEnum.USER);
                    SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
                    if (Objects.nonNull(sysUser)) {
                        taskVO.setHandlerId(sysUser.getUserId());
@@ -385,6 +429,7 @@
                    // 绑定的是角色或者部门
                } else if (StringUtils.isNotBlank(identityLink.getGroupId())) {
                    if (identityLink.getGroupId().startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                        taskVO.setHandlerType(HandlerTypeEnum.DEPT);
                        String[] split = identityLink.getGroupId().split(":");
                        if (split.length > 1) {
                            // 部门
@@ -397,6 +442,7 @@
                            }
                        }
                    } else {
                        taskVO.setHandlerType(HandlerTypeEnum.ROLE);
                        SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
                        if (Objects.nonNull(role)) {
                            taskVO.setHandlerUnitId(Long.parseLong(identityLink.getGroupId()));
@@ -426,7 +472,6 @@
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
        result.total(allUserTaskElement.size());
        if (startNum >= allUserTaskElement.size()) {
            // 如果起始索引超出了列表的大小，返回一个空列表
            return new ArrayList<>();
@@ -435,6 +480,7 @@
            // 模拟模糊查询
            allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
        }
        result.total(allUserTaskElement.size());
        int end = Math.min(endNum, allUserTaskElement.size());
        List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);
        // 查出流程
@@ -458,6 +504,7 @@
                if (Objects.isNull(historicTask)) {
                    // 未开始的任务，其关联的用户组这些都可以从UserTask中拿到，因为本身未开始的任务是没有task的，所以这里直接查
                    if (StringUtils.isNotBlank(userTask.getAssignee())) {
                        vo.setHandlerType(HandlerTypeEnum.USER);
                        SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
                        if (Objects.nonNull(sysUser)) {
                            vo.setHandlerId(sysUser.getUserId());
@@ -468,6 +515,7 @@
                    } else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
                        String groupId = userTask.getCandidateGroups().get(0);
                        if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                            vo.setHandlerType(HandlerTypeEnum.DEPT);
                            String[] split = groupId.split(":");
                            if (split.length > 1) {
                                // 部门
@@ -480,6 +528,7 @@
                                }
                            }
                        } else {
                            vo.setHandlerType(HandlerTypeEnum.ROLE);
                            SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
                            if (Objects.nonNull(role)) {
                                vo.setHandlerUnitId(Long.parseLong(groupId));
@@ -533,7 +582,7 @@
        int startNum = pageSize * (pageNum - 1);
        int endNum = startNum + pageSize;
        List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
        result.total(allUserTaskElement.size());

        if (startNum >= allUserTaskElement.size()) {
            // 如果起始索引超出了列表的大小，返回一个空列表
            return new ArrayList<>();
@@ -542,6 +591,7 @@
            // 模拟模糊查询
            allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
        }
        result.total(allUserTaskElement.size());
        int end = Math.min(endNum, allUserTaskElement.size());
        List<UserTask> userTasks = allUserTaskElement.subList(startNum, end);
        // 查出流程
@@ -565,6 +615,7 @@
                if (Objects.isNull(historicTask)) {
                    // 未开始的任务，其关联的用户组这些都可以从UserTask中拿到，因为本身未开始的任务是没有task的，所以这里直接查
                    if (StringUtils.isNotBlank(userTask.getAssignee())) {
                        vo.setHandlerType(HandlerTypeEnum.USER);
                        SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
                        if (Objects.nonNull(sysUser)) {
                            vo.setHandlerId(sysUser.getUserId());
@@ -575,6 +626,7 @@
                    } else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
                        String groupId = userTask.getCandidateGroups().get(0);
                        if (groupId.startsWith("dept")) {   // 部门的id是加了前缀的如：dept:1
                            vo.setHandlerType(HandlerTypeEnum.DEPT);
                            String[] split = groupId.split(":");
                            if (split.length > 1) {
                                // 部门
@@ -587,6 +639,7 @@
                                }
                            }
                        } else {
                            vo.setHandlerType(HandlerTypeEnum.ROLE);
                            SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
                            if (Objects.nonNull(role)) {
                                vo.setHandlerUnitId(Long.parseLong(groupId));

 common/src/main/java/com/ycl/common/enums/business/HandlerTypeEnum.java

New file
@@ -0,0 +1,29 @@
package com.ycl.common.enums.business;

import com.fasterxml.jackson.annotation.JsonValue;
import lombok.Getter;

/**
 * 任务处理人类型
 *
 * @author：xp
 * @date：2024/11/29 11:13
 */
@Getter
public enum HandlerTypeEnum {

    USER("USER", "用户"),
    DEPT("DEPT", "部门"),
    ROLE("ROLE", "角色")
    ;

    @JsonValue
    private final String value;

    private final String desc;

    HandlerTypeEnum(String value, String desc) {
        this.value = value;
        this.desc = desc;
    }
}

 flowable/src/main/java/com/ycl/common/constant/ProcessConstants.java

@@ -76,5 +76,18 @@
     */
    public static final String FLOWABLE_SKIP_EXPRESSION_ENABLED = "_FLOWABLE_SKIP_EXPRESSION_ENABLED";

    /**
     * 表单信息key
     *
     */
    public static final String TASK_FORM_KEY = "formJson";


    /**
     * 表单配套，暂时不知道是啥
     *
     */
    public static final String WIDGET_LIST = "widgetList";


}

 flowable/src/main/java/com/ycl/domain/vo/FormDetailVO.java

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

import com.alibaba.fastjson2.JSONObject;
import lombok.Data;

import java.util.Map;

/**
 * 处理下一个任务时，回显前置任务的表单(包含本节点的表单)
 *
 * @author：xp
 * @date：2024/12/5 0:35
 */
@Data
public class FormDetailVO {


    /**
     * 是否当前节点的表单
     *
     */
    private Boolean current = false;

    /**
     * 前置节点定义id
     *
     */
    private String beforeNodeDefId;

    /**
     * 前置节点名称（任务名称）
     *
     */
    private String beforeNodeName;

    /**
     * 前置节点表单数据
     *
     */
    private Map<String, Object> formJsonObj;


}

 flowable/src/main/java/com/ycl/service/common/TaskCommonService.java

New file
@@ -0,0 +1,117 @@
package com.ycl.service.common;

import com.alibaba.fastjson2.JSONObject;
import com.ycl.common.constant.ProcessConstants;
import com.ycl.domain.entity.SysForm;
import com.ycl.domain.vo.FormDetailVO;
import com.ycl.flow.FindNextNodeUtil;
import com.ycl.service.ISysFormService;
import lombok.RequiredArgsConstructor;
import org.flowable.bpmn.model.*;
import org.flowable.bpmn.model.Process;
import org.flowable.engine.RepositoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.repository.ProcessDefinition;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.*;

/**
 * @author：xp
 * @date：2024/12/4 23:22
 */
@Service
@RequiredArgsConstructor
public class TaskCommonService {

    private final RuntimeService runtimeService;
    private final RepositoryService repositoryService;

    /**
     * 通过当前节点定义key，获取其上一个节点的定义id，如果前面是并行的会返回多个
     *
     * @param processDefId 流程定义id
     * @param currentNodeDefId
     * @return
     */
    public List<FormDetailVO> getBeforeNodeDefId(String processDefId, String currentNodeDefId, ISysFormService sysFormService) {
        // 获取流程定义
        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery()
                .processDefinitionId(processDefId)
                .singleResult();

        // 获取流程模型
        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefId);
        if (bpmnModel == null) {
            throw new RuntimeException("BpmnModel not found for processDefinitionId: " + processDefId);
        }

        // 获取流程对象
        Process process = bpmnModel.getProcessById(processDefinition.getKey());
        if (process == null) {
            throw new RuntimeException("Process not found for processDefinitionId: " + processDefId);
        }

        // 遍历流程元素，找到对应的任务节点
        Collection<FlowElement> flowElements = process.getFlowElements();
        UserTask currentElement = null;
        for (FlowElement flowElement : flowElements) {
            if (flowElement instanceof UserTask && flowElement.getId().equals(currentNodeDefId)) {
                currentElement = (UserTask) flowElement;
                break;
            }
        }
        if (Objects.isNull(currentElement)) {
            throw new RuntimeException("未找到改任务的流程定义节点");
        }

        // 获取当前节点的输入
        List<FormDetailVO> defKeys = new ArrayList<>(2);
        if (StringUtils.hasText(currentElement.getFormKey())) {
            FormDetailVO formDetailVO = new FormDetailVO();
            formDetailVO.setBeforeNodeDefId(currentElement.getId());
            formDetailVO.setBeforeNodeName(currentElement.getName());
            formDetailVO.setCurrent(Boolean.TRUE);

            SysForm sysForm = sysFormService.selectSysFormById(Long.parseLong(currentElement.getFormKey()));
            if (Objects.isNull(sysForm)) {
                throw new RuntimeException("该流程绑定的表单不存在或已被删除");
            }
            Map<String, Object> data = new HashMap<>(1);
            data.put(ProcessConstants.TASK_FORM_KEY, JSONObject.parseObject(sysForm.getFormContent()));

            formDetailVO.setFormJsonObj(data);
            defKeys.add(formDetailVO);
        }
        this.before(currentElement, defKeys);

        return defKeys;
    }

    /**
     * 递归获取当前节点的前一个任务节点key
     *
     * @param currentElement
     * @param defKeys
     */
    private void before(UserTask currentElement, List<FormDetailVO> defKeys) {
        if (! CollectionUtils.isEmpty(currentElement.getIncomingFlows())) {
            for (SequenceFlow incomingFlow : currentElement.getIncomingFlows()) {
                if (! (incomingFlow.getSourceFlowElement() instanceof UserTask)) {
                    // 不包含开始节点
                    if (! (incomingFlow.getSourceFlowElement() instanceof StartEvent)) {
                        before((UserTask) (incomingFlow.getSourceFlowElement()), defKeys);
                    }
                } else {
                    FormDetailVO formDetailVO = new FormDetailVO();
                    formDetailVO.setBeforeNodeDefId(incomingFlow.getSourceFlowElement().getId());
                    formDetailVO.setBeforeNodeName(incomingFlow.getSourceFlowElement().getName());
                    defKeys.add(formDetailVO);
                }
            }
        }
    }

}

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

@@ -19,6 +19,7 @@
import com.ycl.domain.entity.SysForm;
import com.ycl.domain.vo.FlowQueryVo;
import com.ycl.domain.vo.FlowTaskVo;
import com.ycl.domain.vo.FormDetailVO;
import com.ycl.factory.FlowServiceFactory;
import com.ycl.flow.CustomProcessDiagramGenerator;
import com.ycl.flow.FindNextNodeUtil;
@@ -26,6 +27,7 @@
import com.ycl.service.IFlowTaskService;
import com.ycl.service.ISysDeployFormService;
import com.ycl.service.ISysFormService;
import com.ycl.service.common.TaskCommonService;
import com.ycl.system.service.ISysRoleService;
import com.ycl.system.service.ISysUserService;
import lombok.RequiredArgsConstructor;
@@ -80,6 +82,7 @@
    private final ISysRoleService sysRoleService;
    private final ISysDeployFormService sysInstanceFormService;
    private final ISysFormService sysFormService;
    private final TaskCommonService taskCommonService;

    /**
     * 完成审核任务
@@ -119,10 +122,21 @@
        if (Objects.isNull(task)) {
            return AjaxResult.error("任务不存在");
        }
        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 (ProcessConstants.TASK_FORM_KEY.equals(key)) {
//                    newV.put(task.getTaskDefinitionKey() + "_" + ProcessConstants.TASK_FORM_KEY, variables.get(key));
//                } else if (ProcessConstants.WIDGET_LIST.equals(key)){
//                    newV.put(task.getTaskDefinitionKey() + "_" + ProcessConstants.WIDGET_LIST, variables.get(key));
//                }
            }
        }
        // 先让当前用户认领这个任务
        taskService.claim(taskId, SecurityUtils.getUserId() + "");
        taskService.addComment(taskId, task.getProcessInstanceId(), FlowComment.SUBMIT.getType(), "完成提交");
        taskService.complete(taskId, variables);
        taskService.complete(taskId, newV);
        return AjaxResult.success("提交成功");
    }

@@ -1135,41 +1149,83 @@
        } else {
            parameters = taskService.getVariables(taskId);
        }

        JSONObject oldVariables = JSONObject.parseObject(JSON.toJSONString(parameters.get("formJson")));
        if (Objects.isNull(oldVariables)) {
            // 如果是空的，直接使用主表单，因为这代表是流程中的第一个提交表单的任务
            String deploymentId = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult().getDeploymentId();
            return this.flowFormData(deploymentId);
        if (! parameters.keySet().stream().anyMatch(key -> key.contains(ProcessConstants.TASK_FORM_KEY))) {
            // 如果是空的，使用formId去查
            if (StringUtils.isNotBlank(task.getFormKey())) {
                SysForm sysForm = sysFormService.selectSysFormById(Long.parseLong(task.getFormKey()));
                if (Objects.isNull(sysForm)) {
                    throw new RuntimeException("该流程绑定的表单不存在或已被删除");
                }
                FormDetailVO formDetailVO = new FormDetailVO();
                Map<String, Object> data = new HashMap<>(1);
                data.put(ProcessConstants.TASK_FORM_KEY, JSONObject.parseObject(sysForm.getFormContent()));
                formDetailVO.setFormJsonObj(data);
                formDetailVO.setBeforeNodeName(task.getName());
                formDetailVO.setCurrent(Boolean.TRUE);
                return AjaxResult.success(Arrays.asList(formDetailVO));
            } else {
                return AjaxResult.success(new ArrayList<>(1));
            }
        }
        List<JSONObject> oldFields = JSON.parseObject(JSON.toJSONString(oldVariables.get("widgetList")), new TypeReference<List<JSONObject>>() {
        });
        // 设置已填写的表单为禁用状态
        for (JSONObject oldField : oldFields) {
            JSONObject options = oldField.getJSONObject("options");
            options.put("disabled", true);
        }
        // TODO 暂时只处理用户任务上的表单
        if (StringUtils.isNotBlank(task.getFormKey())) {
            SysForm sysForm = sysFormService.selectSysFormById(Long.parseLong(task.getFormKey()));
            JSONObject data = JSONObject.parseObject(sysForm.getFormContent());
            List<JSONObject> newFields = JSON.parseObject(JSON.toJSONString(data.get("widgetList")), new TypeReference<List<JSONObject>>() {
            });
            // 表单回显时 加入子表单信息到流程变量中
            for (JSONObject newField : newFields) {
                String key = newField.getString("id");
                // 处理图片上传组件回显问题
                if ("picture-upload".equals(newField.getString("type"))) {
                    parameters.put(key, new ArrayList<>());
                } else {
                    parameters.put(key, null);
        // 这里只需要查自身以及上一个节点(如果并行的有多个)的表单数据
        List<FormDetailVO> beforeNodes = taskCommonService.getBeforeNodeDefId(task.getProcessDefinitionId(), task.getTaskDefinitionKey(), sysFormService);
        List<String> beforeNodeDefIds = beforeNodes.stream().filter(item -> !item.getCurrent()).map(FormDetailVO::getBeforeNodeDefId).collect(Collectors.toList());
        Map<String, Object> newP = new HashMap<>();
        if (CollectionUtils.isNotEmpty(beforeNodeDefIds)) {
            for (String key : parameters.keySet()) {
                // 过滤目标数据，将目标表单数据放到新map中
                if (beforeNodeDefIds.stream().anyMatch(defId -> key.startsWith(defId))) {
                    if (key.contains(ProcessConstants.TASK_FORM_KEY)) {
                        newP.put(key, parameters.get(key));
                    } else {
                        newP.put(key.split("&")[1], parameters.get(key));
                    }
                }
            }
            oldFields.addAll(newFields);
        }
        oldVariables.put("widgetList", oldFields);
        parameters.put("formJson", oldVariables);
        return AjaxResult.success(parameters);

        // 拿到目标表单后，再处理每个表单的数据
        for (FormDetailVO formDetailVO : beforeNodes) {
            if (formDetailVO.getCurrent()) {
                continue;  // 跳过当前节点，因为当前节点在获取前置节点时已经设置过了
            }
            Object form = newP.get(formDetailVO.getBeforeNodeDefId() + "&" + ProcessConstants.TASK_FORM_KEY);
            if (Objects.nonNull(form)) {
                JSONObject formJson = JSONObject.parseObject(JSON.toJSONString(form));
                List<JSONObject> oldFields = JSON.parseObject(JSON.toJSONString(formJson.get(ProcessConstants.WIDGET_LIST)), new TypeReference<List<JSONObject>>() {
                });

                // 设置已填写的表单为禁用状态
                for (JSONObject oldField : oldFields) {
                    JSONObject options = oldField.getJSONObject("options");
                    options.put("disabled", true);
                }
                // TODO 暂时只处理用户任务上的表单
//                if (StringUtils.isNotBlank(task.getFormKey())) {
//                    SysForm sysForm = sysFormService.selectSysFormById(Long.parseLong(task.getFormKey()));
//                    JSONObject data = JSONObject.parseObject(sysForm.getFormContent());
//                    List<JSONObject> newFields = JSON.parseObject(JSON.toJSONString(data.get(ProcessConstants.WIDGET_LIST)), new TypeReference<List<JSONObject>>() {
//                    });
//                    // 表单回显时 加入子表单信息到流程变量中
//                    for (JSONObject newField : newFields) {
//                        String key = newField.getString("id");
//                        // 处理图片上传组件回显问题
//                        if ("picture-upload".equals(newField.getString("type"))) {
//                            parameters.put(key, new ArrayList<>());
//                        } else {
//                            parameters.put(key, null);
//                        }
//                    }
//                    oldFields.addAll(newFields);
//                }
                formJson.put(ProcessConstants.WIDGET_LIST, oldFields);
                newP.put(ProcessConstants.TASK_FORM_KEY, formJson);
                newP.remove(formDetailVO.getBeforeNodeDefId() + "&" + ProcessConstants.TASK_FORM_KEY);
                formDetailVO.setFormJsonObj(newP);
            }
        }

        return AjaxResult.success(beforeNodes);
    }

    /**