project_management-java.git

			@@ -1,48 +1,47 @@
			package com.ycl.service.impl;


			import com.alibaba.fastjson2.JSON;
			import com.alibaba.fastjson2.JSONArray;
			import com.alibaba.fastjson2.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.metadata.IPage;
			import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
			import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
			import com.ycl.common.constant.ProcessConstants;
			import com.ycl.common.constant.ProcessOverTimeConstants;
			import com.ycl.common.core.domain.AjaxResult;
			import com.ycl.common.core.domain.entity.SysDept;
			import com.ycl.common.core.domain.entity.SysDictData;
			import com.ycl.common.core.domain.entity.SysRole;
			import com.ycl.common.core.domain.entity.SysUser;
			import com.ycl.common.enums.business.HandlerTypeEnum;
			import com.ycl.common.enums.business.ProcessLogEventTypeEnum;
			import com.ycl.common.enums.business.SuperviseTypeEnum;
			import com.ycl.common.enums.business.TaskStatusEnum;
			import com.ycl.common.enums.business.*;
			import com.ycl.common.utils.DateUtils;
			import com.ycl.common.utils.SecurityUtils;
			import com.ycl.constant.TaskTypeConstant;
			import com.ycl.domain.entity.*;
			import com.ycl.domain.form.*;
			import com.ycl.domain.json.DelegateData;
			import com.ycl.domain.json.HangupData;
			import com.ycl.domain.json.JumpData;
			import com.ycl.domain.json.SuperviseData;
			import com.ycl.domain.vo.CustomerTaskVO;
			import com.ycl.domain.vo.IndexCustomerTaskVO;
			import com.ycl.domain.vo.ProjectProcessDetailVO;
			import com.ycl.domain.json.*;
			import com.ycl.domain.query.ProcessLogQuery;
			import com.ycl.domain.vo.*;
			import com.ycl.event.event.TaskLogEvent;
			import com.ycl.mapper.ProjectEngineeringMapper;
			import com.ycl.mapper.ProjectInfoMapper;
			import com.ycl.mapper.ProjectProcessMapper;
			import com.ycl.service.*;
			import com.ycl.common.base.Result;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import com.ycl.domain.vo.ProjectProcessVO;
			import com.ycl.domain.query.ProjectProcessQuery;
			import com.ycl.service.common.TaskCommonService;
			import com.ycl.system.domain.base.AbsQuery;
			import com.ycl.system.service.ISysDeptService;
			import com.ycl.system.service.ISysDictTypeService;
			import com.ycl.system.service.ISysRoleService;
			import com.ycl.system.service.ISysUserService;
			import com.ycl.utils.TreeUtil;
			import lombok.Synchronized;
			import org.apache.commons.lang3.StringUtils;
			import org.flowable.bpmn.model.*;
			import org.flowable.bpmn.model.Process;
			import org.flowable.common.engine.impl.persistence.StrongUuidGenerator;
			import org.flowable.common.engine.impl.util.CollectionUtil;
			import org.flowable.engine.*;
			import org.flowable.engine.history.HistoricProcessInstance;
			@@ -55,6 +54,8 @@
			import org.flowable.task.api.Task;
			import org.flowable.task.api.TaskQuery;
			import org.flowable.task.api.history.HistoricTaskInstance;
			import org.flowable.task.api.history.HistoricTaskInstanceQuery;
			import org.springframework.beans.BeanUtils;
			import org.springframework.context.ApplicationEventPublisher;
			import org.springframework.stereotype.Service;
			import lombok.RequiredArgsConstructor;
			@@ -81,6 +82,7 @@
			private final IdentityService identityService;
			private final RepositoryService repositoryService;
			private final ProjectInfoMapper projectInfoMapper;
			private final ProjectEngineeringMapper projectEngineeringMapper;
			private final HistoryService historyService;
			private final ISysUserService sysUserService;
			private final ISysRoleService sysRoleService;
			@@ -92,6 +94,8 @@
			private final ApplicationEventPublisher publisher;
			private final ISysDeptService deptService;
			private final ProcessLogService processLogService;
			private final ISysDictTypeService dictTypeService;
			private final ProcessConfigInfoService processConfigInfoService;

			/**
			* 分页查询
			@@ -104,7 +108,20 @@
			IPage<ProjectProcessVO> page = PageUtil.getPage(query, ProjectProcessVO.class);
			baseMapper.getPage(query, page);
			for (ProjectProcessVO vo : page.getRecords()) {
			if (Objects.nonNull(vo.getProcessDefId())) {
			List<ProjectEngineeringVO> childList = baseMapper.getEngineeringList(vo.getId());
			childList.stream().forEach(child -> {
			if (StringUtils.isNotBlank(child.getProcessDefId())) {
			ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(child.getProcessDefId()).singleResult();
			if (Objects.nonNull(processDefinition)) {
			child.setSuspended(processDefinition.isSuspended());
			child.setFlowableProcessName(processDefinition.getName() + "(v" + processDefinition.getVersion() + ")");
			child.setDeployId(processDefinition.getDeploymentId());
			}
			}
			});
			vo.setChildren(TreeUtil.treeForProjectEng(childList));
			vo.setStatus(vo.getProjectStatus());
			if (StringUtils.isNotBlank(vo.getProcessDefId())) {
			ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(vo.getProcessDefId()).singleResult();
			if (Objects.nonNull(processDefinition)) {
			vo.setSuspended(processDefinition.isSuspended());
			@@ -122,6 +139,7 @@
			// 查询该项目是否已经绑定过流程了，检查绑定的流程是否在运行，在运行就删了
			ProjectProcess pp = new LambdaQueryChainWrapper<>(baseMapper)
			.eq(ProjectProcess::getProjectId, form.getProjectId())
			.eq(ProjectProcess::getProjectType, form.getProjectType())
			.one();
			if (Objects.isNull(pp)) {
			throw new RuntimeException("该项目未绑定流程");
			@@ -141,23 +159,36 @@
			}
			}
			}
			ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
			.select(ProjectInfo::getCreateBy)
			.eq(ProjectInfo::getId, form.getProjectId())
			.one();
			if (Objects.isNull(project)) {
			throw new RuntimeException("项目不存在");
			Long unitId = null;
			if (ProjectProcessTypeEnum.PROJECT.equals(form.getProjectType())) {
			ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
			.eq(ProjectInfo::getId, form.getProjectId())
			.one();
			if (Objects.isNull(project)) {
			throw new RuntimeException("项目不存在");
			}
			unitId = project.getProjectOwnerUnit();
			} else if (ProjectProcessTypeEnum.ENGINEERING.equals(form.getProjectType())) {
			ProjectEngineering projectEngineering = new LambdaQueryChainWrapper<>(projectEngineeringMapper)
			.eq(ProjectEngineering::getId, form.getProjectId())
			.one();
			if (Objects.isNull(projectEngineering)) {
			throw new RuntimeException("工程不存在");
			}
			unitId = projectEngineering.getUnit();
			}
			SysUser user = sysUserService.selectUserById(project.getCreateBy());
			if (Objects.isNull(user)) {
			throw new RuntimeException("项目业主单位不存在");

			SysDept dept = deptService.selectDeptById(unitId);
			if (Objects.isNull(dept)) {
			throw new RuntimeException("业主单位不存在");
			}
			String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), user.getDeptId());
			String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), dept.getDeptId());
			new LambdaUpdateChainWrapper<>(baseMapper)
			.eq(ProjectProcess::getProjectId, form.getProjectId())
			.eq(ProjectProcess::getProjectType, form.getProjectType())
			.set(ProjectProcess::getProcessDefId, form.getProcessDefId())
			.set(ProjectProcess::getProcessInsId, processInsId)
			.set(ProjectProcess::getDataLaunch, project.getCreateBy())
			.set(ProjectProcess::getDataLaunch, unitId)
			.update();

			return Result.ok("流程变更成功");
			@@ -165,24 +196,36 @@

			@Override
			@Transactional(rollbackFor = Exception.class)
			public Result startProcess(Long projectId, String processDefId) {
			ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
			.select(ProjectInfo::getCreateBy)
			.eq(ProjectInfo::getId, projectId)
			.one();
			if (Objects.isNull(project)) {
			throw new RuntimeException("项目不存在");
			public Result startProcess(ProjectProcessForm form) {
			Long unitId = null;
			if (ProjectProcessTypeEnum.PROJECT.equals(form.getProjectType())) {
			ProjectInfo project = new LambdaQueryChainWrapper<>(projectInfoMapper)
			.eq(ProjectInfo::getId, form.getProjectId())
			.one();
			if (Objects.isNull(project)) {
			throw new RuntimeException("项目不存在");
			}
			unitId = project.getProjectOwnerUnit();
			} else if (ProjectProcessTypeEnum.ENGINEERING.equals(form.getProjectType())) {
			ProjectEngineering projectEngineering = new LambdaQueryChainWrapper<>(projectEngineeringMapper)
			.eq(ProjectEngineering::getId, form.getProjectId())
			.one();
			if (Objects.isNull(projectEngineering)) {
			throw new RuntimeException("工程不存在");
			}
			unitId = projectEngineering.getUnit();
			}
			SysUser user = sysUserService.selectUserById(project.getCreateBy());
			if (Objects.isNull(user)) {
			throw new RuntimeException("项目业主单位不存在");
			SysDept dept = deptService.selectDeptById(unitId);
			if (Objects.isNull(dept)) {
			throw new RuntimeException("业主单位不存在");
			}
			String processInsId = this.startPro(projectId, processDefId, user.getDeptId());
			String processInsId = this.startPro(form.getProjectId(), form.getProcessDefId(), dept.getDeptId());
			ProjectProcess entity = new ProjectProcess();
			entity.setProjectId(projectId);
			entity.setProcessDefId(processDefId);
			entity.setProjectId(form.getProjectId());
			entity.setProcessDefId(form.getProcessDefId());
			entity.setProcessInsId(processInsId);
			entity.setDataLaunch(project.getCreateBy());
			entity.setDataLaunch(unitId);
			entity.setProjectType(form.getProjectType());
			baseMapper.insert(entity);

			return Result.ok("流程启动成功");
			@@ -195,7 +238,7 @@
			* @param processDefId
			* @return
			*/
			private String startPro(Long projectId, String processDefId, Long createBy) {
			private String startPro(String projectId, String processDefId, Long createBy) {


			ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processDefId)
			@@ -208,10 +251,9 @@
			SysUser sysUser = SecurityUtils.getLoginUser().getUser();
			identityService.setAuthenticatedUserId(sysUser.getUserId().toString());
			variables.put(ProcessConstants.PROCESS_INITIATOR, sysUser.getUserId());
			//测试容缺
			variables.put("miss", true);
			// 将该项目的申请人（业主方）作为流程中某些环节的处理人
			variables.put(ProcessConstants.DATA_LAUNCH, "dept:" + createBy);
			variables.put("a", 1);
			ProcessInstance processInstance = runtimeService.startProcessInstanceById(processDefId, projectId + "", variables);
			return processInstance.getId();
			}
			@@ -219,50 +261,101 @@
			/**
			* 获取流程详情
			*
			* @param projectId
			* @param form
			* @return
			*/
			@Override
			public Result detail(Long projectId, String processDefId) {
			// 项目信息
			ProjectInfo projectInfo = new LambdaQueryChainWrapper<>(projectInfoMapper)
			.select(ProjectInfo::getId, ProjectInfo::getProjectName, ProjectInfo::getProjectCode)
			.eq(ProjectInfo::getId, projectId)
			.one();
			public Result detail(ProjectProcessForm form) {

			if (Objects.isNull(projectInfo)) {
			return Result.error("该项目不存在");
			String projectName = "";
			String projectCode = "";
			if (ProjectProcessTypeEnum.PROJECT.equals(form.getProjectType())) {
			ProjectInfo projectInfo = projectInfoMapper.selectById(form.getProjectId());
			if (Objects.isNull(projectInfo)) {
			throw new RuntimeException("项目不存在");
			}
			projectName = projectInfo.getProjectName();
			projectCode = projectInfo.getProjectCode();
			} else if (ProjectProcessTypeEnum.ENGINEERING.equals(form.getProjectType())) {
			ProjectEngineering projectEngineering = projectEngineeringMapper.selectById(form.getProjectId());
			if (Objects.isNull(projectEngineering)) {
			throw new RuntimeException("工程不存在");
			}
			projectName = projectEngineering.getProjectName();
			}

			ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
			.eq(ProjectProcess::getProjectId, projectId)
			.eq(ProjectProcess::getProcessDefId, processDefId)
			.eq(ProjectProcess::getProjectId, form.getProjectId())
			.eq(ProjectProcess::getProcessDefId, form.getProcessDefId())
			.eq(ProjectProcess::getProjectType, form.getProjectType())
			.one();
			if (Objects.isNull(projectProcess)) {
			return Result.error("该项目未设置流程");
			return Result.error("未设置流程");
			}

			ProjectProcessDetailVO detail = new ProjectProcessDetailVO();
			detail.setProjectId(projectId);
			detail.setProjectName(projectInfo.getProjectName());
			detail.setProjectCode(projectInfo.getProjectCode());
			detail.setProjectType(form.getProjectType().getValue());
			detail.setProjectId(form.getProjectId());


			detail.setProjectName(projectName);
			detail.setProjectCode(projectCode);

			ProjectProcessDetailVO.TaskStatistics taskStatistics = new ProjectProcessDetailVO.TaskStatistics();
			// 状态统计
			taskStatistics.setTotalTaskNum(this.getTotalTaskNum(processDefId));
			taskStatistics.setTotalTaskNum(this.getTotalTaskNum(form.getProcessDefId()));
			taskStatistics.setTodoTaskNum(this.getTodoTaskNum(projectProcess.getProcessInsId()));
			taskStatistics.setRemainingTaskNum(this.getRemainingTaskNum(processDefId, projectProcess.getProcessInsId(), taskStatistics.getTotalTaskNum()));
			taskStatistics.setRemainingTaskNum(this.getRemainingTaskNum(form.getProcessDefId(), projectProcess.getProcessInsId(), taskStatistics.getTotalTaskNum()));
			taskStatistics.setTimelyFinishedTaskNum(this.getTimelyTaskNum(projectProcess.getProcessInsId()));
			taskStatistics.setOvertimeTaskNum(this.getOvertimeTaskNum(projectProcess.getProcessInsId()));
			taskStatistics.setWillOvertimeTaskNum(this.getWillOvertimeTaskNum(projectProcess.getProcessInsId()));
			// taskStatistics.setCurrentTask(this.getCurrentNodeTaskList(projectProcess.getProcessInstanceId()));
			taskStatistics.setWaitTaskNum(this.getWaitTaskNum(projectProcess.getProcessInsId()));
			taskStatistics.setJumpTaskNum(this.getJumpTaskNum(projectProcess.getProcessInsId()));
			detail.setStatistics(taskStatistics);

			Result result = Result.ok();

			// 代办任务
			this.getTodoTaskList(projectProcess.getProjectId(), projectProcess.getProcessInsId(), "", 5, 1, result);
			// // 代办任务
			// this.getTodoTaskList(projectProcess.getProjectId(), projectProcess.getProcessInsId(), "", 5, 1, result);
			return result.data(detail);
			}

			/**
			* 容缺任务计数
			* @param processInsId
			* @return
			*/
			private Long getWaitTaskNum(String processInsId){
			// 查出容缺过的任务
			List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list();
			// 排除容缺后又完成的任务
			List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.REJECT)
			.list();
			List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
			// 得到未完成的容缺任务
			List<String> waitTaskIds = allWaitTaskList.stream().filter(log -> !finishedTaskIds.contains(log.getTaskId())).map(ProcessLog::getTaskId).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(waitTaskIds)) {
			return 0L;
			}
			// 容缺的任务都属于历史任务，只是需要补表单数据
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.taskIds(waitTaskIds)
			.includeIdentityLinks()
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除运行时任务
			List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
			return Long.valueOf(hisTaskList.size());
			}

			@Override
			@@ -284,13 +377,17 @@
			this.getTodoTaskList(query.getProjectId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getPageSize(), (int) query.getCurrentPage(), ok);
			ok.data(ok.get("taskList"));
			break;
			case TaskTypeConstant.CURRENT:
			case TaskTypeConstant.WAIT:
			this.getWaitTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			break;
			case TaskTypeConstant.JUMP:
			this.getJumpTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			break;
			case TaskTypeConstant.REMAINING:
			this.getRemainingTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			break;
			case TaskTypeConstant.TIMELY:
			this.getTimelyTask(query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			this.getTimelyTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			break;
			case TaskTypeConstant.OVERTIME:
			this.getOvertimeTask(query.getProjectId(), query.getProcessDefId(), projectProcess.getProcessInsId(), query.getTaskName(), (int) query.getCurrentPage(), (int) query.getPageSize(), ok);
			@@ -311,9 +408,15 @@
			.active()
			.includeProcessVariables()
			.orderByTaskCreateTime().desc();

			List<String> insIds = baseMapper.getNormalInsIds();
			if (CollectionUtils.isEmpty(insIds)) {
			result.data(new ArrayList<>()).total(0L);
			return;
			} else {
			taskQuery.processInstanceIdIn(insIds);
			}
			if (StringUtils.isNotBlank(taskName)) {
			taskQuery.processDefinitionNameLike(taskName);
			taskQuery.taskNameLike(taskName);
			}
			if (!SecurityUtils.getLoginUser().getUser().isAdmin()) {
			taskQuery
			@@ -324,7 +427,50 @@
			.endOr();
			}
			result.total(taskQuery.count());
			List<Task> taskList = taskQuery.listPage(pageSize * (pageNum - 1), pageSize);
			List<Task> allTodoList = taskQuery.list();
			List<TaskOrderVO> orderList = new ArrayList<>();
			allTodoList.stream().forEach(task -> {
			TaskOrderVO order = new TaskOrderVO();
			order.setTaskId(task.getId());
			// 计算办理时间，超时的排前面，没超时的由低到高排序，没超时时间的排最后
			ProcessCoding processCoding = processCodingService.getByTaskId(task.getId(), task.getProcessInstanceId());
			if (Objects.nonNull(processCoding)) {
			if (StringUtils.isNotBlank(processCoding.getRedTime())) {
			Long overtime = getTime(processCoding.getRedTime());
			long durationTime = 0l;
			if (Objects.nonNull(processCoding.getStartTaskTime())) {
			durationTime = DateUtils.getWorkingSed(processCoding.getStartTaskTime(), new Date());
			}
			if (overtime > durationTime) {
			order.setNum((overtime - durationTime) / 3600);
			} else {
			order.setNum(-2000000L);
			}
			} else {
			order.setNum(2000000L);
			}
			} else {
			order.setNum(2000000L);
			}
			orderList.add(order);
			});
			// 升序排列
			Collections.sort(orderList, Comparator.comparingLong(TaskOrderVO::getNum));
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;
			if (startNum >= orderList.size()) {
			result.data(new ArrayList<>()).total(0L);
			return;
			}
			int end = Math.min(endNum, orderList.size());
			List<String> targetTaskIds = orderList.subList(startNum, end).stream().map(TaskOrderVO::getTaskId).collect(Collectors.toList());
			List<Task> taskList = targetTaskIds.stream().map(taskId -> {
			List<Task> list = allTodoList.stream().filter(task -> task.getId().equals(taskId)).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(list)) {
			return null;
			}
			return list.get(0);
			}).filter(Objects::nonNull).collect(Collectors.toList());
			List<IndexCustomerTaskVO> vos = new ArrayList<>();
			for (Task task : taskList) {
			IndexCustomerTaskVO taskVO = new IndexCustomerTaskVO();
			@@ -345,13 +491,28 @@
			taskVO.setTaskDefinitionKey(task.getTaskDefinitionKey());

			// 流程项目信息
			ProjectInfo project = baseMapper.getProjectInfo(task.getProcessInstanceId());
			if (Objects.nonNull(project)) {
			taskVO.setProjectId(project.getId());
			taskVO.setProjectName(project.getProjectName());
			} else {
			continue;
			ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
			.eq(ProjectProcess::getProcessInsId, task.getProcessInstanceId())
			.one();
			String projectId = "";
			String projectName = "";
			if (Objects.nonNull(projectProcess)) {
			if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.PROJECT)) {
			ProjectInfo project = projectInfoMapper.selectById(projectProcess.getProjectId());
			if (Objects.nonNull(project)) {
			projectId = projectProcess.getProjectId();
			projectName = project.getProjectName();
			}
			} else if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.ENGINEERING)) {
			ProjectEngineering engineering = projectEngineeringMapper.selectById(projectProcess.getProjectId());
			if (Objects.nonNull(engineering)) {
			projectId = projectProcess.getProjectId();
			projectName = engineering.getProjectName();
			}
			}
			}
			taskVO.setProjectId(projectId);
			taskVO.setProjectName(projectName);

			// 流程发起人信息
			this.setPromoterInfo(taskVO);
			@@ -408,14 +569,52 @@
			}
			}
			}
			// 检查是否挂起
			if (processLogService.taskIsHangup(task.getId(), task.getProcessInstanceId())) {
			taskVO.setTaskStatus(TaskStatusEnum.HANGUP);
			}

			// 计算办理时间
			ProcessCoding processCoding = processCodingService.getByTaskId(task.getId(), task.getProcessInstanceId());
			if (Objects.nonNull(processCoding)) {
			if (StringUtils.isNotBlank(processCoding.getRedTime())) {
			Long overtime = getTime(processCoding.getRedTime());
			long durationTime = 0l;
			if (Objects.nonNull(processCoding.getStartTaskTime())) {
			durationTime = ((new Date()).getTime() - processCoding.getStartTaskTime().getTime()) / 1000;
			}
			if (overtime > durationTime) {
			taskVO.setRemainingTime((overtime - durationTime) / 3600 + "小时");
			} else {
			taskVO.setRemainingTime("已超时");
			}
			} else {
			taskVO.setRemainingTime("-");
			}
			} else {
			taskVO.setRemainingTime("-");
			}
			this.distinctVo(taskVO);
			vos.add(taskVO);
			}
			if (vos.size() < pageSize) {
			result.total(vos.size());
			}
			result.put("taskList", vos);
			}

			private Long getTime(String timeStr) {
			Long time = null;
			if (StringUtils.isNotBlank(timeStr)) {
			String[] timeArr = timeStr.split("-");
			// 解析天数和小时数
			int days = Integer.parseInt(timeArr[0]);
			int hours = 0;
			if (timeArr.length > 1) {
			hours = Integer.parseInt(timeArr[1]);
			}
			time = (days * 24L + hours) * 3600L;
			// //分-秒
			// time= (days * 60L) + hours;
			}
			return time;
			}

			@Override
			@@ -609,7 +808,7 @@
			jsonData.setAfterHandlerIds(afterHandlerIds);
			jsonData.setAfterHandlerType(form.getPeopleType());
			// 发布转办事件
			publisher.publishEvent(new TaskLogEvent(this, null,SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), task.getId(), task.getName(),ProcessLogEventTypeEnum.DELEGATE, jsonData));
			publisher.publishEvent(new TaskLogEvent(this, null, SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), task.getId(), task.getTaskDefinitionKey(), task.getName(), ProcessLogEventTypeEnum.DELEGATE, jsonData));

			return Result.ok("转办成功");
			}
			@@ -620,7 +819,7 @@
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).processInstanceId(form.getProcessInsId()).singleResult();
			if (Objects.nonNull(task)) {
			// 添加跳过日志
			publisher.publishEvent(new TaskLogEvent(this, null,SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), form.getTaskId(), task.getName(),ProcessLogEventTypeEnum.JUMP, new JumpData(form.getDesc())));
			publisher.publishEvent(new TaskLogEvent(this, null, SecurityUtils.getUserId(), form.getProjectId(), form.getProcessInsId(), task.getId(), task.getTaskDefinitionKey(), task.getName(), ProcessLogEventTypeEnum.JUMP, new JumpData(form.getDesc())));
			// 查出该任务绑定的表单

			Map<String, Object> data = new HashMap<>(1);
			@@ -631,7 +830,36 @@
			}
			}
			// 完成任务
			flowTaskService.completeSubmitForm(form.getTaskId(), data);
			flowTaskService.completeSubmitForm(form.getTaskId(), data, Boolean.FALSE);
			}
			return Result.ok("操作成功");
			}

			@Override
			public Result taskWait(TaskWaitForm form) {
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).processInstanceId(form.getProcessInsId()).singleResult();
			if (Objects.nonNull(task)) {
			// 添加容缺日志
			publisher.publishEvent(new TaskLogEvent(this,
			null,
			SecurityUtils.getUserId(),
			form.getProjectId(),
			form.getProcessInsId(),
			task.getId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.WAIT,
			new WaitData(form.getDesc())));
			// 查出该任务绑定的表单
			Map<String, Object> data = new HashMap<>(1);
			if (StringUtils.isNotBlank(task.getFormKey())) {
			SysForm sysForm = formService.selectSysFormById(Long.parseLong(task.getFormKey()));
			if (Objects.nonNull(sysForm)) {
			data.put(ProcessConstants.TASK_FORM_KEY, JSONObject.parseObject(sysForm.getFormContent()));
			}
			}
			// 完成任务
			flowTaskService.completeSubmitForm(form.getTaskId(), data, Boolean.FALSE);
			}
			return Result.ok("操作成功");
			}
			@@ -639,6 +867,9 @@
			@Override
			public Result taskSupervise(TaskSuperviseForm form) {
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
			if (Objects.isNull(task)) {
			throw new RuntimeException("任务不存在");
			}
			SuperviseData jsonData = new SuperviseData();
			jsonData.setCreateTime(new Date());
			jsonData.setContent(form.getContent());
			@@ -647,12 +878,12 @@
			jsonData.setReceiverIds(form.getReceiverIds());
			jsonData.setReceiverType(form.getReceiverType());
			jsonData.setSuperviseType(form.getSuperviseType());
			QueryWrapper<ProcessLog> queryWrapper = new QueryWrapper<>();
			queryWrapper.eq("task_id", form.getTaskId());
			queryWrapper.eq("event_type", ProcessLogEventTypeEnum.SUPERVISE);
			queryWrapper.eq("process_ins_id", form.getProcessInsId());
			//查询督办日志
			ProcessLog processLog = processLogService.getOne(queryWrapper);

			ProcessLog processLog = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.SUPERVISE)
			.eq(ProcessLog::getProcessInsId, task.getProcessInstanceId())
			.one();
			List<SuperviseData> dataList;
			if (processLog != null) {
			String eventDataJson = processLog.getEventDataJson();
			@@ -664,13 +895,35 @@
			}
			dataList.add(jsonData);
			//添加督办日志
			publisher.publishEvent(new TaskLogEvent(this, processLog.getId(), processLog.getUserId(), form.getProjectId(), form.getProcessInsId(), form.getTaskId(), task.getName(),ProcessLogEventTypeEnum.SUPERVISE, dataList));
			publisher.publishEvent(new TaskLogEvent(this,
			processLog.getId(),
			processLog.getUserId(),
			form.getProjectId(),
			task.getProcessInstanceId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.SUPERVISE,
			dataList));
			return Result.ok("操作成功");
			}

			@Override
			@Synchronized
			public Result taskHangup(TaskHangupForm form) {
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
			if (Objects.isNull(task)) {
			throw new RuntimeException("任务不存在");
			}
			List<ProcessLog> logs = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getProcessInsId, form.getProcessInsId())
			.eq(ProcessLog::getProjectId, form.getProjectId())
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.HANGUP, ProcessLogEventTypeEnum.CANCEL_HANGUP)
			.list();
			if (logs.size() % 2 != 0) {
			throw new RuntimeException("该任务正在挂起中，不能再次挂起");
			}
			// 任务挂起只需要存日志，查询待办时如果有这个日志记录，则禁用提交按钮，以此实现任务挂起
			publisher.publishEvent(new TaskLogEvent(this,
			null,
			@@ -678,11 +931,119 @@
			form.getProjectId(),
			form.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.HANGUP,
			new HangupData(form.getReason())
			));
			));
			return Result.ok("操作成功");
			}

			@Override
			@Synchronized
			public Result cancelTaskHangup(TaskHangupForm form) {
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
			if (Objects.isNull(task)) {
			throw new RuntimeException("任务不存在");
			}
			List<ProcessLog> logs = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getProcessInsId, form.getProcessInsId())
			.eq(ProcessLog::getProjectId, form.getProjectId())
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.HANGUP, ProcessLogEventTypeEnum.CANCEL_HANGUP)
			.list();
			if (logs.size() % 2 == 0) {
			throw new RuntimeException("该任务未被挂起，不能取消挂起");
			}
			publisher.publishEvent(new TaskLogEvent(this,
			null,
			SecurityUtils.getUserId(),
			form.getProjectId(),
			form.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.CANCEL_HANGUP,
			new HangupData(form.getReason())
			));
			return Result.ok("操作成功");
			}

			@Override
			public Result taskTeamwork(TaskTeamWorkForm form) {
			Task task = taskService.createTaskQuery().taskId(form.getTaskId()).singleResult();
			if (Objects.isNull(task)) {
			return Result.error("任务不存在");
			}
			ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(projectProcessMapper)
			.eq(ProjectProcess::getProcessInsId, task.getProcessInstanceId())
			.eq(ProjectProcess::getProcessDefId, task.getProcessDefinitionId())
			.one();
			if (Objects.isNull(projectProcess)) {
			return Result.error("项目流程未绑定");
			}
			// 1. 保存发起人填写的表单数据，但不直接完成该任务。提交后任务处理人必须等到协同人处理完之后才能完成任务
			Map<String, Object> processVariables = new HashMap<>();
			//查出字典中需要注入的字段信息
			List<String> dictList = dictTypeService.selectDictDataByType("flow_variables").stream().map(SysDictData::getDictValue).collect(Collectors.toList());
			Map<String, Object> newV = new HashMap<>(2);
			if (!org.springframework.util.CollectionUtils.isEmpty(form.getVariables())) {
			for (String key : form.getVariables().keySet()) {
			newV.put(task.getTaskDefinitionKey() + "&" + key, form.getVariables().get(key));
			//字典里有就放入流程变量中
			if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(dictList) && dictList.contains(key)) {
			processVariables.put(key, form.getVariables().get(key));
			}
			}
			}
			if (!processVariables.isEmpty()) {
			taskService.setVariables(form.getTaskId(), processVariables);
			}

			// 2. 保存日志
			publisher.publishEvent(new TaskLogEvent(this,
			null,
			SecurityUtils.getUserId(),
			form.getProjectId(),
			form.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.TEAM_WORK,
			new TeamWorkData(form.getHandlerType(), form.getHandlerIds(), TeamWorkStatusEnum.NOT_FINISHED)
			));
			return Result.ok("操作成功");
			}

			@Override
			public Result getProcessMsg(AbsQuery q) {
			// 查自己的日志
			ProcessLogQuery query = new ProcessLogQuery();
			if (! SecurityUtils.isAdmin(SecurityUtils.getUserId())) {
			query.setUserId(SecurityUtils.getUserId());
			}
			query.setEventTypeList(Arrays.asList(ProcessLogEventTypeEnum.DELEGATE.getValue(),
			ProcessLogEventTypeEnum.REJECT.getValue(),
			ProcessLogEventTypeEnum.JUMP.getValue(),
			ProcessLogEventTypeEnum.FINISHED.getValue(),
			ProcessLogEventTypeEnum.WAIT.getValue()));
			query.setCurrentPage(q.getCurrentPage());
			query.setPageSize(q.getPageSize());
			Result result = processLogService.projectProcessLogPage(query);
			List<ProcessLogVO> logs = (List<ProcessLogVO>) result.get("data");

			logs.stream().forEach(log -> {
			if (ProcessLogEventTypeEnum.FINISHED.equals(log.getEventType())) {
			log.setContent("您完成了任务：" + log.getTaskName());
			} else if (ProcessLogEventTypeEnum.REJECT.equals(log.getEventType())) {
			log.setContent("您驳回了任务：" + log.getTaskName());
			} else if (ProcessLogEventTypeEnum.WAIT.equals(log.getEventType())) {
			log.setContent("您容缺了任务：" + log.getTaskName());
			} else if (ProcessLogEventTypeEnum.JUMP.equals(log.getEventType())) {
			log.setContent("您跳过了任务：" + log.getTaskName());
			}
			});
			return Result.ok().data(logs).total((Long) result.get("total"));
			}

			/**
			@@ -695,7 +1056,8 @@
			* @param pageNum
			* @param result
			*/
			public void getTodoTaskList(Long projectId, String processInsId, String taskName, int pageSize, int pageNum, Result result) {
			public void getTodoTaskList(String projectId, String processInsId, String taskName, int pageSize, int pageNum, Result result) {

			TaskQuery taskQuery = taskService.createTaskQuery()
			.active()
			.processInstanceId(processInsId)
			@@ -704,7 +1066,7 @@
			.desc();

			if (StringUtils.isNotBlank(taskName)) {
			taskQuery.processDefinitionNameLike(taskName);
			taskQuery.taskNameLike(taskName);
			}
			result.total(taskQuery.count());
			List<Task> taskList = taskQuery.listPage(pageSize * (pageNum - 1), pageSize);
			@@ -712,6 +1074,10 @@
			for (Task task : taskList) {
			CustomerTaskVO taskVO = new CustomerTaskVO();
			this.setRuntimeTaskInfo(task, taskVO, projectId);
			// 检查是否挂起
			if (processLogService.taskIsHangup(task.getId(), task.getProcessInstanceId())) {
			taskVO.setTaskStatus(TaskStatusEnum.HANGUP);
			}
			vos.add(taskVO);
			}
			result.put("taskList", vos);
			@@ -728,7 +1094,7 @@
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getAllUserTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			private List<CustomerTaskVO> getAllUserTask(String projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;
			List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);
			@@ -747,7 +1113,7 @@
			ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			if (Objects.isNull(process)) {
			// 如果运行时找不到说明是已完成的流程，直接查历史任务
			List<CustomerTaskVO> vos = this.getFinishedProcessTaskInfo(userTasks, processInsId, processDefinitionId);
			List<CustomerTaskVO> vos = this.getFinishedProcessTaskInfo(userTasks, projectId, processInsId, processDefinitionId);
			result.data(vos);
			return vos;
			}
			@@ -769,10 +1135,16 @@
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			this.setCandidateInfo(userTask, vo, projectId, processInsId);

			if (Objects.isNull(task)) {
			// 如果任务在运行时没找到，那么可能为未开始或者已完成，需要从历史任务中再找一下
			@@ -784,28 +1156,25 @@
			.desc()
			.list();
			if (CollectionUtils.isEmpty(historicTasks)) {
			vo.setPromoterName("暂无");
			vo.setPromoterUnitName("暂无");
			// 未开始的任务，其关联的用户组这些都可以从UserTask中拿到，因为本身未开始的任务是没有task的，所以这里直接查
			if (StringUtils.isNotBlank(userTask.getAssignee())) {
			vo.setHandlerType(HandlerTypeEnum.USER);
			SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
			if (Objects.nonNull(sysUser)) {
			handlerIds.add(sysUser.getUserId());
			handlerNames.add(sysUser.getNickName());
			vo.getHandlerId().add(sysUser.getUserId());
			vo.getHandlerName().add(this.getUserShowName(sysUser));
			if (Objects.nonNull(sysUser.getDept())) {
			handlerUnitIds.add(sysUser.getDept().getDeptId());
			handlerUnitNames.add(sysUser.getDept().getDeptName());
			vo.getHandlerUnitId().add(sysUser.getDept().getDeptId());
			vo.getHandlerUnitName().add(sysUser.getDept().getDeptName());
			}
			}

			} else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
			List<String> groupIds = userTask.getCandidateGroups();
			for (String groupId : groupIds) {
			// 处理变量表达式，DATA_LAUNCH只可能是部门不会是角色，因为代表的是业主部门
			if (groupId.contains(ProcessConstants.DATA_LAUNCH)) {
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT);
			this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT, 1);
			} else if (groupId.startsWith("dept")) { // 部门的id是加了前缀的如：dept:1
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			String[] split = groupId.split(":");
			@@ -813,16 +1182,17 @@
			// 部门
			SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
			if (Objects.nonNull(dept)) {
			handlerUnitIds.add(dept.getDeptId());
			handlerUnitNames.add(dept.getDeptName());
			vo.getHandlerUnitId().add(dept.getDeptId());
			vo.getHandlerUnitName().add(dept.getDeptName());
			vo.getHandlerName().add(this.getDeptLeaderShowName(dept));
			}
			}
			} else {
			vo.setHandlerType(HandlerTypeEnum.ROLE);
			SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
			if (Objects.nonNull(role)) {
			handlerUnitIds.add(role.getRoleId());
			handlerUnitNames.add(role.getRoleName());
			vo.getHandlerUnitId().add(role.getRoleId());
			vo.getHandlerUnitName().add(role.getRoleName());
			}
			}
			}
			@@ -836,16 +1206,19 @@
			vo.setCreateTime(historicTasks.get(0).getStartTime());

			// 查询实际处理人
			long handlerUserId = Long.parseLong(historicTasks.get(0).getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			handlerIds.add(handlerUserId);
			handlerNames.add(handlerUser.getNickName());
			vo.setActualHandlerUserId(historicTasks.get(0).getAssignee());
			vo.setActualHandlerUserName(handlerUser.getNickName());
			if (StringUtils.isNotBlank(historicTasks.get(0).getAssignee())) {
			long handlerUserId = Long.parseLong(historicTasks.get(0).getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			vo.getHandlerName().add(this.getUserShowName(handlerUser));
			if (Objects.nonNull(handlerUser.getDept())) {
			vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
			vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
			}
			}
			}
			vo.setTaskDefinitionKey(historicTasks.get(0).getTaskDefinitionKey());
			this.setPromoterAndHandler(vo, historicTasks.get(0).getIdentityLinks());
			}
			} else {
			vo.setTaskStatus(TaskStatusEnum.TODO);
			@@ -854,7 +1227,7 @@
			vo.setCreateTime(task.getCreateTime());
			vo.setTaskDefinitionKey(task.getTaskDefinitionKey());

			this.setPromoterAndHandler(vo, null);
			this.setHandler(vo, null);
			this.setRuntimeTaskInfo(task, vo, projectId);
			}
			this.distinctVo(vo);
			@@ -872,8 +1245,11 @@
			* @param processDefId 流程定义id
			* @return
			*/
			private List<CustomerTaskVO> getFinishedProcessTaskInfo(List<UserTask> userTasks, String processInsId, String processDefId) {
			private List<CustomerTaskVO> getFinishedProcessTaskInfo(List<UserTask> userTasks, String projectId, String processInsId, String processDefId) {
			HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			if (Objects.isNull(hisProcess)) {
			return new ArrayList<>();
			}
			List<CustomerTaskVO> vos = userTasks.stream().map(userTask -> {
			CustomerTaskVO vo = new CustomerTaskVO();
			vo.setProcessInsId(hisProcess.getId());
			@@ -882,6 +1258,23 @@
			vo.setTaskName(userTask.getName());
			vo.setProcessName(hisProcess.getProcessDefinitionName());

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);


			this.setCandidateInfo(userTask, vo, projectId, processInsId);

			// 查多个是因为驳回后会查出两条及以上，取最新一条
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(hisProcess.getId())
			@@ -889,25 +1282,29 @@
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();

			vo.setTaskStatus(TaskStatusEnum.FINISHED);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(hisTaskList.get(0).getId());
			vo.setExecutionId(hisTaskList.get(0).getExecutionId());
			vo.setCreateTime(hisTaskList.get(0).getStartTime());
			// 查询实际处理人
			long handlerUserId = Long.parseLong(hisTaskList.get(0).getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {

			vo.setActualHandlerUserId(hisTaskList.get(0).getAssignee());
			vo.setActualHandlerUserName(handlerUser.getNickName());
			// 如果未找到历史任务，说明这个任务可能处于某个互斥网关下，实际并未执行
			if (CollectionUtils.isEmpty(hisTaskList)) {
			vo.setTaskStatus(TaskStatusEnum.NOT_START);
			} else {
			vo.setTaskStatus(TaskStatusEnum.FINISHED);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(hisTaskList.get(0).getId());
			vo.setExecutionId(hisTaskList.get(0).getExecutionId());
			vo.setCreateTime(hisTaskList.get(0).getStartTime());
			// 查询实际处理人
			if (StringUtils.isNotBlank(hisTaskList.get(0).getAssignee())) {
			long handlerUserId = Long.parseLong(hisTaskList.get(0).getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.setActualHandlerUserId(hisTaskList.get(0).getAssignee());
			vo.setActualHandlerUserName(handlerUser.getNickName());
			}
			}
			vo.setTaskDefinitionKey(hisTaskList.get(0).getTaskDefinitionKey());
			this.setHandler(vo, hisTaskList.get(0).getIdentityLinks());
			}
			vo.setTaskDefinitionKey(hisTaskList.get(0).getTaskDefinitionKey());
			this.setPromoterAndHandler(vo, hisTaskList.get(0).getIdentityLinks());

			return vo;
			}).collect(Collectors.toList());
			}).filter(Objects::nonNull).collect(Collectors.toList());
			return vos;
			}

			@@ -918,7 +1315,7 @@
			* @param taskVO 任务vo
			* @param projectId 项目id
			*/
			private void setRuntimeTaskInfo(Task task, CustomerTaskVO taskVO, Long projectId) {
			private void setRuntimeTaskInfo(Task task, CustomerTaskVO taskVO, String projectId) {
			// 当前流程信息
			taskVO.setTaskId(task.getId());
			taskVO.setCreateTime(task.getCreateTime());
			@@ -943,18 +1340,19 @@
			taskVO.setProcessInsId(task.getProcessInstanceId());
			taskVO.setTaskDefinitionKey(task.getTaskDefinitionKey());

			// 流程发起人信息
			this.setPromoterInfo(taskVO);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			taskVO.setHandlerId(handlerIds);
			taskVO.setHandlerName(handlerNames);
			taskVO.setHandlerUnitId(handlerUnitIds);
			taskVO.setHandlerUnitName(handlerUnitNames);
			taskVO.setPromoterName(promoterNames);
			taskVO.setPromoterUnitName(promoterUnitNames);

			// 流程处理人信息
			List<IdentityLink> identityLinksForTask = taskService.getIdentityLinksForTask(task.getId());
			@@ -970,10 +1368,19 @@
			SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
			if (Objects.nonNull(sysUser)) {
			taskVO.getHandlerId().add(sysUser.getUserId());
			taskVO.getHandlerName().add(sysUser.getNickName());
			taskVO.getHandlerName().add(this.getUserShowName(sysUser));
			if (Objects.nonNull(sysUser.getDept())) {
			taskVO.getHandlerUnitId().add(sysUser.getDept().getDeptId());
			taskVO.getHandlerUnitName().add(sysUser.getDept().getDeptName());
			taskVO.getPromoterName().add(this.getUserShowName(sysUser));
			// if (sysUser.getDept().getAncestors())
			String[] str = sysUser.getDept().getAncestors().split(",");
			if (str.length >= 4){
			taskVO.getPromoterUnitName().add(sysUser.getDept().getParentName() +"-"+sysUser.getDept().getDeptName());
			}else {
			taskVO.getPromoterUnitName().add(sysUser.getDept().getDeptName());
			}

			}
			}
			// 绑定的是角色或者部门
			@@ -987,6 +1394,8 @@
			if (Objects.nonNull(dept)) {
			taskVO.getHandlerUnitId().add(dept.getDeptId());
			taskVO.getHandlerUnitName().add(dept.getDeptName());
			taskVO.getPromoterName().add(this.getDeptLeaderShowName(dept));
			taskVO.getPromoterUnitName().add(this.setDeptNameWithParentName(dept));
			}
			}
			} else {
			@@ -998,7 +1407,6 @@
			}
			}
			}

			this.distinctVo(taskVO);
			}
			}
			@@ -1011,16 +1419,30 @@
			*/
			private Long getTimelyTaskNum(String processInsId) {
			// 查出已完成的任务key
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.finished()
			.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			.includeIdentityLinks()
			.orderByTaskCreateTime()
			.desc();
			List<HistoricTaskInstance> hisTaskList = query.list();
			if (CollectionUtils.isEmpty(hisTaskList)) {
			return 0L;
			}

			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除跳过、容缺的任务，因为这两个操作都会完成任务而产生历史任务
			List<String> jumpAndWaitTaskKeys = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT) // TODO 如果运行时任务正好是被驳回的，需要想办法排除调被驳回的任务，不能直接在这加 ProcessLogEventTypeEnum.REJECT
			.list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
			List<String> runtimeTaskKey = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			jumpAndWaitTaskKeys.addAll(runtimeTaskKey);
			hisTaskList = hisTaskList.stream().filter(hisTask -> jumpAndWaitTaskKeys.indexOf(hisTask.getTaskDefinitionKey()) == -1).collect(Collectors.toList());
			List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());

			if (CollectionUtils.isEmpty(hisTaskKeys)) {
			return 0L;
			}
			Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
			// 查出时间正常的任务key
			List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			@@ -1057,26 +1479,42 @@
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getTimelyTask(String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			private List<CustomerTaskVO> getTimelyTask(String projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;

			// 查出已完成的任务key
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.finished()
			.taskNameLike(taskName)
			.includeIdentityLinks()
			.orderByTaskCreateTime()
			.desc()
			.list();
			.desc();
			if (StringUtils.isNotBlank(taskName)) {
			query.taskNameLike(taskName);
			}
			List<HistoricTaskInstance> hisTaskList = query.list();
			if (CollectionUtils.isEmpty(hisTaskList)) {
			result.total(0);
			return new ArrayList<>();
			}

			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除跳过、容缺的任务，因为这两个操作都会完成任务而产生历史任务
			List<String> jumpAndWaitTaskKeys = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getProjectId, projectId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
			.list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
			List<String> runtimeTaskKey = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			jumpAndWaitTaskKeys.addAll(runtimeTaskKey);
			hisTaskList = hisTaskList.stream().filter(hisTask -> jumpAndWaitTaskKeys.indexOf(hisTask.getTaskDefinitionKey()) == -1).collect(Collectors.toList());
			List<String> hisTaskKeys = hisTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			Map<String, HistoricTaskInstance> hisTaskMap = this.distinctHisTask(hisTaskList).stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));

			if (CollectionUtils.isEmpty(hisTaskKeys)) {
			result.total(0);
			return new ArrayList<>();
			}
			Map<String, HistoricTaskInstance> hisTaskMap = hisTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
			// 查出时间正常的任务key
			List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			.eq(ProcessCoding::getProcessInsId, processInsId)
			@@ -1140,11 +1578,16 @@
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			this.setCandidateInfo(userTask, vo, projectId, processInsId);
			HistoricTaskInstance hisTask = keyMap.get(userTask.getId());
			if (Objects.nonNull(hisTask)) {
			vo.setTaskStatus(TaskStatusEnum.FINISHED);
			@@ -1154,16 +1597,19 @@
			vo.setCreateTime(hisTask.getStartTime());

			// 查询实际处理人
			long handlerUserId = Long.parseLong(hisTask.getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			vo.getHandlerName().add(handlerUser.getNickName());
			vo.setActualHandlerUserId(hisTask.getAssignee());
			vo.setActualHandlerUserName(handlerUser.getNickName());
			if (StringUtils.isNotBlank(hisTask.getAssignee())) {
			long handlerUserId = Long.parseLong(hisTask.getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			vo.getHandlerName().add(this.getUserShowName(handlerUser));
			if (Objects.nonNull(handlerUser.getDept())) {
			vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
			vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
			}
			}
			}
			vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
			this.setPromoterAndHandler(vo, hisTask.getIdentityLinks());
			}

			this.distinctVo(vo);
			@@ -1171,6 +1617,101 @@
			}).collect(Collectors.toList());
			result.data(vos);
			return vos;
			}

			/**
			* 设置历史任务信息
			*
			* @param hisTask
			* @param vo
			* @param projectId
			* @param processInsId
			*/
			private void setHisTaskInfo(HistoricTaskInstance hisTask, CustomerTaskVO vo, String projectId, String processInsId) {
			// 查出流程
			ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			String deployId = "";
			String processName = "";
			String processDefinitionId = "";
			if (Objects.nonNull(process)) {
			deployId = process.getDeploymentId();
			processName = process.getProcessDefinitionName();
			processDefinitionId = process.getProcessDefinitionId();
			} else {
			HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			deployId = hisProcess.getDeploymentId();
			processName = hisProcess.getProcessDefinitionName();
			processDefinitionId = hisProcess.getProcessDefinitionId();
			}

			vo.setProcessInsId(processInsId);
			vo.setProcessDefId(processDefinitionId);
			vo.setDeployId(deployId);
			vo.setTaskName(hisTask.getName());
			vo.setProcessName(processName);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);
			List<UserTask> targetUserTasks = this.getAllUserTaskElement(processDefinitionId).stream().filter(userTask -> hisTask.getTaskDefinitionKey().equals(userTask.getId())).collect(Collectors.toList());
			UserTask userTask = null;
			if (! CollectionUtils.isEmpty(targetUserTasks)) {
			userTask = targetUserTasks.get(0);
			}
			this.setCandidateInfo(userTask, vo, projectId, processInsId);


			vo.setTaskStatus(TaskStatusEnum.FINISHED);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(hisTask.getId());
			vo.setExecutionId(hisTask.getExecutionId());
			vo.setCreateTime(hisTask.getStartTime());

			// 查询实际处理人
			if (StringUtils.isNotBlank(hisTask.getAssignee())) {
			long handlerUserId = Long.parseLong(hisTask.getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			vo.getHandlerName().add(this.getUserShowName(handlerUser));
			if (Objects.nonNull(handlerUser.getDept())) {
			vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
			vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
			}
			}
			}
			vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
			this.distinctVo(vo);
			}

			/**
			* 用户名称后面跟电话号码
			*
			* @param user
			* @return
			*/
			private String getUserShowName(SysUser user) {
			return user.getNickName() + (StringUtils.isNotBlank(user.getPhonenumber()) ? "(" + user.getPhonenumber() + ")" : "");
			}

			/**
			* 部门负责人名称后面跟电话号码
			*
			* @param dept
			* @return
			*/
			private String getDeptLeaderShowName(SysDept dept) {
			return dept.getLeader() + (StringUtils.isNotBlank(dept.getPhone()) ? "(" + dept.getPhone() + ")" : "");
			}

			/**
			@@ -1202,36 +1743,16 @@
			* @return
			*/
			private Long getOvertimeTaskNum(String processInsId) {
			// 查出运行在的任务key
			List<Task> taskList = taskService.createTaskQuery().processInstanceId(processInsId).list();

			if (CollectionUtils.isEmpty(taskList)) {
			// 查出已超时的任务id
			List<ProcessCoding> overtimeRecords = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			.eq(ProcessCoding::getProcessInsId, processInsId)
			.eq(ProcessCoding::getOvertimeStatus, ProcessOverTimeConstants.OVERTIME)
			.orderByDesc(ProcessCoding::getGmtCreate)
			.list();
			if (CollectionUtils.isEmpty(overtimeRecords)) {
			return 0L;
			}
			List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
			// 查出数据库的任务key
			List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			.eq(ProcessCoding::getProcessInsId, processInsId)
			.in(ProcessCoding::getTaskDefKey, taskKeys)
			.list();
			List<Task> tList = new ArrayList<>();
			// 判断
			for (String key : taskMap.keySet()) {
			List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
			// 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
			if (CollectionUtils.isEmpty(targetProcessCodings)) {
			tList.add(taskMap.get(key));
			} else {
			// 按照时间降序排列
			targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
			ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
			if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.OVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
			tList.add(taskMap.get(key));
			}
			}
			}
			return Long.valueOf(taskList.size());
			return Long.valueOf(overtimeRecords.size());
			}

			/**
			@@ -1246,67 +1767,112 @@
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getOvertimeTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			private List<CustomerTaskVO> getOvertimeTask(String projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;

			// 查出运行在的任务key
			List<Task> taskList = new ArrayList<>(12);
			if (StringUtils.isNotBlank(taskName)) {
			taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
			} else {
			taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
			}
			if (CollectionUtils.isEmpty(taskList)) {
			// 查出已超时的任务id
			List<ProcessCoding> overtimeRecords = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			.eq(ProcessCoding::getProcessInsId, processInsId)
			.eq(ProcessCoding::getOvertimeStatus, ProcessOverTimeConstants.OVERTIME)
			.orderByDesc(ProcessCoding::getGmtCreate)
			.list();
			if (CollectionUtils.isEmpty(overtimeRecords)) {
			result.total(0);
			return new ArrayList<>();
			}
			List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
			// 查出数据库的任务key
			List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			.eq(ProcessCoding::getProcessInsId, processInsId)
			.in(ProcessCoding::getTaskDefKey, taskKeys)
			.list();
			List<Task> tList = new ArrayList<>();
			// 判断
			for (String key : taskMap.keySet()) {
			List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
			// 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
			if (CollectionUtils.isEmpty(targetProcessCodings)) {
			tList.add(taskMap.get(key));
			} else {
			// 按照时间降序排列
			targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
			ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
			if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.OVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
			tList.add(taskMap.get(key));
			}
			}
			}

			if (startNum >= tList.size()) {
			if (startNum >= overtimeRecords.size()) {
			// 如果起始索引超出了列表的大小，返回一个空列表
			return new ArrayList<>();
			}
			result.total(tList.size());
			int end = Math.min(endNum, tList.size());
			List<Task> pageTaskList = tList.subList(startNum, end);
			List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
			result.total(overtimeRecords.size());
			int end = Math.min(endNum, overtimeRecords.size());
			List<ProcessCoding> pageOvertimeRecords = overtimeRecords.subList(startNum, end);

			// 得到目标任务对应的定义
			List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());

			// 查询任务相关信息
			List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
			Task task = keyMap.get(userTask.getId());
			List<CustomerTaskVO> vos = pageOvertimeRecords.stream().map(record -> {
			CustomerTaskVO vo = new CustomerTaskVO();
			this.setRuntimeTaskInfo(task, vo, projectId);
			return vo;
			}).collect(Collectors.toList());
			Task task = taskService.createTaskQuery().processInstanceId(processInsId).taskId(record.getTaskId()).singleResult();
			if (Objects.nonNull(task)) {
			this.setRuntimeTaskInfo(task, vo, projectId);
			vo.setTaskStatus(TaskStatusEnum.OVER_TIME);
			return vo;
			} else {
			List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
			.finished()
			.processInstanceId(processInsId)
			.taskId(record.getTaskId())
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();
			if (CollectionUtils.isEmpty(list)) {
			return null;
			}
			List<HistoricTaskInstance> hisTask = this.distinctHisTask(list);
			this.setHisTaskInfo(hisTask.get(0), vo, projectId, processInsId);
			vo.setTaskStatus(TaskStatusEnum.OVER_TIME_FINISHED);
			return vo;
			}
			}).filter(Objects::nonNull).collect(Collectors.toList());
			result.data(vos);
			return vos;

			// // 查出运行在的任务key
			// List<Task> taskList = new ArrayList<>(12);
			// if (StringUtils.isNotBlank(taskName)) {
			// taskList = taskService.createTaskQuery().processInstanceId(processInsId).taskNameLike(taskName).orderByTaskCreateTime().desc().list();
			// } else {
			// taskList = taskService.createTaskQuery().processInstanceId(processInsId).orderByTaskCreateTime().desc().list();
			// }
			// if (CollectionUtils.isEmpty(taskList)) {
			// result.total(0);
			// return new ArrayList<>();
			// }
			// List<String> taskKeys = taskList.stream().map(Task::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			// Map<String, Task> taskMap = taskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
			// // 查出数据库的任务key
			// List<ProcessCoding> codeList = new LambdaQueryChainWrapper<>(processCodingService.getBaseMapper())
			// .eq(ProcessCoding::getProcessInsId, processInsId)
			// .in(ProcessCoding::getTaskDefKey, taskKeys)
			// .list();
			// List<Task> tList = new ArrayList<>();
			// // 判断
			// for (String key : taskMap.keySet()) {
			// List<ProcessCoding> targetProcessCodings = codeList.stream().filter(code -> key.equals(code.getTaskDefKey())).collect(Collectors.toList());
			// // 如果已完成的任务没从数据库查找出来，说明该任务没配置赋码等时间，直接设置为按时完成
			// if (CollectionUtils.isEmpty(targetProcessCodings)) {
			// tList.add(taskMap.get(key));
			// } else {
			// // 按照时间降序排列
			// targetProcessCodings.sort(Comparator.comparing(ProcessCoding::getGmtCreate).reversed());
			// ProcessCoding latestProjectProcess = targetProcessCodings.get(0);
			// if (Objects.nonNull(latestProjectProcess) && ProcessOverTimeConstants.OVERTIME.equals(latestProjectProcess.getOvertimeStatus())) {
			// tList.add(taskMap.get(key));
			// }
			// }
			// }
			//
			// if (startNum >= tList.size()) {
			// // 如果起始索引超出了列表的大小，返回一个空列表
			// return new ArrayList<>();
			// }
			// result.total(tList.size());
			// int end = Math.min(endNum, tList.size());
			// List<Task> pageTaskList = tList.subList(startNum, end);
			// List<String> taskDefs = pageTaskList.stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			// Map<String, Task> keyMap = pageTaskList.stream().collect(Collectors.toMap(Task::getTaskDefinitionKey, his -> his));
			//
			// // 得到目标任务对应的定义
			// List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
			//
			// // 查询任务相关信息
			// List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
			// Task task = keyMap.get(userTask.getId());
			// CustomerTaskVO vo = new CustomerTaskVO();
			// this.setRuntimeTaskInfo(task, vo, projectId);
			// return vo;
			// }).collect(Collectors.toList());
			// result.data(vos);
			// return vos;
			}

			/**
			@@ -1347,6 +1913,8 @@
			return Long.valueOf(tList.size());
			}



			/**
			* 查询即将超时的任务
			*
			@@ -1359,7 +1927,7 @@
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getWillOvertimeTask(Long projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			private List<CustomerTaskVO> getWillOvertimeTask(String projectId, String processDefinitionId, String processInsId, String taskName, Integer pageNum, Integer pageSize, Result result) {
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;

			@@ -1422,6 +1990,477 @@
			return vos;
			}

			@Override
			public void getIndexWaitTask(String s, int pageSize, int pageNum, Result result) {
			// 查出容缺过的任务
			List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list();
			// 排除容缺后又完成的任务
			List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED)
			.list();
			List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
			// 得到未完成的容缺任务
			List<String> waitTaskIds = allWaitTaskList.stream().filter(log -> !finishedTaskIds.contains(log.getTaskId())).map(ProcessLog::getTaskId).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(waitTaskIds)) {
			result.total(0l);
			result.data(new ArrayList<>());
			return;
			}
			List<HistoricTaskInstance> hisTasks = waitTaskIds.stream().map(waitTaskId -> {
			List<ProcessLog> logs = allWaitTaskList.stream().filter(item -> item.getTaskId().equals(waitTaskId)).collect(Collectors.toList());
			HistoricTaskInstance hisTask = null;
			if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(logs)) {
			// 容缺的任务都属于历史任务，只是需要补表单数据
			HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(logs.get(0).getProcessInsId())
			.taskId(waitTaskId)
			.includeIdentityLinks()
			.orderByHistoricTaskInstanceStartTime()
			.desc();
			if (!SecurityUtils.getLoginUser().getUser().isAdmin()) {
			query
			.or()
			.taskCandidateGroupIn(taskCommonService.getCurrentUserGroups())
			.taskCandidateUser(SecurityUtils.getUserId() + "")
			.taskAssignee(SecurityUtils.getUserId() + "")
			.endOr();
			}
			List<HistoricTaskInstance> hisTaskList = query.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(hisTaskList)) {
			hisTask = hisTaskList.get(0);
			}
			}
			return hisTask;
			}).filter(Objects::nonNull).collect(Collectors.toList());

			if (CollectionUtils.isEmpty(hisTasks)) {
			result.total(0l);
			result.data(new ArrayList<>());
			return;
			}
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;
			if (startNum >= hisTasks.size()) {
			result.total(0l);
			// 如果起始索引超出了列表的大小，返回一个空列表
			result.data(new ArrayList<>());
			return;
			}
			result.total(hisTasks.size());
			int end = Math.min(endNum, hisTasks.size());
			List<HistoricTaskInstance> targetTask = hisTasks.subList(startNum, end);

			// 转换成VO
			List<IndexCustomerTaskVO> vos = targetTask.stream().map(userTask -> {
			IndexCustomerTaskVO vo = new IndexCustomerTaskVO();
			vo.setProcessInsId(userTask.getProcessInstanceId());
			vo.setProcessDefId(userTask.getProcessDefinitionId());

			// 查出流程
			ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(userTask.getProcessInstanceId()).singleResult();
			String deployId = "";
			String processName = "";
			if (Objects.nonNull(process)) {
			deployId = process.getDeploymentId();
			processName = process.getProcessDefinitionName();
			} else {
			HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(userTask.getProcessInstanceId()).singleResult();
			deployId = hisProcess.getDeploymentId();
			processName = hisProcess.getProcessDefinitionName();
			}

			String finalDeployId = deployId;
			String finalProcessName = processName;

			vo.setDeployId(finalDeployId);
			vo.setTaskName(userTask.getName());
			vo.setProcessName(finalProcessName);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(baseMapper)
			.eq(ProjectProcess::getProcessInsId, userTask.getProcessInstanceId())
			.one();
			if (Objects.isNull(projectProcess)) {
			throw new RuntimeException("项目流程未启动");
			}
			String projectId = "";
			String projectName = "";
			if (Objects.nonNull(projectProcess)) {
			if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.PROJECT)) {
			ProjectInfo project = projectInfoMapper.selectById(projectProcess.getProjectId());
			if (Objects.nonNull(project)) {
			projectId = projectProcess.getProjectId();
			projectName = project.getProjectName();
			}
			} else if (projectProcess.getProjectType().equals(ProjectProcessTypeEnum.ENGINEERING)) {
			ProjectEngineering engineering = projectEngineeringMapper.selectById(projectProcess.getProjectId());
			if (Objects.nonNull(engineering)) {
			projectId = projectProcess.getProjectId();
			projectName = engineering.getProjectName();
			}
			}
			}
			vo.setProjectId(projectId);
			vo.setProjectName(projectName);
			List<UserTask> uTaskList = this.getAllUserTaskElement(userTask.getProcessDefinitionId()).stream().filter(item -> item.getId().equals(userTask.getTaskDefinitionKey())).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(uTaskList)) {
			throw new RuntimeException("未找到流程任务设计");
			}
			this.setCandidateInfo(uTaskList.get(0), vo, projectProcess.getProjectId(), userTask.getProcessInstanceId());

			vo.setTaskStatus(TaskStatusEnum.WAIT);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(userTask.getId());
			vo.setExecutionId(userTask.getExecutionId());
			vo.setCreateTime(userTask.getStartTime());

			vo.setTaskDefinitionKey(userTask.getTaskDefinitionKey());

			this.distinctVo(vo);
			return vo;
			}).collect(Collectors.toList());
			result.data(vos);
			}

			/**
			* 获取跳过任务
			*
			* @param processInsId
			* @return
			*/
			private Long getJumpTaskNum(String processInsId) {
			// 查出跳过的任务
			List<ProcessLog> allJumpTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list();
			// 排除驳回的
			List<String> rejectTaskIds = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.select(ProcessLog::getTaskId)
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.REJECT)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list().stream().map(ProcessLog::getTaskId).collect(Collectors.toList());

			List<String> jumpTaskIds = allJumpTaskList.stream().map(ProcessLog::getTaskId).collect(Collectors.toList());
			jumpTaskIds.removeAll(rejectTaskIds);
			if(CollectionUtils.isEmpty(jumpTaskIds)) {
			return 0L;
			}
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.finished()
			.taskIds(jumpTaskIds)
			.includeIdentityLinks()
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除运行时任务
			List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
			return Long.valueOf(hisTaskList.size());
			}

			/**
			* 获取跳过任务
			*
			* @param projectId
			* @param processDefinitionId
			* @param processInsId
			* @param taskName
			* @param pageNum
			* @param pageSize
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getJumpTask(String projectId,
			String processDefinitionId,
			String processInsId,
			String taskName,
			Integer pageNum,
			Integer pageSize,
			Result result) {
			// 查出跳过的任务
			List<ProcessLog> allJumpTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP)
			.like(StringUtils.isNotBlank(taskName), ProcessLog::getTaskName, taskName)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list();
			// 排除驳回的
			List<String> rejectTaskIds = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.select(ProcessLog::getTaskId)
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.REJECT)
			.like(StringUtils.isNotBlank(taskName), ProcessLog::getTaskName, taskName)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list().stream().map(ProcessLog::getTaskId).collect(Collectors.toList());

			List<String> jumpTaskIds = allJumpTaskList.stream().map(ProcessLog::getTaskId).collect(Collectors.toList());
			jumpTaskIds.removeAll(rejectTaskIds);
			if(CollectionUtils.isEmpty(jumpTaskIds)) {
			result.total(0l);
			return new ArrayList<>();
			}
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.finished()
			.taskIds(jumpTaskIds)
			.includeIdentityLinks()
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除运行时任务
			List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(hisTaskList)) {
			result.total(0l);
			return new ArrayList<>();
			}
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;
			if (startNum >= hisTaskList.size()) {
			result.total(0l);
			// 如果起始索引超出了列表的大小，返回一个空列表
			return new ArrayList<>();
			}
			result.total(hisTaskList.size());
			int end = Math.min(endNum, hisTaskList.size());
			List<HistoricTaskInstance> targetTaskList = hisTaskList.subList(startNum, end);

			// 转换成VO
			// 得到目标任务对应的定义
			List<String> taskDefs = targetTaskList.stream().map(HistoricTaskInstance::getTaskDefinitionKey).collect(Collectors.toList());
			Map<String, HistoricTaskInstance> keyMap = targetTaskList.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
			List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());

			// 查出流程
			ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			String deployId = "";
			String processName = "";
			if (Objects.nonNull(process)) {
			deployId = process.getDeploymentId();
			processName = process.getProcessDefinitionName();
			} else {
			HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			deployId = hisProcess.getDeploymentId();
			processName = hisProcess.getProcessDefinitionName();
			}

			String finalDeployId = deployId;
			String finalProcessName = processName;
			List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
			CustomerTaskVO vo = new CustomerTaskVO();
			vo.setProcessInsId(processInsId);
			vo.setProcessDefId(processDefinitionId);
			vo.setDeployId(finalDeployId);
			vo.setTaskName(userTask.getName());
			vo.setProcessName(finalProcessName);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			this.setCandidateInfo(userTask, vo, projectId, processInsId);
			HistoricTaskInstance hisTask = keyMap.get(userTask.getId());
			if (Objects.nonNull(hisTask)) {
			vo.setTaskStatus(TaskStatusEnum.JUMP);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(hisTask.getId());
			vo.setExecutionId(hisTask.getExecutionId());
			vo.setCreateTime(hisTask.getStartTime());

			// 查询实际处理人
			if (StringUtils.isNotBlank(hisTask.getAssignee())) {
			long handlerUserId = Long.parseLong(hisTask.getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			vo.getHandlerName().add(this.getUserShowName(handlerUser));
			if (Objects.nonNull(handlerUser.getDept())) {
			vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
			vo.getHandlerUnitName().add(handlerUser.getDept().getDeptName());
			}
			}
			}
			this.setHandler(vo, hisTask.getIdentityLinks());
			vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
			}
			this.distinctVo(vo);
			return vo;
			}).collect(Collectors.toList());
			result.data(vos);
			return vos;
			}

			/**
			* 容缺任务分页
			*
			* @param projectId
			* @param processDefinitionId
			* @param processInsId
			* @param taskName
			* @param pageNum
			* @param pageSize
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getWaitTask(String projectId,
			String processDefinitionId,
			String processInsId,
			String taskName,
			Integer pageNum,
			Integer pageSize,
			Result result) {

			// 查出容缺过的任务
			List<ProcessLog> allWaitTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
			.like(StringUtils.isNotBlank(taskName), ProcessLog::getTaskName, taskName)
			.orderByDesc(ProcessLog::getGmtCreate)
			.list();
			// 排除容缺后又完成的任务
			List<ProcessLog> finishedTaskList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getProcessInsId, processInsId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.REJECT)
			.list();
			List<String> finishedTaskIds = finishedTaskList.stream().map(ProcessLog::getTaskId).distinct().collect(Collectors.toList());
			// 得到未完成的容缺任务
			List<String> waitTaskIds = allWaitTaskList.stream().filter(log -> !finishedTaskIds.contains(log.getTaskId())).map(ProcessLog::getTaskId).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(waitTaskIds)) {
			result.total(0l);
			return new ArrayList<>();
			}
			// 容缺的任务都属于历史任务，只是需要补表单数据
			List<HistoricTaskInstance> hisTaskList = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(processInsId)
			.taskIds(waitTaskIds)
			.includeIdentityLinks()
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list();
			hisTaskList = this.distinctHisTask(hisTaskList);
			// 排除运行时任务
			List<String> runTaskKeys = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			hisTaskList = hisTaskList.stream().filter(his -> !runTaskKeys.contains(his.getTaskDefinitionKey())).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(hisTaskList)) {
			result.total(0l);
			return new ArrayList<>();
			}
			int startNum = pageSize * (pageNum - 1);
			int endNum = startNum + pageSize;
			if (startNum >= hisTaskList.size()) {
			result.total(0l);
			// 如果起始索引超出了列表的大小，返回一个空列表
			return new ArrayList<>();
			}
			result.total(hisTaskList.size());
			int end = Math.min(endNum, hisTaskList.size());
			List<HistoricTaskInstance> targetTask = hisTaskList.subList(startNum, end);

			// 转换成VO
			// 得到目标任务对应的定义
			List<String> taskDefs = targetTask.stream().map(HistoricTaskInstance::getTaskDefinitionKey).collect(Collectors.toList());
			Map<String, HistoricTaskInstance> keyMap = targetTask.stream().collect(Collectors.toMap(HistoricTaskInstance::getTaskDefinitionKey, his -> his));
			List<UserTask> finishedUserTaskElement = this.getAllUserTaskElement(processDefinitionId).stream().filter(el -> taskDefs.contains(el.getId())).collect(Collectors.toList());
			// 查出流程
			ProcessInstance process = runtimeService.createProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			String deployId = "";
			String processName = "";
			if (Objects.nonNull(process)) {
			deployId = process.getDeploymentId();
			processName = process.getProcessDefinitionName();
			} else {
			HistoricProcessInstance hisProcess = historyService.createHistoricProcessInstanceQuery().processInstanceId(processInsId).singleResult();
			deployId = hisProcess.getDeploymentId();
			processName = hisProcess.getProcessDefinitionName();
			}

			String finalDeployId = deployId;
			String finalProcessName = processName;
			List<CustomerTaskVO> vos = finishedUserTaskElement.stream().map(userTask -> {
			CustomerTaskVO vo = new CustomerTaskVO();
			vo.setProcessInsId(processInsId);
			vo.setProcessDefId(processDefinitionId);
			vo.setDeployId(finalDeployId);
			vo.setTaskName(userTask.getName());
			vo.setProcessName(finalProcessName);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			this.setCandidateInfo(userTask, vo, projectId, processInsId);
			HistoricTaskInstance hisTask = keyMap.get(userTask.getId());
			if (Objects.nonNull(hisTask)) {
			vo.setTaskStatus(TaskStatusEnum.WAIT);
			// 如果是已完成的，信息需要单独赋值
			vo.setTaskId(hisTask.getId());
			vo.setExecutionId(hisTask.getExecutionId());
			vo.setCreateTime(hisTask.getStartTime());

			// 查询实际处理人
			if (StringUtils.isNotBlank(hisTask.getAssignee())) {
			long handlerUserId = Long.parseLong(hisTask.getAssignee());
			SysUser handlerUser = sysUserService.selectUserById(handlerUserId);
			if (Objects.nonNull(handlerUser)) {
			vo.getHandlerId().add(handlerUserId);
			if (Objects.nonNull(handlerUser.getDept())) {
			vo.getHandlerUnitId().add(handlerUser.getDept().getDeptId());
			}
			}
			}
			this.setHandler(vo, hisTask.getIdentityLinks());
			vo.setTaskDefinitionKey(hisTask.getTaskDefinitionKey());
			}
			this.distinctVo(vo);
			return vo;
			}).collect(Collectors.toList());
			result.data(vos);
			return vos;
			}

			/**
			* 查询剩余事项（未开始的任务）
			*
			@@ -1434,7 +2473,7 @@
			* @param result
			* @return
			*/
			private List<CustomerTaskVO> getRemainingTask(Long projectId,
			private List<CustomerTaskVO> getRemainingTask(String projectId,
			String processDefinitionId,
			String processInsId,
			String taskName,
			@@ -1456,8 +2495,14 @@

			// 排除进行中的任务和已完成的任务
			List<String> runTaskKeyList = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			List<String> finishedTaskKeyList = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInsId).finished().list().stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			allUserTaskElement = allUserTaskElement.stream().filter(el -> !runTaskKeyList.contains(el.getId()) && !finishedTaskKeyList.contains(el.getId())).collect(Collectors.toList());
			List<String> finishedTaskKeyList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.select(ProcessLog::getTaskDefKey)
			.eq(ProcessLog::getProcessInsId, processInsId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
			.list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
			finishedTaskKeyList.addAll(runTaskKeyList);
			// List<String> finishedTaskKeyList = historyService.createHistoricTaskInstanceQuery().processInstanceId(processInsId).finished().list().stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().collect(Collectors.toList());
			allUserTaskElement = allUserTaskElement.stream().filter(el -> finishedTaskKeyList.indexOf(el.getId()) == -1).collect(Collectors.toList());
			// 模拟模糊查询
			if (StringUtils.isNotBlank(taskName)) {
			allUserTaskElement = allUserTaskElement.stream().filter(taskEl -> taskEl.getName().contains(taskName)).collect(Collectors.toList());
			@@ -1480,10 +2525,14 @@
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			List<String> promoterNames = new ArrayList<>(2);
			List<String> promoterUnitNames = new ArrayList<>(2);
			vo.setHandlerId(handlerIds);
			vo.setHandlerName(handlerNames);
			vo.setHandlerUnitId(handlerUnitIds);
			vo.setHandlerUnitName(handlerUnitNames);
			vo.setPromoterName(promoterNames);
			vo.setPromoterUnitName(promoterUnitNames);

			vo.setProcessInsId(process.getId());
			vo.setProcessDefId(processDefinitionId);
			@@ -1491,6 +2540,9 @@
			vo.setTaskName(userTask.getName());
			vo.setProcessName(process.getProcessDefinitionName());
			vo.setTaskStatus(TaskStatusEnum.NOT_START);

			this.setCandidateInfo(userTask, vo, projectId, processInsId);

			// 未开始的任务，其关联的用户组这些都可以从UserTask中拿到，因为本身未开始的任务是没有task的，所以这里直接查
			if (StringUtils.isNotBlank(userTask.getAssignee())) {
			vo.setHandlerType(HandlerTypeEnum.USER);
			@@ -1509,7 +2561,7 @@
			// 处理变量表达式，DATA_LAUNCH只可能是部门不会是角色，因为代表的是业主部门
			if (groupId.contains(ProcessConstants.DATA_LAUNCH)) {
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT);
			this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT, 1);
			} else if (groupId.startsWith("dept")) { // 部门的id是加了前缀的如：dept:1
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			String[] split = groupId.split(":");
			@@ -1552,10 +2604,10 @@

			/**
			* 处理流程变量-业主单位
			*
			* @param setType 0 设置责任单位 1 设置办理单位
			* @param vo
			*/
			private void varYzReview(CustomerTaskVO vo, Long projectId, String processInsId, HandlerTypeEnum type) {
			private void varYzReview(CustomerTaskVO vo, String projectId, String processInsId, HandlerTypeEnum type, Integer setType) {
			ProjectProcess projectProcess = new LambdaQueryChainWrapper<>(projectProcessMapper)
			.eq(ProjectProcess::getProjectId, projectId)
			.eq(ProjectProcess::getProcessInsId, processInsId)
			@@ -1572,8 +2624,14 @@
			} else if (HandlerTypeEnum.DEPT.equals(type)) {
			SysDept dept = deptService.selectDeptById(projectProcess.getDataLaunch());
			if (Objects.nonNull(dept)) {
			vo.getHandlerUnitId().add(dept.getDeptId());
			vo.getHandlerUnitName().add(dept.getDeptName());
			if (setType == 1) {
			vo.getHandlerUnitId().add(dept.getDeptId());
			vo.getHandlerUnitName().add(dept.getDeptName());
			vo.getHandlerName().add(this.getDeptLeaderShowName(dept));
			} else {
			vo.getPromoterUnitName().add(dept.getDeptName());
			vo.getPromoterName().add(this.getDeptLeaderShowName(dept));
			}
			}
			} else if (HandlerTypeEnum.ROLE.equals(type)) {
			SysRole role = sysRoleService.selectRoleById(projectProcess.getDataLaunch());
			@@ -1601,16 +2659,80 @@
			// 运行时未找到流程，说明流程已经结束了
			return 0L;
			}
			// 查出已完成的任务，用总任务数-已完成的就得到剩余事项
			List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(process.getProcessInstanceId())
			.finished()
			.list();
			long num = list.stream().map(HistoricTaskInstance::getTaskDefinitionKey).distinct().count();
			List<UserTask> allUserTaskElement = this.getAllUserTaskElement(processDefinitionId);

			return totalNum - num;
			// 排除进行中的任务和已完成的任务
			List<String> runTaskKeyList = taskService.createTaskQuery().processInstanceId(processInsId).list().stream().map(Task::getTaskDefinitionKey).collect(Collectors.toList());
			List<String> finishedTaskKeyList = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.select(ProcessLog::getTaskDefKey)
			.eq(ProcessLog::getProcessInsId, processInsId)
			.in(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED, ProcessLogEventTypeEnum.JUMP, ProcessLogEventTypeEnum.WAIT)
			.list().stream().map(ProcessLog::getTaskDefKey).collect(Collectors.toList());
			finishedTaskKeyList.addAll(runTaskKeyList);
			allUserTaskElement = allUserTaskElement.stream().filter(el -> finishedTaskKeyList.indexOf(el.getId()) == -1).collect(Collectors.toList());
			return Long.valueOf(allUserTaskElement.size());
			}

			/**
			* 设置候选人信息/责任单位
			*
			* @param userTask
			* @param vo
			* @param projectId
			* @param processInsId
			*/
			private void setCandidateInfo(UserTask userTask, CustomerTaskVO vo, String projectId, String processInsId) {
			if (StringUtils.isNotBlank(userTask.getAssignee())) {
			vo.setHandlerType(HandlerTypeEnum.USER);
			SysUser sysUser = sysUserService.selectUserById(Long.parseLong(userTask.getAssignee()));
			if (Objects.nonNull(sysUser)) {
			if (Objects.nonNull(sysUser.getDept())) {
			// 如果是指定的某个人，那么责任单位是这个人所在的部门
			vo.getPromoterUnitName().add(sysUser.getDept().getDeptName());
			vo.getPromoterName().add(this.getUserShowName(sysUser));
			}
			}
			} else if (CollectionUtil.isNotEmpty(userTask.getCandidateGroups())) {
			List<String> groupIds = userTask.getCandidateGroups();
			for (String groupId : groupIds) {
			// 处理变量表达式，DATA_LAUNCH只可能是部门不会是角色，因为代表的是业主部门
			if (groupId.contains(ProcessConstants.DATA_LAUNCH)) {
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			this.varYzReview(vo, projectId, processInsId, HandlerTypeEnum.DEPT, 0);
			} else if (groupId.startsWith("dept")) { // 部门的id是加了前缀的如：dept:1
			vo.setHandlerType(HandlerTypeEnum.DEPT);
			String[] split = groupId.split(":");
			if (split.length > 1) {
			// 部门
			SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
			if (Objects.nonNull(dept)) {
			vo.getPromoterUnitName().add(this.setDeptNameWithParentName(dept));
			vo.getPromoterName().add(this.getDeptLeaderShowName(dept));
			}
			}
			} else {
			vo.setHandlerType(HandlerTypeEnum.ROLE);
			SysRole role = sysRoleService.selectRoleById(Long.parseLong(groupId));
			if (Objects.nonNull(role)) {
			vo.getPromoterUnitName().add(role.getRoleName());
			}
			}
			}
			}
			}

			/**
			* 设置部门名称时带上上级部门名称
			* @param dept
			*/
			private String setDeptNameWithParentName(SysDept dept) {
			String[] str = dept.getAncestors().split(",");
			if (str.length >= 4){
			return dept.getParentName() + " / " + dept.getDeptName();
			}else {
			return dept.getDeptName();
			}
			}

			/**
			* 设置任务的发起人&处理人只有待办任务和已完成任务才会掉这个方法
			@@ -1618,18 +2740,7 @@
			* @param taskVO
			* @param identityLinkInfos 如果是已完成的任务，用这个去取关联的用户/用户组
			*/
			private void setPromoterAndHandler(CustomerTaskVO taskVO, List<? extends IdentityLinkInfo> identityLinkInfos) {
			this.setPromoterInfo(taskVO);

			// 一个任务可能有多个候选人/组，所以需要使用list
			List<Long> handlerIds = new ArrayList<>(2);
			List<String> handlerNames = new ArrayList<>(2);
			List<Long> handlerUnitIds = new ArrayList<>(2);
			List<String> handlerUnitNames = new ArrayList<>(2);
			taskVO.setHandlerId(handlerIds);
			taskVO.setHandlerName(handlerNames);
			taskVO.setHandlerUnitId(handlerUnitIds);
			taskVO.setHandlerUnitName(handlerUnitNames);
			private void setHandler(CustomerTaskVO taskVO, List<? extends IdentityLinkInfo> identityLinkInfos) {

			// 流程处理人信息
			if (TaskStatusEnum.TODO.equals(taskVO.getTaskStatus())) {
			@@ -1643,11 +2754,11 @@
			SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
			if (Objects.nonNull(sysUser)) {
			taskVO.setHandlerType(HandlerTypeEnum.USER);
			handlerIds.add(sysUser.getUserId());
			handlerNames.add(sysUser.getNickName());
			taskVO.getHandlerId().add(sysUser.getUserId());
			taskVO.getHandlerName().add(this.getUserShowName(sysUser));
			if (Objects.nonNull(sysUser.getDept())) {
			handlerUnitIds.add(sysUser.getDept().getDeptId());
			handlerUnitNames.add(sysUser.getDept().getDeptName());
			taskVO.getHandlerUnitId().add(sysUser.getDept().getDeptId());
			taskVO.getHandlerUnitName().add(sysUser.getDept().getDeptName());
			}
			}
			// 绑定的是角色或者是部门，需要根据id判断
			@@ -1659,32 +2770,32 @@
			// 部门
			SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
			if (Objects.nonNull(dept)) {
			handlerUnitIds.add(dept.getDeptId());
			handlerUnitNames.add(dept.getDeptName());
			taskVO.getHandlerUnitId().add(dept.getDeptId());
			taskVO.getHandlerUnitName().add(dept.getDeptName());
			}
			}
			} else {
			taskVO.setHandlerType(HandlerTypeEnum.ROLE);
			SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
			if (Objects.nonNull(role)) {
			handlerUnitIds.add(role.getRoleId());
			handlerUnitNames.add(role.getRoleName());
			taskVO.getHandlerUnitId().add(role.getRoleId());
			taskVO.getHandlerUnitName().add(role.getRoleName());
			}
			}
			}
			}
			} else if (TaskStatusEnum.FINISHED.equals(taskVO.getTaskStatus())) {
			} else if (TaskStatusEnum.FINISHED.equals(taskVO.getTaskStatus()) \|\| TaskStatusEnum.WAIT.equals(taskVO.getTaskStatus())) {
			for (IdentityLinkInfo identityLink : identityLinkInfos) {
			// 绑定的是用户，查出用户姓名、部门
			if (StringUtils.isNotBlank(identityLink.getUserId())) {
			taskVO.setHandlerType(HandlerTypeEnum.USER);
			SysUser sysUser = sysUserService.selectUserById(Long.parseLong(identityLink.getUserId()));
			if (Objects.nonNull(sysUser)) {
			handlerIds.add(sysUser.getUserId());
			handlerNames.add(sysUser.getNickName());
			taskVO.getHandlerId().add(sysUser.getUserId());
			taskVO.getHandlerName().add(this.getUserShowName(sysUser));
			if (Objects.nonNull(sysUser.getDept())) {
			handlerUnitIds.add(sysUser.getDept().getDeptId());
			handlerUnitNames.add(sysUser.getDept().getDeptName());
			taskVO.getHandlerUnitId().add(sysUser.getDept().getDeptId());
			taskVO.getHandlerUnitName().add(sysUser.getDept().getDeptName());
			}
			}
			// 绑定的是角色，查出角色名称
			@@ -1696,22 +2807,21 @@
			// 部门
			SysDept dept = sysDeptService.selectDeptById(Long.parseLong(split[1]));
			if (Objects.nonNull(dept)) {
			handlerUnitIds.add(dept.getDeptId());
			handlerUnitNames.add(dept.getDeptName());
			taskVO.getHandlerUnitId().add(dept.getDeptId());
			taskVO.getHandlerUnitName().add(dept.getDeptName());
			}
			}
			} else {
			taskVO.setHandlerType(HandlerTypeEnum.ROLE);
			SysRole role = sysRoleService.selectRoleById(Long.parseLong(identityLink.getGroupId()));
			if (Objects.nonNull(role)) {
			handlerUnitIds.add(role.getRoleId());
			handlerUnitNames.add(role.getRoleName());
			taskVO.getHandlerUnitId().add(role.getRoleId());
			taskVO.getHandlerUnitName().add(role.getRoleName());
			}
			}
			}
			}
			}

			this.distinctVo(taskVO);
			}

			@@ -1721,41 +2831,41 @@
			* @param taskVO
			*/
			private void setPromoterInfo(CustomerTaskVO taskVO) {
			// 发起人应为上一节点的处理人
			List<String> beforeNodeKey = taskCommonService.getBeforeNodeInfo(taskVO.getProcessDefId(), taskVO.getTaskDefinitionKey());
			List<SysUser> userList = beforeNodeKey.stream().map(key -> {
			List<HistoricTaskInstance> historicTaskInstances = historyService.createHistoricTaskInstanceQuery()
			.processInstanceId(taskVO.getProcessInsId())
			.taskDefinitionKey(key)
			.orderByHistoricTaskInstanceStartTime()
			.desc()
			.list(); // 之所以用list是因为如果某个任务被驳回过，且如果该任务再次执行时会有多条数据，取最新的一条
			if (!CollectionUtils.isEmpty(historicTaskInstances)) {
			// 实际领取这个任务的人，也就是处理人
			String assignee = historicTaskInstances.get(0).getAssignee();
			SysUser startUser = sysUserService.selectUserById(Long.parseLong(assignee));
			return startUser;
			} else {
			return null;
			}
			}).filter(user -> Objects.nonNull(user)).collect(Collectors.toList());
			if (CollectionUtils.isEmpty(userList)) {
			taskVO.setPromoterName("暂无");
			taskVO.setPromoterUnitName("暂无");
			} else {
			taskVO.setPromoterId(userList.stream().map(user -> {
			return user.getUserId() + "";
			}).collect(Collectors.joining("、")));
			taskVO.setPromoterName(userList.stream().map(user -> {
			return user.getNickName();
			}).collect(Collectors.joining("、")));
			taskVO.setPromoterUnitId(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
			return user.getDept().getDeptId() + "";
			}).collect(Collectors.joining("、")));
			taskVO.setPromoterUnitName(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
			return user.getDept().getDeptName() + "";
			}).collect(Collectors.joining("、")));
			}
			// // 发起人应为上一节点的处理人
			// List<String> beforeNodeKey = taskCommonService.getBeforeNodeInfo(taskVO.getProcessDefId(), taskVO.getTaskDefinitionKey());
			// List<SysUser> userList = beforeNodeKey.stream().map(key -> {
			// List<HistoricTaskInstance> historicTaskInstances = historyService.createHistoricTaskInstanceQuery()
			// .processInstanceId(taskVO.getProcessInsId())
			// .taskDefinitionKey(key)
			// .orderByHistoricTaskInstanceStartTime()
			// .desc()
			// .list(); // 之所以用list是因为如果某个任务被驳回过，且如果该任务再次执行时会有多条数据，取最新的一条
			// if (!CollectionUtils.isEmpty(historicTaskInstances)) {
			// // 实际领取这个任务的人，也就是处理人
			// String assignee = historicTaskInstances.get(0).getAssignee();
			// SysUser startUser = sysUserService.selectUserById(Long.parseLong(assignee));
			// return startUser;
			// } else {
			// return null;
			// }
			// }).filter(user -> Objects.nonNull(user)).collect(Collectors.toList());
			// if (CollectionUtils.isEmpty(userList)) {
			// taskVO.setPromoterName("暂无");
			// taskVO.setPromoterUnitName("暂无");
			// } else {
			// taskVO.setPromoterId(userList.stream().map(user -> {
			// return user.getUserId() + "";
			// }).collect(Collectors.joining("、")));
			// taskVO.setPromoterName(userList.stream().map(user -> {
			// return this.getUserShowName(user);
			// }).collect(Collectors.joining("、")));
			// taskVO.setPromoterUnitId(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
			// return user.getDept().getDeptId() + "";
			// }).collect(Collectors.joining("、")));
			// taskVO.setPromoterUnitName(userList.stream().filter(user -> Objects.nonNull(user.getDept())).map(user -> {
			// return user.getDept().getDeptName() + "";
			// }).collect(Collectors.joining("、")));
			// }
			}

			/**
			@@ -1822,4 +2932,207 @@
			private List<Task> getCurrentNodeTaskList(String processInstanceId) {
			return taskService.createTaskQuery().processDefinitionId(processInstanceId).list();
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public Result editFinishedTask(EditFinishedTaskForm form) {
			List<HistoricTaskInstance> hisTasks = historyService.createHistoricTaskInstanceQuery().taskId(form.getTaskId()).orderByHistoricTaskInstanceStartTime().desc().list();
			if (org.apache.commons.collections4.CollectionUtils.isEmpty(hisTasks) \|\| Objects.isNull(hisTasks.get(0))) {
			return Result.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 Result.error("项目流程未绑定");
			}
			// 查出字典中需要注入的字段信息
			List<String> dictList = dictTypeService.selectDictDataByType("flow_variables").stream().map(SysDictData::getDictValue).collect(Collectors.toList());
			Map<String, Object> newV = new HashMap<>(2);
			if (!org.springframework.util.CollectionUtils.isEmpty(form.getVariables())) {
			for (String key : form.getVariables().keySet()) {
			newV.put(task.getTaskDefinitionKey() + "&" + key, form.getVariables().get(key));
			// 字典里有就不做处理
			if (!org.apache.commons.collections4.CollectionUtils.isEmpty(dictList) && dictList.contains(key)) {
			newV.put(key,form.getVariables().get(key));
			}
			}
			}
			ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(task.getProcessInstanceId()).singleResult();
			Date now = new Date();

			// 1. 表单变量替换
			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.nonNull(var)) {
			// 先删除原来的变量，再把当前的保存进去
			projectProcessMapper.deleteHisFlowableVar(var.getID_());
			projectProcessMapper.deleteRunFlowableVar(var.getID_());
			if (StringUtils.isNotBlank(var.getBYTEARRAY_ID_())) {
			projectProcessMapper.deleteByteArray(var.getID_());
			}
			}

			// 保存当前的表单数据
			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);

			}
			// 2. 任务状态调整：仅支持已完成==》容缺/跳过容缺《===》跳过
			if (Objects.nonNull(form.getNowStatus()) && ! Objects.equals(form.getOriginalStatus(), form.getNowStatus())) {
			if (TaskStatusEnum.FINISHED.equals(form.getOriginalStatus())) {
			ProcessLog finishedLog = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.FINISHED)
			.one();
			if (Objects.nonNull(finishedLog)) {
			if (TaskStatusEnum.JUMP.equals(form.getNowStatus())) {
			// 添加跳过日志
			publisher.publishEvent(new TaskLogEvent(this, null,
			finishedLog.getUserId(),
			projectProcess.getProjectId(),
			projectProcess.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.JUMP,
			new JumpData(form.getTaskJumpForm().getDesc())));
			// 删除原来的完成日志
			processLogService.removeById(finishedLog.getId());
			} else if (TaskStatusEnum.WAIT.equals(form.getNowStatus())) {
			// 添加容缺日志
			publisher.publishEvent(new TaskLogEvent(this, null,
			finishedLog.getUserId(),
			projectProcess.getProjectId(),
			projectProcess.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.WAIT,
			new WaitData(form.getTaskWaitForm().getDesc())));
			// 删除原来的完成日志
			processLogService.removeById(finishedLog.getId());
			} else {
			return Result.error("已完成任务只能调整为容缺或跳过状态");
			}
			}
			}
			else if (TaskStatusEnum.WAIT.equals(form.getOriginalStatus())) {
			ProcessLog waitLog = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.WAIT)
			.one();
			if (Objects.nonNull(waitLog)) {
			if (TaskStatusEnum.JUMP.equals(form.getNowStatus())) {
			// 添加跳过日志
			publisher.publishEvent(new TaskLogEvent(this, null,
			waitLog.getUserId(),
			projectProcess.getProjectId(),
			projectProcess.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.JUMP,
			new JumpData(form.getTaskJumpForm().getDesc())));
			// 删除原来的容缺日志
			processLogService.removeById(waitLog.getId());
			} else {
			return Result.error("容缺任务只能调整为跳过状态");
			}
			}
			} else if (TaskStatusEnum.JUMP.equals(form.getOriginalStatus())) {
			ProcessLog jumpLog = new LambdaQueryChainWrapper<>(processLogService.getBaseMapper())
			.eq(ProcessLog::getTaskId, form.getTaskId())
			.eq(ProcessLog::getEventType, ProcessLogEventTypeEnum.JUMP)
			.one();
			if (Objects.nonNull(jumpLog)) {
			if (TaskStatusEnum.WAIT.equals(form.getNowStatus())) {
			// 添加容缺日志
			publisher.publishEvent(new TaskLogEvent(this, null,
			jumpLog.getUserId(),
			projectProcess.getProjectId(),
			projectProcess.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.WAIT,
			new WaitData(form.getTaskWaitForm().getDesc())));
			// 删除原来的跳过日志
			processLogService.removeById(jumpLog.getId());
			} else {
			return Result.error("跳过任务只能调整为容缺任务");
			}
			}
			}
			}
			// 3. 保存修改日志
			publisher.publishEvent(new TaskLogEvent(this, null,
			SecurityUtils.getUserId(),
			projectProcess.getProjectId(),
			projectProcess.getProcessInsId(),
			form.getTaskId(),
			task.getTaskDefinitionKey(),
			task.getName(),
			ProcessLogEventTypeEnum.EDIT,
			null));

			return Result.ok("修改成功");
			}
			}