toolchaintechnologycenter/spdm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

1、新增查询项目参与人员接口

Browse Source 
2、任务列表中的【所有任务】情况，添加权限校验（暂时先注释，待完成测试后正式提交发布）
This commit is contained in:
lidongyang
2026-01-30 06:45:32 +08:00
parent 3cf9cb692f
commit 74ec395793
7 changed files with 220 additions and 530 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
common/src/main/java/com/sdm/common/entity/enums/DelFlagTypeEnum.java Normal file
View File

@@ -0,0 +1,18 @@
package com.sdm.common.entity.enums;
public enum DelFlagTypeEnum {
NORMAL(0L),
DELETED(1L),
FREEZE(2L)
;
Long value;
DelFlagTypeEnum(Long i) {
value = i;
}
public Long getValue() {
return value;
}
}

3
outbridge/src/main/java/com/sdm/outbridge/entity/LyricVProjectResourcePlanDM.java
View File

@@ -3,10 +3,11 @@ package com.sdm.outbridge.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName(value = "v_project_resource_plan_DM", autoResultMap = true)

11
project/src/main/java/com/sdm/project/controller/SimulationLyricNodeController.java
View File

@@ -156,5 +156,16 @@ public class SimulationLyricNodeController {
return lyricInternalService.getHkToken();
}
/**
* 查询项目参与人员
*
* @return
*/
@GetMapping("/queryProjectMember")
@Operation(summary = "查询项目参与人员", description = "查询项目参与人员")
public SdmResponse queryProjectMember(@RequestParam String projectId,@RequestParam Integer current,@RequestParam Integer size) {
return lyricInternalService.queryProjectMember(projectId,current,size);
}
}

2
project/src/main/java/com/sdm/project/service/ILyricInternalService.java
View File

@@ -37,4 +37,6 @@ public interface ILyricInternalService {
SdmResponse getHkToken();
SdmResponse queryProjectMember(String projectId, Integer current, Integer size);
}

2
project/src/main/java/com/sdm/project/service/ITaskService.java
View File

@@ -77,8 +77,6 @@ public interface ITaskService {
SdmResponse getTaskListByDemandId(SpdmTaskListReq req);
SdmResponse newExportTaskTree(TaskTreeExportExcelFormat taskTreeExportExcelFormat, HttpServletResponse httpservletResponse);
SdmResponse getTaskAchieveStatistics(TaskCompleteStatisticsReq req);
SdmResponse<List<JSONObject>> getTaskConfidenceStatistics(String nodeType);

90
project/src/main/java/com/sdm/project/service/impl/LyricInternalServiceImpl.java
View File

@@ -131,6 +131,9 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
@Autowired
private ISimulationTaskService simulationTaskService;
@Autowired
private LyricVProjectResourcePlanDMService lyricVProjectResourcePlanDMService;
/**
* 判断字符串是否可以安全转换为Long类型
*
@@ -1090,13 +1093,13 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("total", list.size());
list = list.stream().skip((long) (current - 1) * size).limit(size).toList();
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("currentPage", current);
jsonObject.put("pageSize", size);
jsonObject.put("total", list.size());
jsonObject.put("data", list);
return SdmResponse.success(jsonObject);
}
@@ -1127,13 +1130,13 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("total", list.size());
list = list.stream().skip((long) (current - 1) * size).limit(size).toList();
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("currentPage", current);
jsonObject.put("pageSize", size);
jsonObject.put("total", list.size());
jsonObject.put("data", list);
return SdmResponse.success(jsonObject);
}
@@ -1164,13 +1167,13 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("total", list.size());
list = list.stream().skip((long) (current - 1) * size).limit(size).toList();
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("currentPage", current);
jsonObject.put("pageSize", size);
jsonObject.put("total", list.size());
jsonObject.put("data", list);
return SdmResponse.success(jsonObject);
}
@@ -1201,13 +1204,13 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("total", list.size());
list = list.stream().skip((long) (current - 1) * size).limit(size).toList();
if (CollectionUtils.isEmpty(list)) {
return SdmResponse.success(jsonObject);
}
jsonObject.put("currentPage", current);
jsonObject.put("pageSize", size);
jsonObject.put("total", list.size());
jsonObject.put("data", list);
return SdmResponse.success(jsonObject);
}
@@ -1582,4 +1585,83 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
return SdmResponse.success(token);
}
/**
* 查询EP项目
*/
private SimulationNode getSimulationNode(String projectId) {
return nodeService.lambdaQuery()
.eq(SimulationNode::getUuid, projectId)
.eq(SimulationNode::getProjectSource, SYNC_PROJECT_SOURCE)
.one();
}
/**
* 构建空分页数据
*/
private JSONObject buildEmptyPageData() {
return buildPageResult(1, 10, 0, new ArrayList<>());
}
/**
* 构建规范的分页返回结果，保证返回格式统一
* @param current 当前页
* @param size 页大小
* @param total 总条数
* @param data 分页数据
* @return 标准分页JSON
*/
private JSONObject buildPageResult(int current, int size, long total, List<LyricVProjectResourcePlanDM> data) {
JSONObject result = new JSONObject();
result.put("currentPage", current);
result.put("pageSize", size);
result.put("total", total); // 总条数是核心，必须返回原始总数据量
result.put("data", data);
return result;
}
@Override
public SdmResponse queryProjectMember(String projectId, Integer current, Integer size) {
log.info("开始查询项目参与人员信息，projectId：{}", projectId);
// 1. 入参校验
if (StringUtils.isBlank(projectId)) {
log.error("查询项目参与人员信息失败，projectId为空");
return SdmResponse.success(new ArrayList<>());
}
// 分页参数默认值：current默认1，size默认10（避免前端不传参导致计算异常）
int pageCurrent = ObjectUtils.isEmpty(current) || current < 1 ? 1 : current;
int pageSize = ObjectUtils.isEmpty(size) || size < 1 ? 10 : size;
// 2. 查询EP项目
SimulationNode simulationNode = getSimulationNode(projectId);
if (ObjectUtils.isEmpty(simulationNode)) {
log.error("查询项目参与人员信息失败，未找到对应EP项目，projectId：{}", projectId);
return SdmResponse.success(buildEmptyPageData());
}
// EP项目ID
Integer syncProjectId = simulationNode.getProjectId();
if (ObjectUtils.isEmpty(syncProjectId)) {
log.error("查询项目参与人员信息失败，EP项目：{}的projectId为空", simulationNode.getNodeName());
return SdmResponse.success(buildEmptyPageData());
}
log.info("查询项目参与人员信息，匹配到syncProjectId：{}", syncProjectId);
// 3. 查询项目参与人员
PageHelper.startPage(pageCurrent, pageSize);
List<LyricVProjectResourcePlanDM> projectMemberList = new ArrayList<>();
try {
projectMemberList = lyricVProjectResourcePlanDMService.lambdaQuery().eq(LyricVProjectResourcePlanDM::getProjectId, syncProjectId).list();
}catch (Exception ex) {
// 查询发生异常，记录异常日志（可能是测试环境预期异常）
if (ex instanceof MyBatisSystemException) {
log.warn("查询项目参与人员视图发生预期异常（测试环境），syncProjectId：{}，异常信息：{}",
syncProjectId, ex.getMessage());
} else {
log.error("查询项目参与人员视图发生非预期异常，syncProjectId：{}，异常信息：{}", syncProjectId, ex.getMessage());
}
}
PageInfo<LyricVProjectResourcePlanDM> page = new PageInfo<>(projectMemberList);
return PageUtils.getJsonObjectSdmResponse(projectMemberList, page);
}
}

