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

1、调整构建批量创建文件夹接口参数的逻辑

Browse Source
This commit is contained in:
lidongyang
2026-01-23 19:38:59 +08:00
parent 0dbdb09553
commit 8e5be115ac
12 changed files with 494 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
project/src/main/java/com/sdm/project/config/xxljob/XxlJobConfig.java Normal file
View File

@@ -0,0 +1,90 @@
package com.sdm.project.config.xxljob;
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* xxl-job config
*
* @author xuxueli 2017-04-28
*/
@Configuration
public class XxlJobConfig {
private static final Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);
@Value("${xxl.job.admin.addresses}")
private String adminAddresses;
@Value("${xxl.job.admin.accessToken}")
private String accessToken;
@Value("${xxl.job.admin.timeout}")
private int timeout;
@Value("${xxl.job.executor.enabled}")
private Boolean enabled;
@Value("${xxl.job.executor.appname}")
private String appname;
@Value("${xxl.job.executor.address}")
private String address;
@Value("${xxl.job.executor.ip}")
private String ip;
@Value("${xxl.job.executor.port}")
private int port;
@Value("${xxl.job.executor.logpath}")
private String logPath;
@Value("${xxl.job.executor.logretentiondays}")
private int logRetentionDays;
@Value("${xxl.job.executor.excludedpackage}")
private String excludedPackage;
@Bean
public XxlJobSpringExecutor xxlJobExecutor() {
logger.info(">>>>>>>>>>> xxl-job config init.");
XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
xxlJobSpringExecutor.setAccessToken(accessToken);
xxlJobSpringExecutor.setTimeout(timeout);
xxlJobSpringExecutor.setEnabled(enabled);
xxlJobSpringExecutor.setAppname(appname);
xxlJobSpringExecutor.setAddress(address);
xxlJobSpringExecutor.setIp(ip);
xxlJobSpringExecutor.setPort(port);
xxlJobSpringExecutor.setLogPath(logPath);
xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
xxlJobSpringExecutor.setExcludedPackage(excludedPackage);
return xxlJobSpringExecutor;
}
/**
* 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
*
* 1、引入依赖：
* <dependency>
* <groupId>org.springframework.cloud</groupId>
* <artifactId>spring-cloud-commons</artifactId>
* <version>${version}</version>
* </dependency>
*
* 2、配置文件，或者容器启动变量
* spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
*
* 3、获取IP
* String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
*/
}

14
project/src/main/java/com/sdm/project/controller/SimulationTaskController.java
View File

@@ -9,10 +9,7 @@ import com.sdm.common.feign.inter.project.ISimulationTaskFeignClient;
import com.sdm.common.log.annotation.SysLog;
import com.sdm.project.model.bo.ModifyTaskNode;
import com.sdm.project.model.req.*;
import com.sdm.project.model.resp.ProjectDifficultStatisticsResp;
import com.sdm.project.model.resp.TaskCountResp;
import com.sdm.project.model.resp.TaskWorkDaysResp;
import com.sdm.project.model.resp.UserWorkloadResp;
import com.sdm.project.model.resp.*;
import com.sdm.common.entity.resp.project.SpdmTaskVo;
import com.sdm.project.service.ISimulationTaskService;
import com.sdm.project.service.ITaskService;
@@ -283,4 +280,13 @@ public class SimulationTaskController implements ISimulationTaskFeignClient {
return taskService.queryTaskByProjectCodeForEp(projectCode);
}
/**
* 查询项目人员负载
*/
@PostMapping("/queryProjectUserLoads")
@Operation(summary = "查询项目人员负载", description = "查询项目人员负载")
public SdmResponse<List<ProjectUserLoadResp>> queryProjectUserLoads(@RequestBody @Validated ProjectUserLoadReq req) {
return taskService.queryProjectUserLoads(req);
}
}

2
project/src/main/java/com/sdm/project/dao/SimulationProjectMapper.java
View File

@@ -185,4 +185,6 @@ public interface SimulationProjectMapper {
List<ProjectNodePo> getNodeListByType(@Param("nodeTypeList") List<String> nodeTypeList);
List<ProjectNodeMemberPo> getProjectMemberList(@Param("projectIdList") List<String> projectIdList);
}

3
project/src/main/java/com/sdm/project/model/entity/SimulationNode.java
View File

@@ -155,4 +155,7 @@ public class SimulationNode implements Serializable {
@TableField("commitmentDeadline")
private String commitmentDeadline;
@TableField("reference_item")
private String referenceItem;
}

2
project/src/main/java/com/sdm/project/model/po/TaskNodePo.java
View File

@@ -162,7 +162,7 @@ public class TaskNodePo extends NodeAllBase {
@JsonProperty("bCapacity")
private String bCapacity;
private String flowTemplate;
private String flowTemplateName;
private String flowTemplateNames;
private String englishName;
private String description;

31
project/src/main/java/com/sdm/project/model/req/ProjectUserLoadReq.java Normal file
View File

@@ -0,0 +1,31 @@
package com.sdm.project.model.req;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
import java.util.List;
@JsonIgnoreProperties(ignoreUnknown = true)
@Data
public class ProjectUserLoadReq {
/**
* 项目节点的uuid集合
*/
private List<String> projectIdList;
/**
* 开始时间
*/
@NotBlank(message = "开始时间不能为空")
private String beginTime;
/**
* 结束时间
*/
@NotBlank(message = "结束时间不能为空")
private String endTime;
}

41
project/src/main/java/com/sdm/project/model/resp/ProjectUserLoadResp.java Normal file
View File

@@ -0,0 +1,41 @@
package com.sdm.project.model.resp;
import com.sdm.project.model.entity.SimulationTask;
import lombok.Data;
import java.util.List;
@Data
public class ProjectUserLoadResp {
/**
* 项目名称
*/
private String projectName;
/**
* 人员数量
*/
private Integer userNum;
/**
* 任务数量
*/
private Integer taskNum;
/**
* 工作饱和度 任务数量*工时
*/
private double workload;
/**
* 任务列表
*/
private List<SimulationTask> taskList;
/**
* 此字段不为空时，说明当前项目是其他项目的参考项目
*/
private String relateProjectName;
}

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

@@ -96,4 +96,7 @@ public interface ITaskService {
SdmResponse exportRunByScript(HttpServletResponse response, RunAnalysisExportExcelFormat req);
SdmResponse exportPerformanceByScript(HttpServletResponse response, PerformanceAnalysisExportExcelFormat req);
SdmResponse<List<ProjectUserLoadResp>> queryProjectUserLoads(ProjectUserLoadReq req);
}

348
project/src/main/java/com/sdm/project/service/impl/NodeServiceImpl.java
View File

@@ -191,9 +191,9 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
Map<Long, Byte> userPermissions = new HashMap<>();
userPermissions.put(userId, FilePermissionEnum.ALL.getValue());
updatePermissionReq.setUserPermissions(userPermissions);
log.info("创建项目阶段时，更新用户权限的参数为：{}",updatePermissionReq);
log.info("dirItem目阶段时，更新用户权限的参数为：{}",updatePermissionReq);
SdmResponse updatePermissionResponse = dataFeignClient.updatePermission(updatePermissionReq);
log.info("创建项目阶段时，更新用户权限的返回值为：{}",updatePermissionResponse);
log.info("dirItem目阶段时，更新用户权限的返回值为：{}",updatePermissionResponse);
}
for (SpdmProjectNodeEditReq addNode : addNodeList) {
String projectSource = addNode.getProjectSource();
@@ -593,7 +593,7 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
}
// 设置 当前节点所属项目根节点uuid
// addNode.getPid()为空时，在创建项目，ownRootNodeUuid就是addNode本身uuid
// addNode.getPid()为空时，在dirItem目，ownRootNodeUuid就是addNode本身uuid
// addNode.getPid()不为空时，在创建阶段，ownRootNodeUuid就是入参的pid父节点
addNode.setOwnRootNodeUuid(ObjectUtils.isEmpty(addNode.getPid()) ? addNode.getUuid() : addNode.getPid());
addNode.setCreateTime(curDateStr);
@@ -626,74 +626,9 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
if (nodeMapper.addNodeBatch(addNodeList) <= 0) {
return null;
}
SpdmProjectNodeEditReq projectNode = addNodeList.stream().filter(node -> NodeTypeEnum.PROJECT.getValue().equals(node.getNodeType())).findFirst().orElse(null);
List<SpdmProjectNodeEditReq> addPhaseNodeList = addNodeList.stream().filter(node -> NodeTypeEnum.PHASE.getValue().equals(node.getNodeType())).toList();
List<SpdmProjectNodeEditReq> addMachineNodeList = addNodeList.stream().filter(node -> NodeTypeEnum.MACHINE.getValue().equals(node.getNodeType())).toList();
List<SpdmProjectNodeEditReq> addWorkspaceNodeList = addNodeList.stream().filter(node -> NodeTypeEnum.WORKSPACE.getValue().equals(node.getNodeType())).toList();
if (ObjectUtils.isEmpty(projectNode)) {
// 只创建阶段
SpdmProjectNodeEditReq spdmProjectNodeEditReq = addPhaseNodeList.get(0);
createDir(spdmProjectNodeEditReq.getUuid(), spdmProjectNodeEditReq.getNodeType(), spdmProjectNodeEditReq.getPid(), spdmProjectNodeEditReq.getNodeName());
}else {
// 批量创建文件夹
BatchCreateDirReq batchCreateDirReq = new BatchCreateDirReq();
List<BatchCreateDirItem> createDirItemList = new ArrayList<>();
BatchCreateDirItem projectCreateDirItem = new BatchCreateDirItem();
DirNodeInfo projectDirNodeInfo = new DirNodeInfo();
projectDirNodeInfo.setUuId(projectNode.getUuid());
projectDirNodeInfo.setParentUuId(null);
projectDirNodeInfo.setUuIdOwnType(NodeTypeEnum.PROJECT.getValue());
projectDirNodeInfo.setDirName(projectNode.getNodeName());
projectCreateDirItem.setParentDirNodeInfo(projectDirNodeInfo);
List<DirNodeInfo> childDirNodeInfoList = new ArrayList<>();
if (CollectionUtils.isNotEmpty(addPhaseNodeList)) {
for (SpdmProjectNodeEditReq phaseNode : addPhaseNodeList) {
DirNodeInfo phaseDirNodeInfo = new DirNodeInfo();
phaseDirNodeInfo.setUuId(phaseNode.getUuid());
phaseDirNodeInfo.setParentUuId(projectNode.getUuid());
phaseDirNodeInfo.setUuIdOwnType(NodeTypeEnum.PHASE.getValue());
phaseDirNodeInfo.setDirName(phaseNode.getNodeName());
childDirNodeInfoList.add(phaseDirNodeInfo);
// 过滤当前阶段下的机台节点
if (CollectionUtils.isNotEmpty(addMachineNodeList)) {
List<SpdmProjectNodeEditReq> currentMachineNodeList = addMachineNodeList.stream().filter(machineNode -> phaseNode.getUuid().equals(machineNode.getPid())).toList();
if (CollectionUtils.isEmpty(currentMachineNodeList)) {
continue;
}
for (SpdmProjectNodeEditReq machineNode : currentMachineNodeList) {
DirNodeInfo machineDirNodeInfo = new DirNodeInfo();
machineDirNodeInfo.setUuId(machineNode.getUuid());
machineDirNodeInfo.setParentUuId(phaseNode.getUuid());
machineDirNodeInfo.setUuIdOwnType(NodeTypeEnum.MACHINE.getValue());
machineDirNodeInfo.setDirName(machineNode.getNodeName());
childDirNodeInfoList.add(machineDirNodeInfo);
// 过滤当前机台下的工位节点
if (CollectionUtils.isNotEmpty(addWorkspaceNodeList)) {
List<SpdmProjectNodeEditReq> currentWorkspaceNodeList = addWorkspaceNodeList.stream().filter(workspaceNode -> machineNode.getUuid().equals(workspaceNode.getPid())).toList();
if (CollectionUtils.isEmpty(currentWorkspaceNodeList)) {
continue;
}
for (SpdmProjectNodeEditReq workspaceNode : currentWorkspaceNodeList) {
DirNodeInfo workspaceDirNodeInfo = new DirNodeInfo();
workspaceDirNodeInfo.setUuId(workspaceNode.getUuid());
workspaceDirNodeInfo.setParentUuId(machineNode.getUuid());
workspaceDirNodeInfo.setUuIdOwnType(NodeTypeEnum.WORKSPACE.getValue());
workspaceDirNodeInfo.setDirName(workspaceNode.getNodeName());
childDirNodeInfoList.add(workspaceDirNodeInfo);
}
}
}
}
}
}
projectCreateDirItem.setChildDirNodeInfos(childDirNodeInfoList);
createDirItemList.add(projectCreateDirItem);
batchCreateDirReq.setItems(createDirItemList);
batchCreateDirReq.setDirType(DirTypeEnum.PROJECT_NODE_DIR.getValue());
log.info("创建节点时，调用批量创建文件夹的参数为：{}", batchCreateDirReq);
SdmResponse response = dataFeignClient.batchCreateDir(batchCreateDirReq);
log.info("创建节点时，调用批量创建文件夹的返回值为：{}", response);
}
// 批量创建文件夹
batchCreateNodeDir(addNodeList);
if (CollectionUtils.isNotEmpty(allNodeManagerList) && nodeMapper.addNodeMemberBatch(allNodeManagerList) <= 0) {
return null;
@@ -705,6 +640,271 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
return addNodeList;
}
/**
* 内部静态类：封装节点类型筛选结果
*/
private static class NodeTypeFilterResult {
private final SpdmProjectNodeEditReq projectNode;
private final List<SpdmProjectNodeEditReq> addPhaseNodeList;
private final List<SpdmProjectNodeEditReq> addMachineNodeList;
private final List<SpdmProjectNodeEditReq> addWorkspaceNodeList;
public NodeTypeFilterResult(SpdmProjectNodeEditReq projectNode,
List<SpdmProjectNodeEditReq> addPhaseNodeList,
List<SpdmProjectNodeEditReq> addMachineNodeList,
List<SpdmProjectNodeEditReq> addWorkspaceNodeList) {
this.projectNode = projectNode;
this.addPhaseNodeList = addPhaseNodeList;
this.addMachineNodeList = addMachineNodeList;
this.addWorkspaceNodeList = addWorkspaceNodeList;
}
// Getter方法
public SpdmProjectNodeEditReq getProjectNode() { return projectNode; }
public List<SpdmProjectNodeEditReq> getAddPhaseNodeList() { return addPhaseNodeList; }
public List<SpdmProjectNodeEditReq> getAddMachineNodeList() { return addMachineNodeList; }
public List<SpdmProjectNodeEditReq> getAddWorkspaceNodeList() { return addWorkspaceNodeList; }
}
/**
* 仅创建单个阶段节点
*/
private void createSinglePhaseDir(List<SpdmProjectNodeEditReq> phaseNodes) {
if (CollectionUtils.isEmpty(phaseNodes)) {
log.warn("无阶段节点可创建");
return;
}
SpdmProjectNodeEditReq firstPhaseNode = phaseNodes.get(0);
createDir(firstPhaseNode.getUuid(), firstPhaseNode.getNodeType(),
firstPhaseNode.getPid(), firstPhaseNode.getNodeName());
}
/**
* 构建批量创建文件夹请求
*/
private BatchCreateDirReq buildBatchCreateDirReq(NodeTypeFilterResult filterResult) {
BatchCreateDirReq batchCreateDirReq = new BatchCreateDirReq();
List<BatchCreateDirItem> createDirItemList = new ArrayList<>();
// 构建项目节点的dirItem
buildProjectDirItem(filterResult, createDirItemList);
// 构建阶段、机台、工位的层级dirItem
buildPhaseMachineWorkspaceDirItems(filterResult, createDirItemList);
batchCreateDirReq.setItems(createDirItemList);
batchCreateDirReq.setDirType(DirTypeEnum.PROJECT_NODE_DIR.getValue());
return batchCreateDirReq;
}
/**
* 构建项目节点的dirItem
*/
private void buildProjectDirItem(NodeTypeFilterResult filterResult, List<BatchCreateDirItem> createDirItemList) {
SpdmProjectNodeEditReq projectNode = filterResult.getProjectNode();
List<SpdmProjectNodeEditReq> phaseNodes = filterResult.getAddPhaseNodeList();
BatchCreateDirItem projectCreateDirItem = new BatchCreateDirItem();
DirNodeInfo projectDirNodeInfo = buildDirNodeInfo(
projectNode.getUuid(), null,
NodeTypeEnum.PROJECT.getValue(), projectNode.getNodeName()
);
projectCreateDirItem.setParentDirNodeInfo(projectDirNodeInfo);
// 构建项目下的阶段子节点
List<DirNodeInfo> phaseDirInfoList = buildDirNodeInfoList(
phaseNodes, projectNode.getUuid(), NodeTypeEnum.PHASE.getValue()
);
projectCreateDirItem.setChildDirNodeInfos(phaseDirInfoList);
createDirItemList.add(projectCreateDirItem);
}
/**
* 构建阶段、机台、工位的层级dirItem
*/
private void buildPhaseMachineWorkspaceDirItems(NodeTypeFilterResult filterResult, List<BatchCreateDirItem> createDirItemList) {
SpdmProjectNodeEditReq projectNode = filterResult.getProjectNode();
List<SpdmProjectNodeEditReq> phaseNodes = filterResult.getAddPhaseNodeList();
List<SpdmProjectNodeEditReq> machineNodes = filterResult.getAddMachineNodeList();
List<SpdmProjectNodeEditReq> workspaceNodes = filterResult.getAddWorkspaceNodeList();
if (CollectionUtils.isEmpty(phaseNodes)) {
return;
}
for (SpdmProjectNodeEditReq phaseNode : phaseNodes) {
// 构建阶段节点的dirItem
BatchCreateDirItem phaseCreateDirItem = buildPhaseDirItem(phaseNode, projectNode.getUuid(), machineNodes);
createDirItemList.add(phaseCreateDirItem);
// 筛选当前阶段下的机台节点
List<SpdmProjectNodeEditReq> currentMachineNodes = machineNodes.stream()
.filter(machineNode -> phaseNode.getUuid().equals(machineNode.getPid()))
.collect(Collectors.toList());
// 构建机台、工位的dirItem
buildMachineWorkspaceDirItems(phaseNode, currentMachineNodes, workspaceNodes, createDirItemList);
}
}
/**
* 构建阶段节点的dirItem
*/
private BatchCreateDirItem buildPhaseDirItem(SpdmProjectNodeEditReq phaseNode, String projectUuid, List<SpdmProjectNodeEditReq> machineNodes) {
BatchCreateDirItem phaseCreateDirItem = new BatchCreateDirItem();
DirNodeInfo phaseDirNodeInfo = buildDirNodeInfo(
phaseNode.getUuid(), projectUuid,
NodeTypeEnum.PHASE.getValue(), phaseNode.getNodeName()
);
phaseCreateDirItem.setParentDirNodeInfo(phaseDirNodeInfo);
// 若无机台节点，子节点为空
List<DirNodeInfo> phaseChildDirInfoList = CollectionUtils.isEmpty(machineNodes)
? new ArrayList<>()
: buildDirNodeInfoList(
machineNodes.stream()
.filter(machineNode -> phaseNode.getUuid().equals(machineNode.getPid()))
.collect(Collectors.toList()),
phaseNode.getUuid(), NodeTypeEnum.MACHINE.getValue()
);
phaseCreateDirItem.setChildDirNodeInfos(phaseChildDirInfoList);
return phaseCreateDirItem;
}
/**
* 构建机台、工位的dirItem
*/
private void buildMachineWorkspaceDirItems(SpdmProjectNodeEditReq phaseNode,
List<SpdmProjectNodeEditReq> currentMachineNodes,
List<SpdmProjectNodeEditReq> workspaceNodes,
List<BatchCreateDirItem> createDirItemList) {
if (CollectionUtils.isEmpty(currentMachineNodes)) {
return;
}
for (SpdmProjectNodeEditReq machineNode : currentMachineNodes) {
// 构建机台节点的dirItem
BatchCreateDirItem machineCreateDirItem = buildMachineDirItem(machineNode, phaseNode.getUuid(), workspaceNodes);
createDirItemList.add(machineCreateDirItem);
// 筛选当前机台下的工位节点
List<SpdmProjectNodeEditReq> currentWorkspaceNodes = workspaceNodes.stream()
.filter(workspaceNode -> machineNode.getUuid().equals(workspaceNode.getPid()))
.collect(Collectors.toList());
// 构建工位节点的dirItem
buildWorkspaceDirItems(machineNode, currentWorkspaceNodes, createDirItemList);
}
}
/**
* 构建机台节点的dirItem
*/
private BatchCreateDirItem buildMachineDirItem(SpdmProjectNodeEditReq machineNode,
String phaseUuid,
List<SpdmProjectNodeEditReq> workspaceNodes) {
BatchCreateDirItem machineCreateDirItem = new BatchCreateDirItem();
DirNodeInfo machineDirNodeInfo = buildDirNodeInfo(
machineNode.getUuid(), phaseUuid,
NodeTypeEnum.MACHINE.getValue(), machineNode.getNodeName()
);
machineCreateDirItem.setParentDirNodeInfo(machineDirNodeInfo);
// 构建机台下的工位子节点
List<DirNodeInfo> workspaceDirInfoList = buildDirNodeInfoList(
workspaceNodes.stream()
.filter(workspaceNode -> machineNode.getUuid().equals(workspaceNode.getPid()))
.collect(Collectors.toList()),
machineNode.getUuid(), NodeTypeEnum.WORKSPACE.getValue()
);
machineCreateDirItem.setChildDirNodeInfos(workspaceDirInfoList);
return machineCreateDirItem;
}
/**
* 构建工位节点的dirItem
*/
private void buildWorkspaceDirItems(SpdmProjectNodeEditReq machineNode,
List<SpdmProjectNodeEditReq> currentWorkspaceNodes,
List<BatchCreateDirItem> createDirItemList) {
if (CollectionUtils.isEmpty(currentWorkspaceNodes)) {
return;
}
for (SpdmProjectNodeEditReq workspaceNode : currentWorkspaceNodes) {
BatchCreateDirItem workspaceCreateDirItem = new BatchCreateDirItem();
DirNodeInfo workspaceDirNodeInfo = buildDirNodeInfo(
workspaceNode.getUuid(), machineNode.getUuid(),
NodeTypeEnum.WORKSPACE.getValue(), workspaceNode.getNodeName()
);
workspaceCreateDirItem.setParentDirNodeInfo(workspaceDirNodeInfo);
workspaceCreateDirItem.setChildDirNodeInfos(new ArrayList<>());
createDirItemList.add(workspaceCreateDirItem);
}
}
/**
* 通用方法：构建单个DirNodeInfo
*/
private DirNodeInfo buildDirNodeInfo(String uuid, String parentUuid, String nodeType, String dirName) {
DirNodeInfo dirNodeInfo = new DirNodeInfo();
dirNodeInfo.setUuId(uuid);
dirNodeInfo.setParentUuId(parentUuid);
dirNodeInfo.setUuIdOwnType(nodeType);
dirNodeInfo.setDirName(dirName);
return dirNodeInfo;
}
/**
* 通用方法：批量构建DirNodeInfo列表
*/
private List<DirNodeInfo> buildDirNodeInfoList(List<SpdmProjectNodeEditReq> nodeList, String parentUuid, String nodeType) {
if (CollectionUtils.isEmpty(nodeList)) {
return new ArrayList<>();
}
return nodeList.stream()
.map(node -> buildDirNodeInfo(node.getUuid(), parentUuid, nodeType, node.getNodeName()))
.collect(Collectors.toList());
}
/**
* 调用批量创建文件夹接口并记录日志
*/
private void callBatchCreateDirApi(BatchCreateDirReq batchCreateDirReq) {
log.info("创建节点时，调用批量创建文件夹的参数为：{}", batchCreateDirReq);
SdmResponse response = dataFeignClient.batchCreateDir(batchCreateDirReq);
log.info("创建节点时，调用批量创建文件夹的返回值为：{}", response);
}
/**
* 筛选不同类型的节点，封装为统一对象
*/
private NodeTypeFilterResult filterNodesByType(List<SpdmProjectNodeEditReq> addNodeList) {
SpdmProjectNodeEditReq projectNode = addNodeList.stream()
.filter(node -> NodeTypeEnum.PROJECT.getValue().equals(node.getNodeType()))
.findFirst()
.orElse(null);
List<SpdmProjectNodeEditReq> phaseNodes = addNodeList.stream()
.filter(node -> NodeTypeEnum.PHASE.getValue().equals(node.getNodeType()))
.collect(Collectors.toList());
List<SpdmProjectNodeEditReq> machineNodes = addNodeList.stream()
.filter(node -> NodeTypeEnum.MACHINE.getValue().equals(node.getNodeType()))
.collect(Collectors.toList());
List<SpdmProjectNodeEditReq> workspaceNodes = addNodeList.stream()
.filter(node -> NodeTypeEnum.WORKSPACE.getValue().equals(node.getNodeType()))
.collect(Collectors.toList());
return new NodeTypeFilterResult(projectNode, phaseNodes, machineNodes, workspaceNodes);
}
/**
* 构建批量创建节点文件夹的参数并调用接口
* @param addNodeList
*/
public void batchCreateNodeDir(List<SpdmProjectNodeEditReq> addNodeList) {
// 1. 分类筛选节点
NodeTypeFilterResult filterResult = filterNodesByType(addNodeList);
// 2. 无项目节点时，仅创建单个阶段节点
if (ObjectUtils.isEmpty(filterResult.getProjectNode())) {
createSinglePhaseDir(filterResult.getAddPhaseNodeList());
return;
}
// 3. 有项目节点时，批量构建层级化文件夹创建请求
BatchCreateDirReq batchCreateDirReq = buildBatchCreateDirReq(filterResult);
// 4. 调用批量创建接口并记录日志
callBatchCreateDirApi(batchCreateDirReq);
}
private void updatePermission(Long userId,String uuid) {
// 更新文件权限
UpdatePermissionReq updatePermissionReq = new UpdatePermissionReq();
@@ -1049,9 +1249,9 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
createDirReq.setParentUuId(ObjectUtils.isNotEmpty(parentUuid) ? parentUuid : null);
createDirReq.setDirName(dirName);
createDirReq.setDirType(DirTypeEnum.PROJECT_NODE_DIR.getValue());
log.info("创建项目阶段时，调用创建文件夹的参数为：{}", createDirReq);
log.info("dirItem目阶段时，调用创建文件夹的参数为：{}", createDirReq);
SdmResponse response = dataClientFeignClient.createDir(createDirReq);
log.info("创建项目阶段时，调用创建文件夹的返回值为：{}", response);
log.info("dirItem目阶段时，调用创建文件夹的返回值为：{}", response);
return response;
}
@@ -1984,7 +2184,7 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
return resp;
}
try {
// 创建项目节点的文件夹
// dirItem目节点的文件夹
SdmResponse response = createDir(spdmProjectNodeEditReq.getUuid(), spdmProjectNodeEditReq.getNodeType(), null, spdmProjectNodeEditReq.getNodeName());
if (ObjectUtils.isEmpty(response) || response.getCode() != ResultCode.SUCCESS.getCode()) {
log.error("同步CID项目：{}时，创建文件夹失败，原因为：{}",req.getProjectId() + " " + req.getProjectName(),response.getMessage());

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

@@ -742,7 +742,7 @@ public class ProjectServiceImpl extends BaseService implements IProjectService {
flowTemplateNameList.add(flowTemplateResp.getData().getTemplateName());
}
if (CollectionUtils.isNotEmpty(flowTemplateNameList)) {
taskNodePo.setFlowTemplateName(String.join(",", flowTemplateNameList));
taskNodePo.setFlowTemplateNames(String.join(",", flowTemplateNameList));
}
}
}

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