624
project/src/main/java/com/sdm/project/service/impl/TaskServiceImpl.java
View File

@@ -42,6 +42,8 @@ import com.sdm.common.feign.impl.system.SysUserFeignClientImpl;
import com.sdm.common.utils.RandomUtil;
import com.sdm.common.utils.SystemOperate;
import com.sdm.common.utils.excel.ExcelUtil;
import com.sdm.outbridge.entity.LyricVProjectResourcePlanDM;
import com.sdm.outbridge.service.lyric.LyricVProjectResourcePlanDMService;
import com.sdm.project.bo.ExportOperate;
import com.sdm.project.common.MemberTypeEnum;
import com.sdm.project.common.TaskExeStatusEnum;
@@ -69,6 +71,7 @@ import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -113,10 +116,13 @@ public class TaskServiceImpl implements ITaskService {
@Autowired
private ISimulationTaskMemberService simulationTaskMemberService;
@Autowired
private ISimulationTaskService simulationTaskService;
@Autowired
private ISimulationTaskExtraService simulationTaskExtraService;
@Autowired
private ISimulationTaskAttentionService simulationTaskAttentionService;
@@ -129,9 +135,6 @@ public class TaskServiceImpl implements ITaskService {
@Resource
private INodeService nodeService;
@Autowired
private SimulationFlowFeignClientImpl flowFeignClient;
@Autowired
private ISimulationPerformanceExtraService simulationPerformanceExtraService;
@@ -141,38 +144,9 @@ public class TaskServiceImpl implements ITaskService {
@Resource
private SimulationNodeExtraService nodeExtraService;
private static final String NODE_NAME_KEY = "nodeName";
@Autowired
private LyricVProjectResourcePlanDMService lyricVProjectResourcePlanDMService;
private static final String NODE_CODE_KEY = "nodeCode";
private static final String PMEMBER_CODE_KEY = "pMemberList";
private static final String EMEMBER_CODE_KEY = "eMemberList";
private static final String PMEMBER_NAME = "仿真负责人";
private static final String EMEMBER_NAME = "仿真执行人";
private static final String MACHINE_NAME_KEY = "machineName";
private static final String MACHINE_CODE_KEY = "machineCode";
private static final String MACHINE_NAME = "机台名称";
private static final String MACHINE_CODE = "机台编号";
private static final String WORKSPACE_NAME_KEY = "workspaceName";
private static final String WORKSPACE_CODE_KEY = "workspaceCode";
private static final String WORKSPACE_NAME = "工位名称";
private static final String WORKSPACE_CODE = "工位编号";
private static final String DISCIPLINE_NAME_KEY = "disciplineName";
private static final String DISCIPLINE_CODE_KEY = "disciplineCode";
private static final String DISCIPLINE_NAME = "学科名称";
private static final String DISCIPLINE_CODE = "学科编号";
private static final String TASK_NAME_KEY = "taskName";
private static final String TASK_CODE_KEY = "taskCode";
private static final String TASK_NAME = "任务名称";
private static final String TASK_CODE = "任务编号";
private static final String PERFORMANCE_NAME_KEY = "performanceName";
private static final String PERFORMANCE_CODE_KEY = "performanceCode";
private static final String PERFORMANCE_NAME = "指标名称";
private static final String PERFORMANCE_CODE = "指标编号";
@Override
public SdmResponse list(SpdmTaskListReq req) {
@@ -282,6 +256,8 @@ public class TaskServiceImpl implements ITaskService {
taskExtraMap = taskExtraList.stream().collect(Collectors.groupingBy(TaskNodeExtraPo::getTaskId));
}
Boolean convertTag = req.getConvertTag();
// 所有任务
if (type == 2) {
if (CollectionUtils.isEmpty(taskList)) {
return SdmResponse.success(jsonObject);
@@ -436,6 +412,92 @@ public class TaskServiceImpl implements ITaskService {
}
// yangyang
// TODO 先注释，待完成测试后发布
// // 最终返回的有权限任务列表（用LinkedHashSet保证有序+去重，避免同一任务多次添加）
// Set<SpdmTaskVo> returnTaskSet = new LinkedHashSet<>();
// // 当前用户工号
// String jobNumber = ThreadLocalContext.getJobNumber();
// // 维度1：项目参与人员（根据工号匹配任务名称）
// if (StringUtils.isNotBlank(jobNumber)) {
// try {
// // 直接查询并收集用户参与的唯一任务名称
// Set<String> userJoinTaskNameSet = lyricVProjectResourcePlanDMService.lambdaQuery()
// .eq(LyricVProjectResourcePlanDM::getUser, jobNumber)
// .eq(LyricVProjectResourcePlanDM::getDelFlag, DelFlagTypeEnum.NORMAL.getValue())
// .list()
// .stream()
// .map(LyricVProjectResourcePlanDM::getJobname)
// .filter(StringUtils::isNotBlank) // 过滤空的任务名称，避免无效匹配
// .collect(Collectors.toSet());
//
// // 匹配任务：任务名称在用户参与的任务名称集合中
// if (CollectionUtils.isNotEmpty(userJoinTaskNameSet)) {
// taskList.stream()
// .filter(task -> userJoinTaskNameSet.contains(task.getTaskName()))
// .forEach(returnTaskSet::add);
// }
// } catch (MyBatisSystemException ex) {
// log.warn("查询项目参与人员异常（测试环境可能为预期异常），用户工号：{}，异常信息：{}", jobNumber, ex.getMessage());
// }
// }
//
// // 项目节点授权人员（根据tag1=项目节点ID匹配用户ID）
// // 提取原始任务中的非空项目节点ID，去重
// Set<String> projectNodeIdSet = taskList.stream()
// .map(SpdmTaskVo::getTag1)
// .filter(StringUtils::isNotBlank)
// .collect(Collectors.toSet());
// if (CollectionUtils.isNotEmpty(projectNodeIdSet)) {
// // 查询节点授权人员，并构建【节点ID -> 授权用户ID】集合的Map做快速匹配
// Map<String, Set<Long>> nodeAuthUserIdMap = nodeMapper.getNodeMemberListByNodeIdList(new ArrayList<>(projectNodeIdSet))
// .stream()
// // 过滤无效数据：节点ID/用户ID非空
// .filter(member -> member != null
// && StringUtils.isNotBlank(member.getNodeId())
// && member.getUserId() != null)
// // 分组：节点ID为key，用户ID去重为value，用Set避免重复
// .collect(Collectors.groupingBy(
// SpdmNodeMemberVo::getNodeId,
// Collectors.mapping(SpdmNodeMemberVo::getUserId, Collectors.toSet())
// ));
//
// // 匹配任务：当前用户ID在任务对应节点的有权限查询的用户集合中
// if (MapUtils.isNotEmpty(nodeAuthUserIdMap) && userId != null) {
// taskList.stream()
// .filter(task -> StringUtils.isNotBlank(task.getTag1()))
// .filter(task -> nodeAuthUserIdMap.getOrDefault(task.getTag1(), Collections.emptySet()).contains(userId))
// .forEach(returnTaskSet::add);
// }
// }
//
// // 任务成员（根据任务UUID匹配用户ID）
// if (CollectionUtils.isNotEmpty(taskMemberVoList) && userId != null) {
// // 构建【任务ID -> 任务成员用户ID集合】的Map
// Map<String, Set<Long>> taskAuthUserIdMap = taskMemberVoList.stream()
// // 过滤无效数据：任务ID/用户ID非空
// .filter(member -> member != null
// && StringUtils.isNotBlank(member.getTaskId())
// && member.getUserId() != null)
// // 分组：任务ID为key，用户ID去重为value
// .collect(Collectors.groupingBy(
// SpdmTaskMemberVo::getTaskId,
// Collectors.mapping(SpdmTaskMemberVo::getUserId, Collectors.toSet())
// ));
//
// // 匹配任务：当前用户ID在任务的成员用户集合中
// if (MapUtils.isNotEmpty(taskAuthUserIdMap)) {
// taskList.stream()
// .filter(task -> StringUtils.isNotBlank(task.getUuid()))
// .filter(task -> taskAuthUserIdMap.getOrDefault(task.getUuid(), Collections.emptySet()).contains(userId))
// .forEach(returnTaskSet::add);
// }
// }
//
// // 去重后的Set转List，赋值回任务列表
// taskList = new ArrayList<>(returnTaskSet);
jsonObject.put("total", taskList.size());
taskList = taskList.stream().skip((long) (req.getCurrent() - 1) * req.getSize()).limit(req.getSize()).toList();
List<SpdmNewTaskVo> newTaskList = new ArrayList<>();
@@ -485,6 +547,10 @@ public class TaskServiceImpl implements ITaskService {
jsonObject.put("data", newTaskList);
return SdmResponse.success(jsonObject);
}
// 所有任务结束
if (type == 0) {
// 仿真执行人是当前用户
if (CollectionUtils.isEmpty(taskMemberVoList)) {
@@ -1105,7 +1171,7 @@ public class TaskServiceImpl implements ITaskService {
private void recursionAllNodeIdList(List<String> currentNodeIdList, List<String> allNodeIdList) {
List<com.sdm.project.model.vo.SpdmNodeVo> spdmNodeVoList = nodeMapper.getNodeListByNodeIdList(currentNodeIdList);
List<SpdmNodeVo> spdmNodeVoList = nodeMapper.getNodeListByNodeIdList(currentNodeIdList);
if (CollectionUtils.isEmpty(spdmNodeVoList)) {
return;
}
@@ -2570,494 +2636,6 @@ public class TaskServiceImpl implements ITaskService {
return SdmResponse.success(jsonObject);
}
@Override
public SdmResponse newExportTaskTree(TaskTreeExportExcelFormat taskTreeExportExcelFormat, HttpServletResponse httpServletResponse) {
SpdmTaskListReq req = new SpdmTaskListReq();
TaskTreeExportExcelParam params = taskTreeExportExcelFormat.getParams();
List<com.sdm.common.entity.bo.TaskNodeTag> originIdMap = params.getIdMap();
if (CollectionUtils.isEmpty(originIdMap)) {
log.error("idMap不能为空");
return SdmResponse.failed("idMap不能为空");
}
List<TaskNodeTag> currentIdMapList = new ArrayList<>();
for (com.sdm.common.entity.bo.TaskNodeTag originTaskNodeTag : originIdMap) {
TaskNodeTag taskNodeTag = new TaskNodeTag();
taskNodeTag.setKey(originTaskNodeTag.getKey());
taskNodeTag.setValue(originTaskNodeTag.getValue());
currentIdMapList.add(taskNodeTag);
}
req.setIdMap(currentIdMapList);
if (ObjectUtils.isNotEmpty(params)) {
BeanUtils.copyProperties(params, req);
}
req.setConvertTag(false);
req.setType(2);
req.setCurrent(1);
req.setSize(10000);
List<ExportExcelFormat> exportExcelFormats = taskTreeExportExcelFormat.getExcelHeaders();
SdmResponse taskRespond = list(req);
SdmResponse response = new SdmResponse();
List<com.sdm.common.entity.bo.TaskNodeTag> tagMap = params.getTagMap();
List<String> allNodeIdList = new ArrayList<>();
if (taskRespond.isSuccess()) {
JSONObject dataObj = (JSONObject) taskRespond.getData();
List<SpdmNewTaskVo> taskVoList = (List<SpdmNewTaskVo>) dataObj.get("data");
if (CollectionUtils.isEmpty(taskVoList)) {
log.error("导出任务分析项树时，任务不能为空");
return SdmResponse.failed("任务不能为空");
}
List<String> chooseTaskIdList = params.getTaskIdList();
if (CollectionUtils.isNotEmpty(chooseTaskIdList)) {
taskVoList = taskVoList.stream().filter(task -> chooseTaskIdList.contains(task.getUuid())).toList();
}
if (CollectionUtils.isEmpty(taskVoList)) {
log.error("导出任务分析项树时，根据任务id：{}过滤后，任务集合为空", chooseTaskIdList);
return SdmResponse.failed("任务不能为空");
}
List<ExportExcelFormat> fixedHeaderList = new ArrayList<>();
Optional<ExportExcelFormat> nodeNameOptional = exportExcelFormats.stream().filter(header -> "nodeName".equals(header.getKey())).findAny();
Optional<ExportExcelFormat> nodeCodeOptional = exportExcelFormats.stream().filter(header -> "nodeCode".equals(header.getKey())).findAny();
if (nodeNameOptional.isPresent() && nodeCodeOptional.isPresent()) {
// 机台
ExportExcelFormat machineNameExportExcelFormat = new ExportExcelFormat();
machineNameExportExcelFormat.setKey(MACHINE_NAME_KEY);
machineNameExportExcelFormat.setTitle(MACHINE_NAME);
ExportExcelFormat machineCodeExportExcelFormat = new ExportExcelFormat();
machineCodeExportExcelFormat.setKey(MACHINE_CODE_KEY);
machineCodeExportExcelFormat.setTitle(MACHINE_CODE);
// 工位
ExportExcelFormat workspaceNameExportExcelFormat = new ExportExcelFormat();
workspaceNameExportExcelFormat.setKey(WORKSPACE_NAME_KEY);
workspaceNameExportExcelFormat.setTitle(WORKSPACE_NAME);
ExportExcelFormat workspaceCodeExportExcelFormat = new ExportExcelFormat();
workspaceCodeExportExcelFormat.setKey(WORKSPACE_CODE_KEY);
workspaceCodeExportExcelFormat.setTitle(WORKSPACE_CODE);
// 学科
ExportExcelFormat disciplineNameExportExcelFormat = new ExportExcelFormat();
disciplineNameExportExcelFormat.setKey(DISCIPLINE_NAME_KEY);
disciplineNameExportExcelFormat.setTitle(DISCIPLINE_NAME);
ExportExcelFormat disciplineCodeExportExcelFormat = new ExportExcelFormat();
disciplineCodeExportExcelFormat.setKey(DISCIPLINE_CODE_KEY);
disciplineCodeExportExcelFormat.setTitle(DISCIPLINE_CODE);
// 任务
ExportExcelFormat taskNameExportExcelFormat = new ExportExcelFormat();
taskNameExportExcelFormat.setKey(TASK_NAME_KEY);
taskNameExportExcelFormat.setTitle(TASK_NAME);
ExportExcelFormat taskCodeExportExcelFormat = new ExportExcelFormat();
taskCodeExportExcelFormat.setKey(TASK_CODE_KEY);
taskCodeExportExcelFormat.setTitle(TASK_CODE);
// 指标
ExportExcelFormat performanceNameExportExcelFormat = new ExportExcelFormat();
performanceNameExportExcelFormat.setKey(PERFORMANCE_NAME_KEY);
performanceNameExportExcelFormat.setTitle(PERFORMANCE_NAME);
ExportExcelFormat performanceCodeExportExcelFormat = new ExportExcelFormat();
performanceCodeExportExcelFormat.setKey(PERFORMANCE_CODE_KEY);
performanceCodeExportExcelFormat.setTitle(PERFORMANCE_CODE);
fixedHeaderList.add(machineNameExportExcelFormat);
fixedHeaderList.add(machineCodeExportExcelFormat);
fixedHeaderList.add(workspaceNameExportExcelFormat);
fixedHeaderList.add(workspaceCodeExportExcelFormat);
fixedHeaderList.add(disciplineNameExportExcelFormat);
fixedHeaderList.add(disciplineCodeExportExcelFormat);
fixedHeaderList.add(taskNameExportExcelFormat);
fixedHeaderList.add(taskCodeExportExcelFormat);
fixedHeaderList.add(performanceNameExportExcelFormat);
fixedHeaderList.add(performanceCodeExportExcelFormat);
} else if (nodeNameOptional.isPresent()) {
// 机台
ExportExcelFormat machineNameExportExcelFormat = new ExportExcelFormat();
machineNameExportExcelFormat.setKey(MACHINE_NAME_KEY);
machineNameExportExcelFormat.setTitle(MACHINE_NAME);
// 工位
ExportExcelFormat workspaceNameExportExcelFormat = new ExportExcelFormat();
workspaceNameExportExcelFormat.setKey(WORKSPACE_NAME_KEY);
workspaceNameExportExcelFormat.setTitle(WORKSPACE_NAME);
// 学科
ExportExcelFormat disciplineNameExportExcelFormat = new ExportExcelFormat();
disciplineNameExportExcelFormat.setKey(DISCIPLINE_NAME_KEY);
disciplineNameExportExcelFormat.setTitle(DISCIPLINE_NAME);
// 任务
ExportExcelFormat taskNameExportExcelFormat = new ExportExcelFormat();
taskNameExportExcelFormat.setKey(TASK_NAME_KEY);
taskNameExportExcelFormat.setTitle(TASK_NAME);
// 指标
ExportExcelFormat performanceNameExportExcelFormat = new ExportExcelFormat();
performanceNameExportExcelFormat.setKey(PERFORMANCE_NAME_KEY);
performanceNameExportExcelFormat.setTitle(PERFORMANCE_NAME);
fixedHeaderList.add(machineNameExportExcelFormat);
fixedHeaderList.add(workspaceNameExportExcelFormat);
fixedHeaderList.add(disciplineNameExportExcelFormat);
fixedHeaderList.add(taskNameExportExcelFormat);
fixedHeaderList.add(performanceNameExportExcelFormat);
} else if (nodeCodeOptional.isPresent()) {
// 机台
ExportExcelFormat machineCodeExportExcelFormat = new ExportExcelFormat();
machineCodeExportExcelFormat.setKey(MACHINE_CODE_KEY);
machineCodeExportExcelFormat.setTitle(MACHINE_CODE);
// 工位
ExportExcelFormat workspaceCodeExportExcelFormat = new ExportExcelFormat();
workspaceCodeExportExcelFormat.setKey(WORKSPACE_CODE_KEY);
workspaceCodeExportExcelFormat.setTitle(WORKSPACE_CODE);
// 学科
ExportExcelFormat disciplineCodeExportExcelFormat = new ExportExcelFormat();
disciplineCodeExportExcelFormat.setKey(DISCIPLINE_CODE_KEY);
disciplineCodeExportExcelFormat.setTitle(DISCIPLINE_CODE);
// 任务
ExportExcelFormat taskCodeExportExcelFormat = new ExportExcelFormat();
taskCodeExportExcelFormat.setKey(TASK_CODE_KEY);
taskCodeExportExcelFormat.setTitle(TASK_CODE);
// 指标
ExportExcelFormat performanceCodeExportExcelFormat = new ExportExcelFormat();
performanceCodeExportExcelFormat.setKey(PERFORMANCE_CODE_KEY);
performanceCodeExportExcelFormat.setTitle(PERFORMANCE_CODE);
fixedHeaderList.add(machineCodeExportExcelFormat);
fixedHeaderList.add(workspaceCodeExportExcelFormat);
fixedHeaderList.add(disciplineCodeExportExcelFormat);
fixedHeaderList.add(taskCodeExportExcelFormat);
fixedHeaderList.add(performanceCodeExportExcelFormat);
}
if (CollectionUtils.isNotEmpty(fixedHeaderList)) {
if (nodeNameOptional.isPresent()) {
exportExcelFormats.remove(0);
}
if (nodeCodeOptional.isPresent()) {
exportExcelFormats.remove(0);
}
fixedHeaderList.addAll(exportExcelFormats);
exportExcelFormats = fixedHeaderList;
}
List<SpdmExportNewTaskVo> allExportNewTaskVoList = new ArrayList<>();
List<SpdmExportNewTaskVo> exportNewTaskVoList = new ArrayList<>();
List<CIDUserResp> pMemberList;
String pMemberName = "";
List<CIDUserResp> eMemberList;
String eMemberName = "";
for (SpdmNewTaskVo spdmNewTaskVo : taskVoList) {
pMemberList = spdmNewTaskVo.getPMemberList();
if (CollectionUtils.isNotEmpty(pMemberList)) {
pMemberName = pMemberList.stream().map(CIDUserResp::getNickname).collect(Collectors.joining(","));
}
eMemberList = spdmNewTaskVo.getPMemberList();
if (CollectionUtils.isNotEmpty(eMemberList)) {
eMemberName = eMemberList.stream().map(CIDUserResp::getNickname).collect(Collectors.joining(","));
}
SpdmExportNewTaskVo spdmExportNewTaskVo = new SpdmExportNewTaskVo();
BeanUtils.copyProperties(spdmNewTaskVo, spdmExportNewTaskVo);
spdmExportNewTaskVo.setPMemberList(pMemberName);
spdmExportNewTaskVo.setEMemberList(eMemberName);
// 查询任务相应的前置节点和指标
// 机台
Optional<com.sdm.common.entity.bo.TaskNodeTag> machineOptional = tagMap.stream().filter(tag -> NodeTypeEnum.MACHINE.getValue().equals(tag.getKey())).findFirst();
// 工位
Optional<com.sdm.common.entity.bo.TaskNodeTag> workspaceOptional = tagMap.stream().filter(tag -> NodeTypeEnum.WORKSPACE.getValue().equals(tag.getKey())).findFirst();
// 学科
Optional<com.sdm.common.entity.bo.TaskNodeTag> disciplineOptional = tagMap.stream().filter(tag -> NodeTypeEnum.DISCIPLINE.getValue().equals(tag.getKey())).findFirst();
String machineTags = "";
if (machineOptional.isPresent()) {
String machineTag = machineOptional.get().getValue();
try {
machineTags = getTagProperty(spdmExportNewTaskVo, machineTag);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
String workspaceTags = "";
if (workspaceOptional.isPresent()) {
String workspaceTag = workspaceOptional.get().getValue();
try {
workspaceTags = getTagProperty(spdmExportNewTaskVo, workspaceTag);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
String disciplineTags = "";
if (disciplineOptional.isPresent()) {
String disciplineTag = disciplineOptional.get().getValue();
try {
disciplineTags = getTagProperty(spdmExportNewTaskVo, disciplineTag);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if (StringUtils.isNotBlank(machineTags)) {
allNodeIdList.addAll(Arrays.stream(machineTags.split(",")).toList());
}
if (StringUtils.isNotBlank(workspaceTags)) {
allNodeIdList.addAll(Arrays.stream(workspaceTags.split(",")).toList());
}
if (StringUtils.isNotBlank(disciplineTags)) {
allNodeIdList.addAll(Arrays.stream(disciplineTags.split(",")).toList());
}
exportNewTaskVoList.add(spdmExportNewTaskVo);
}
// 查询任务下所有指标
List<String> taskIdList = exportNewTaskVoList.stream().map(SpdmExportNewTaskVo::getUuid).toList();
List<PerformanceNodePo> performanceList = projectMapper.getPerformanceListByNodeIdList(taskIdList);
Map<String, List<PerformanceNodePo>> performanceMap = Map.of();
if (CollectionUtils.isNotEmpty(performanceList)) {
performanceList = performanceList.stream().filter(performance -> performance.getRunId() == null).toList();
if (CollectionUtils.isNotEmpty(performanceList)) {
performanceMap = performanceList.stream().collect(Collectors.groupingBy(PerformanceNodePo::getTaskId));
}
}
if (CollectionUtils.isNotEmpty(allNodeIdList)) {
List<SpdmNodeVo> nodeList = nodeMapper.getNodeListByIds(allNodeIdList.stream().distinct().toList());
if (CollectionUtils.isNotEmpty(nodeList)) {
Map<String, SpdmNodeVo> nodeMap = nodeList.stream().collect(Collectors.groupingBy(
SpdmNodeVo::getUuid,
Collectors.collectingAndThen(
Collectors.toList(),
list -> list.get(0)
)
));
for (SpdmExportNewTaskVo spdmExportNewTaskVo : exportNewTaskVoList) {
// 设置机台名称和机台编码
Optional<com.sdm.common.entity.bo.TaskNodeTag> machineOptional = tagMap.stream().filter(tag -> NodeTypeEnum.MACHINE.getValue().equals(tag.getKey())).findFirst();
if (machineOptional.isPresent()) {
String machineTag = machineOptional.get().getValue();
try {
String machineTags = getTagProperty(spdmExportNewTaskVo, machineTag);
if (StringUtils.isNotBlank(machineTags)) {
for (String machineTagId : Arrays.stream(machineTags.split(",")).toList()) {
SpdmNodeVo spdmNodeVo = nodeMap.get(machineTagId);
if (ObjectUtils.isEmpty(spdmNodeVo)) {
continue;
}
spdmExportNewTaskVo.setMachineName(spdmNodeVo.getNodeName());
spdmExportNewTaskVo.setMachineCode(spdmNodeVo.getNodeCode());
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 设置机台名称和机台编码
Optional<com.sdm.common.entity.bo.TaskNodeTag> workspaceOptional = tagMap.stream().filter(tag -> NodeTypeEnum.WORKSPACE.getValue().equals(tag.getKey())).findFirst();
if (workspaceOptional.isPresent()) {
String workspaceTag = workspaceOptional.get().getValue();
try {
String workspaceTags = getTagProperty(spdmExportNewTaskVo, workspaceTag);
if (StringUtils.isNotBlank(workspaceTags)) {
for (String workspaceTagId : Arrays.stream(workspaceTags.split(",")).toList()) {
SpdmNodeVo spdmNodeVo = nodeMap.get(workspaceTagId);
if (ObjectUtils.isEmpty(spdmNodeVo)) {
continue;
}
spdmExportNewTaskVo.setWorkspaceName(spdmNodeVo.getNodeName());
spdmExportNewTaskVo.setWorkspaceCode(spdmNodeVo.getNodeCode());
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
Optional<com.sdm.common.entity.bo.TaskNodeTag> disciplineOptional = tagMap.stream().filter(tag -> NodeTypeEnum.DISCIPLINE.getValue().equals(tag.getKey())).findFirst();
if (disciplineOptional.isPresent()) {
String disciplineTag = disciplineOptional.get().getValue();
try {
String disciplineTags = getTagProperty(spdmExportNewTaskVo, disciplineTag);
if (StringUtils.isNotBlank(disciplineTags)) {
for (String disciplineTagId : Arrays.stream(disciplineTags.split(",")).toList()) {
SpdmNodeVo spdmNodeVo = nodeMap.get(disciplineTagId);
if (ObjectUtils.isEmpty(spdmNodeVo)) {
continue;
}
spdmExportNewTaskVo.setDisciplineName(spdmNodeVo.getNodeName());
spdmExportNewTaskVo.setDisciplineCode(spdmNodeVo.getNodeCode());
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 任务下指标
List<PerformanceNodePo> performanceNodePoList = performanceMap.get(spdmExportNewTaskVo.getUuid());
List<SpdmExportNewTaskVo> spdmExportNewTaskVoList = new ArrayList<>();
if (CollectionUtils.isNotEmpty(performanceNodePoList)) {
for (PerformanceNodePo performanceNodePo : performanceNodePoList) {
SpdmExportNewTaskVo exportNewTaskVo = new SpdmExportNewTaskVo();
BeanUtils.copyProperties(performanceNodePo, exportNewTaskVo);
BeanUtils.copyProperties(spdmExportNewTaskVo,exportNewTaskVo);
exportNewTaskVo.setMachineName(spdmExportNewTaskVo.getMachineName());
exportNewTaskVo.setMachineCode(spdmExportNewTaskVo.getMachineCode());
exportNewTaskVo.setWorkspaceName(spdmExportNewTaskVo.getWorkspaceName());
exportNewTaskVo.setWorkspaceCode(spdmExportNewTaskVo.getWorkspaceCode());
exportNewTaskVo.setDisciplineName(spdmExportNewTaskVo.getDisciplineName());
exportNewTaskVo.setDisciplineCode(spdmExportNewTaskVo.getDisciplineCode());
exportNewTaskVo.setTaskCode(spdmExportNewTaskVo.getTaskCode());
exportNewTaskVo.setPerformanceName(performanceNodePo.getNodeName());
exportNewTaskVo.setPerformanceCode(performanceNodePo.getNodeCode());
spdmExportNewTaskVoList.add(exportNewTaskVo);
}
} else {
SpdmExportNewTaskVo exportNewTaskVo = new SpdmExportNewTaskVo();
BeanUtils.copyProperties(spdmExportNewTaskVo,exportNewTaskVo);
exportNewTaskVo.setMachineName(spdmExportNewTaskVo.getMachineName());
exportNewTaskVo.setMachineCode(spdmExportNewTaskVo.getMachineCode());
exportNewTaskVo.setWorkspaceName(spdmExportNewTaskVo.getWorkspaceName());
exportNewTaskVo.setWorkspaceCode(spdmExportNewTaskVo.getWorkspaceCode());
exportNewTaskVo.setDisciplineName(spdmExportNewTaskVo.getDisciplineName());
exportNewTaskVo.setDisciplineCode(spdmExportNewTaskVo.getDisciplineCode());
exportNewTaskVo.setTaskCode(spdmExportNewTaskVo.getTaskCode());
spdmExportNewTaskVoList.add(exportNewTaskVo);
}
if (CollectionUtils.isNotEmpty(spdmExportNewTaskVoList)) {
allExportNewTaskVoList.addAll(spdmExportNewTaskVoList);
}
}
}
}
List<TaskTreeExportExcelParam> paramList = new ArrayList<>();
String currentTaskName = "";
long total;
String tag3;
String tag4;
String tag5;
for (int i = 0; i < allExportNewTaskVoList.size() ; i++) {
SpdmExportNewTaskVo spdmExportNewTaskVo = allExportNewTaskVoList.get(i);
tag3 = spdmExportNewTaskVo.getTag3();
tag4 = spdmExportNewTaskVo.getTag4();
tag5 = spdmExportNewTaskVo.getTag5();
String taskName = spdmExportNewTaskVo.getTaskName();
if (StringUtils.isNotBlank(tag3)) {
taskName += tag3;
}
if (StringUtils.isNotBlank(tag4)) {
taskName += tag4;
}
if (StringUtils.isNotBlank(tag5)) {
taskName += tag5;
}
if (!currentTaskName.equals(taskName)) {
String finalTaskName = taskName;
total = allExportNewTaskVoList.stream().filter(task -> {
String eachTaskName = task.getTaskName();
if (StringUtils.isNotBlank(task.getTag3())) {
eachTaskName += task.getTag3();
}
if (StringUtils.isNotBlank(task.getTag4())) {
eachTaskName += task.getTag4();
}
if (StringUtils.isNotBlank(task.getTag5())) {
eachTaskName += task.getTag5();
}
return eachTaskName.equals(finalTaskName);
}).count();
TaskTreeExportExcelParam taskTreeExportExcelParam = new TaskTreeExportExcelParam();
taskTreeExportExcelParam.setStartIndex(i + 1);
if (total == 0) {
total = 1;
}
taskTreeExportExcelParam.setEndIndex(i + (int) total);
paramList.add(taskTreeExportExcelParam);
i = i + (int) total;
}
currentTaskName = taskName;
}
// 转换执行规范的文件id为文件名称
List<String> standardList = allExportNewTaskVoList.stream().map(SpdmExportNewTaskVo::getStandard).toList();
Map<Long, String> dataMap = Map.of();
if (CollectionUtils.isNotEmpty(standardList)) {
List<Long> fileIdList = new ArrayList<>();
standardList = standardList.stream().filter(StringUtils::isNotBlank).toList();
if (CollectionUtils.isNotEmpty(standardList)) {
for (String standard : standardList) {
if (standard.contains(";")) {
List<String> fileDirIdList = Arrays.stream(standard.split(";")).toList();
for (String fileDirId : fileDirIdList) {
if (!isConvertibleToLong(fileDirId.split(",")[1])) {
continue;
}
fileIdList.add(Long.valueOf(fileDirId.split(",")[1]));
}
}else {
List<String> normalFileIdList = Arrays.stream(standard.split(",")).toList().stream().filter(ProjectServiceImpl::isConvertibleToLong).toList();
if (CollectionUtils.isEmpty(normalFileIdList)) {
continue;
}
fileIdList.addAll(normalFileIdList.stream().map(Long::valueOf).toList());
};
}
QueryFileReq queryFileReq = new QueryFileReq();
queryFileReq.setFileIdList(fileIdList);
SdmResponse<List<FileMetadataInfoResp>> listSdmResponse = dataClientFeignClient.queryFileListByIdList(queryFileReq);
if (listSdmResponse.isSuccess()) {
List<FileMetadataInfoResp> dataList = listSdmResponse.getData();
dataMap = dataList.stream().collect(Collectors.toMap(FileMetadataInfoResp::getId, FileMetadataInfoResp::getOriginalName));
}
}
}
for (SpdmExportNewTaskVo spdmExportNewTaskVo : allExportNewTaskVoList) {
List<Long> fileIdList = new ArrayList<>();
List<String> fileNameList = new ArrayList<>();
String standard = spdmExportNewTaskVo.getStandard();
if (StringUtils.isNotBlank(spdmExportNewTaskVo.getStandard())) {
if (standard.contains(";")) {
List<String> fileDirIdList = Arrays.stream(standard.split(";")).toList();
for (String fileDirId : fileDirIdList) {
fileIdList.add(Long.valueOf(fileDirId.split(",")[1]));
}
}else {
fileIdList.addAll(Arrays.stream(standard.split(",")).toList().stream().map(Long::valueOf).toList());
}
for (Long fileId : fileIdList) {
if (StringUtils.isBlank(dataMap.get(fileId))) {
continue;
}
fileNameList.add(dataMap.get(fileId));
}
spdmExportNewTaskVo.setStandard(String.join(",", fileNameList));
}
log.info("flowTemplate为：{}",spdmExportNewTaskVo.getFlowTemplate());
if (StringUtils.isNotBlank(spdmExportNewTaskVo.getFlowTemplate())) {
List<String> flowTemplateNameList = new ArrayList<>();
String[] flowTemplateArr = spdmExportNewTaskVo.getFlowTemplate().split(",");
for (String flowTemplate : flowTemplateArr) {
log.info("查询flowTemplate为：{}",flowTemplate);
SdmResponse<FlowTemplateResp> flowTemplateResp = flowFeignClient.queryFlowTemplateInfoByTemplateCode(flowTemplate);
log.info("flowTemplateResp为：{}",flowTemplateResp);
if (flowTemplateResp.getData() == null) {
continue;
}
flowTemplateNameList.add(flowTemplateResp.getData().getTemplateName());
}
if (CollectionUtils.isNotEmpty(flowTemplateNameList)) {
spdmExportNewTaskVo.setFlowTemplate(String.join(",", flowTemplateNameList));
}
}
}
ExcelUtil.exportExcelOneDimensional(JSONArray.from(allExportNewTaskVoList), exportExcelFormats, httpServletResponse,paramList);
} else {
response = SdmResponse.failed(taskRespond.getMessage());
}
return response;
}
@Override
public SdmResponse getTaskAchieveStatistics(TaskCompleteStatisticsReq req) {
// 所有任务达成状态