@@ -3332,4 +3332,33 @@ public class TaskServiceImpl implements ITaskService {
return response;
}
@Override
public SdmResponse<List<ProjectUserLoadResp>> queryProjectUserLoads(ProjectUserLoadReq req) {
Long tenantId = ThreadLocalContext.getTenantId();
List<String> projectIdList = req.getProjectIdList();
String beginTime = req.getBeginTime();
String endTime = req.getEndTime();
// 根据项目id、开始/结束时间查询：参考项目、及对应的任务信息
List<SimulationNode> projectNodeList = nodeService.lambdaQuery().in(CollectionUtils.isNotEmpty(projectIdList), SimulationNode::getProjectId, projectIdList)
.eq(SimulationNode::getNodeType, NodeTypeEnum.PROJECT.getValue())
.eq(SimulationNode::getTenantId,tenantId).list();
if (CollectionUtils.isEmpty(projectNodeList)) {
return SdmResponse.success(new ArrayList<>());
}
// 根据查询出来的项目，过滤出所有的任务
List<String> realProjectIdList;
if (CollectionUtils.isNotEmpty(projectIdList)) {
realProjectIdList = projectIdList;
}else {
realProjectIdList = projectNodeList.stream().map(SimulationNode::getUuid).toList();
}
// 根据查询出来的项目，过滤出所有的人员数量
List<ProjectNodeMemberPo> projectMemberList = projectMapper.getProjectMemberList(realProjectIdList);
List<SimulationTask> taskList = simulationTaskService.lambdaQuery().in(SimulationTask::getTag1, realProjectIdList).eq(SimulationTask::getTenantId, tenantId).list();
if (CollectionUtils.isNotEmpty(taskList)) {
List<SpdmTaskMemberVo> taskMemberList = mapper.getMemberList(taskList.stream().map(SimulationTask::getUuid).toList(),null);
}
return SdmResponse.success(new ArrayList<>());
}
}

28
project/src/main/resources/mapper/SimulationProjectMapper.xml
View File

@@ -720,24 +720,14 @@
) and exe_status = '1'
</select>
<!-- <select id="getTaskList" resultType="com.sdm.project.entity.vo.SpdmTaskVo">-->
<!-- select * from simulation_task where tenant_id = #{tenantId}-->
<!-- <if test="taskName != null and taskName != ''">-->
<!-- and task_name = #{taskName}-->
<!-- </if>-->
<!-- <if test="taskStatus != null and taskStatus != ''">-->
<!-- and exe_status = #{taskStatus}-->
<!-- </if>-->
<!-- <if test="achieveStatus != null and achieveStatus != ''">-->
<!-- and achieve_status = #{achieveStatus}-->
<!-- </if>-->
<!-- <if test="nodeId != null and nodeId != ''">-->
<!-- and node_id in (-->
<!-- <foreach collection='nodeIdList' item='nodeId' index='index' separator=','>-->
<!-- #{nodeId}-->
<!-- </foreach>-->
<!-- )-->
<!-- </if>-->
<!-- </select>-->
<select id="getProjectMemberList" resultType="com.sdm.project.model.po.ProjectNodeMemberPo">
select * from simulation_node_member where nodeId in (
<foreach collection='projectIdList' item='projectId' index='index' separator=','>
#{projectId}
</foreach>
)
</select>
</mapper>