Merge remote-tracking branch 'origin/main'

common/src/main/java/com/sdm/common/entity/req/project/BaseReq.java

@@ -22,11 +22,11 @@ public class BaseReq {
 
     @Schema(description = "文件创建搜索开始时间")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private String startTime;
+    private LocalDateTime startTime;
 
     @Schema(description = "文件创建搜索结束时间")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
-    private String endTime;
+    private LocalDateTime finishTime;
 
     @Schema(description = "创建时间范围，格式为 ['开始时间', '结束时间']")
     private List<String> createTime;
@@ -46,8 +46,8 @@ public class BaseReq {
             try {
                 // 解析时间字符串为 LocalDateTime
                 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-                this.startTime = createTime.get(0);
+                this.startTime = LocalDateTime.parse(createTime.get(0), formatter);
-                this.endTime = createTime.get(1);
+                this.finishTime = LocalDateTime.parse(createTime.get(1), formatter);
             } catch (Exception e) {
                 throw new IllegalArgumentException("createTime 时间格式错误，请使用 'yyyy-MM-dd HH:mm:ss' 格式");
             }

project/src/main/java/com/sdm/project/common/BaseEntity.java

@@ -0,0 +1,36 @@
+package com.sdm.project.common;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.sdm.common.entity.bo.BaseBean;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+public class BaseEntity extends BaseBean {
+    private long id;
+
+    @Schema(description = "所属公司")
+    public String company;
+
+    @Schema(description = "更新者ID")
+    @JsonFormat(shape = JsonFormat.Shape.STRING)
+    public Long updater;
+
+    @Schema(description = "更新者名称")
+    public String updaterName;
+
+    @Schema(description = "更新时间")
+    public String updateTime;
+
+    @Schema(description = "租户ID")
+    @JsonFormat(shape = JsonFormat.Shape.STRING)
+    public Long tenantId;
+
+    @Schema(description = "模版创建者名称")
+    public String createName;
+
+    @Schema(description = "创建者ID")
+    @JsonFormat(shape = JsonFormat.Shape.STRING)
+    public Long creator;
+    public String creatorName;
+}

project/src/main/java/com/sdm/project/controller/SimulationAnalysisController.java

@@ -58,7 +58,7 @@ public class SimulationAnalysisController {
      */
     @PostMapping("/runList")
     @Operation(summary = "算例", description = "算例")
-    public SdmResponse runList(SpdmAnalysisRunListReq req) {
+    public SdmResponse runList(@RequestBody SpdmAnalysisRunListReq req) {
         return taskService.analysisRunList(req);
     }
 

project/src/main/java/com/sdm/project/model/req/SpdmAnalysisPerformanceListReq.java

@@ -1,20 +1,25 @@
 package com.sdm.project.model.req;
 
 import com.baomidou.mybatisplus.annotation.TableField;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonSetter;
 import com.sdm.common.entity.ExportExcelFormat;
-import com.sdm.common.entity.pojo.BaseEntity;
 import com.sdm.common.entity.req.data.TagReq;
 import com.sdm.common.entity.req.project.BaseReq;
 import com.sdm.common.entity.req.task.TaskExportExcelParam;
+import com.sdm.project.common.BaseEntity;
 import io.swagger.annotations.ApiModelProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.List;
 
 @Data
-public class SpdmAnalysisPerformanceListReq extends BaseReq {
+public class SpdmAnalysisPerformanceListReq extends BaseEntity {
 
     @NotNull(message = "current不能为空")
     private Integer current;
@@ -98,5 +103,41 @@ public class SpdmAnalysisPerformanceListReq extends BaseReq {
     @Schema(description = "标签请求参数")
     private TagReq tagReq;
 
+    @Schema(description = "文件创建搜索开始时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime startTime;
+
+    @Schema(description = "文件创建搜索结束时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime finishTime;
+
+    @Schema(description = "创建时间范围，格式为 ['开始时间', '结束时间']")
+    private List<String> createTime;
+
+    // 使用 @JsonSetter 注解确保 JSON 反序列化时调用此方法
+    @JsonSetter("createTime")
+    public void setCreateTime(List<String> createTime) {
+        this.createTime = createTime;
+        parseCreateTimeToStartEndTime();
+    }
+
+    /**
+     * 解析 createTime 并赋值给 startTime 和 endTime
+     */
+    private void parseCreateTimeToStartEndTime() {
+        if (createTime != null && createTime.size() == 2) {
+            try {
+                // 解析时间字符串为 LocalDateTime
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                this.startTime = LocalDateTime.parse(createTime.get(0), formatter);
+                this.finishTime = LocalDateTime.parse(createTime.get(1), formatter);
+            } catch (Exception e) {
+                throw new IllegalArgumentException("createTime 时间格式错误，请使用 'yyyy-MM-dd HH:mm:ss' 格式");
+            }
+        }
+    }
+
+    @JsonProperty(value = "pMembers")
+    private Long pMembers;
 
 }

project/src/main/java/com/sdm/project/model/req/SpdmAnalysisRunListReq.java

@@ -2,21 +2,24 @@ package com.sdm.project.model.req;
 
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonSetter;
 import com.sdm.common.entity.ExportExcelFormat;
-import com.sdm.common.entity.pojo.BaseEntity;
 import com.sdm.common.entity.req.data.TagReq;
 import com.sdm.common.entity.req.project.BaseReq;
 import com.sdm.common.entity.req.task.TaskExportExcelParam;
+import com.sdm.project.common.BaseEntity;
 import io.swagger.annotations.ApiModelProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 
 import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.List;
 
 @Data
-public class SpdmAnalysisRunListReq extends BaseReq {
+public class SpdmAnalysisRunListReq extends BaseEntity {
 
     @NotNull(message = "current不能为空")
     private Integer current;
@@ -102,4 +105,42 @@ public class SpdmAnalysisRunListReq extends BaseReq {
      */
     @Schema(description = "标签请求参数")
     private TagReq tagReq;
+
+    @Schema(description = "文件创建搜索开始时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime startTime;
+
+    @Schema(description = "文件创建搜索结束时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime finishTime;
+
+    @Schema(description = "创建时间范围，格式为 ['开始时间', '结束时间']")
+    private List<String> createTime;
+
+    // 使用 @JsonSetter 注解确保 JSON 反序列化时调用此方法
+    @JsonSetter("createTime")
+    public void setCreateTime(List<String> createTime) {
+        this.createTime = createTime;
+        parseCreateTimeToStartEndTime();
+    }
+
+    /**
+     * 解析 createTime 并赋值给 startTime 和 endTime
+     */
+    private void parseCreateTimeToStartEndTime() {
+        if (createTime != null && createTime.size() == 2) {
+            try {
+                // 解析时间字符串为 LocalDateTime
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                this.startTime = LocalDateTime.parse(createTime.get(0), formatter);
+                this.finishTime = LocalDateTime.parse(createTime.get(1), formatter);
+            } catch (Exception e) {
+                throw new IllegalArgumentException("createTime 时间格式错误，请使用 'yyyy-MM-dd HH:mm:ss' 格式");
+            }
+        }
+    }
+
+    @JsonProperty(value = "pMembers")
+    private Long pMembers;
+
 }

project/src/main/java/com/sdm/project/model/req/SpdmAnalysisTaskListReq.java

@@ -3,20 +3,25 @@ package com.sdm.project.model.req;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonSetter;
 import com.sdm.common.entity.ExportExcelFormat;
-import com.sdm.common.entity.pojo.BaseEntity;
 import com.sdm.common.entity.req.data.TagReq;
 import com.sdm.common.entity.req.project.BaseReq;
 import com.sdm.common.entity.req.task.TaskExportExcelParam;
+import com.sdm.project.common.BaseEntity;
 import io.swagger.annotations.ApiModelProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.Data;
 
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.List;
 
 @Data
-public class SpdmAnalysisTaskListReq extends BaseReq {
+public class SpdmAnalysisTaskListReq extends BaseEntity {
 
     @NotNull(message = "current不能为空")
     private Integer current;
@@ -150,10 +155,48 @@ public class SpdmAnalysisTaskListReq extends BaseReq {
 
     private String reportContent;
 
+    @Schema(description = "文件创建搜索开始时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime startTime;
+
+    @Schema(description = "文件创建搜索结束时间")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime finishTime;
+
+    @Schema(description = "创建时间范围，格式为 ['开始时间', '结束时间']")
+    private List<String> createTime;
+
+    // 使用 @JsonSetter 注解确保 JSON 反序列化时调用此方法
+    @JsonSetter("createTime")
+    public void setCreateTime(List<String> createTime) {
+        this.createTime = createTime;
+        parseCreateTimeToStartEndTime();
+    }
+
+    /**
+     * 解析 createTime 并赋值给 startTime 和 endTime
+     */
+    private void parseCreateTimeToStartEndTime() {
+        if (createTime != null && createTime.size() == 2) {
+            try {
+                // 解析时间字符串为 LocalDateTime
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                this.startTime = LocalDateTime.parse(createTime.get(0), formatter);
+                this.finishTime = LocalDateTime.parse(createTime.get(1), formatter);
+            } catch (Exception e) {
+                throw new IllegalArgumentException("createTime 时间格式错误，请使用 'yyyy-MM-dd HH:mm:ss' 格式");
+            }
+        }
+    }
+
     /**
      * 标签请求参数 设置tag1-tag10 ,taskId, runId记录文件所属节点信息
      */
     @Schema(description = "标签请求参数")
     private TagReq tagReq;
 
+    @JsonProperty(value = "pMembers")
+    private Long pMembers;
+
+
 }

project/src/main/java/com/sdm/project/service/impl/LyricInternalServiceImpl.java

@@ -599,7 +599,7 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
         // 仿真负责人
         addDemandMember(todo.getVerifierNo(), MemberTypeEnum.PRINCIPAL.getCode(), demandUuid, jobNumber, curDateStr, memberList);
         // 仿真执行人
-        addDemandMember(todo.getEmulationExecutor(), MemberTypeEnum.EXECUTOR.getCode(), demandUuid, jobNumber, curDateStr, memberList);
+        addDemandMember(todo.getPerformer(), MemberTypeEnum.EXECUTOR.getCode(), demandUuid, jobNumber, curDateStr, memberList);
         // 3D负责人
         addDemandMember(todo.getThreeDimensionalPerformer(), MemberTypeEnum.THREED.getCode(), demandUuid, jobNumber, curDateStr, memberList);
         // 关注人
@@ -623,7 +623,8 @@ public class LyricInternalServiceImpl implements ILyricInternalService {
 
 
         String[] userIdStr;
-        if (MemberTypeEnum.PRINCIPAL.getCode().equals(type) || MemberTypeEnum.ATTENTION.getCode().equals(type)) {
+        if (MemberTypeEnum.PRINCIPAL.getCode().equals(type) || MemberTypeEnum.ATTENTION.getCode().equals(type) ||
+                MemberTypeEnum.EXECUTOR.getCode().equals(type)) {
             userIdStr = memberStr.split(",");
         }else {
             userIdStr = memberStr.split("-");

project/src/main/java/com/sdm/project/service/impl/NodeServiceImpl.java

@@ -3702,7 +3702,8 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
 
 
         String[] userIdStr;
-        if (MemberTypeEnum.PRINCIPAL.getCode().equals(type) || MemberTypeEnum.EXECUTOR.getCode().equals(type)) {
+        if (MemberTypeEnum.PRINCIPAL.getCode().equals(type) || MemberTypeEnum.ATTENTION.getCode().equals(type) ||
+                MemberTypeEnum.EXECUTOR.getCode().equals(type)) {
             userIdStr = memberStr.split(",");
         } {
             userIdStr = memberStr.split("-");
@@ -3745,7 +3746,7 @@ public class NodeServiceImpl extends ServiceImpl<SimulationNodeMapper, Simulatio
         // 仿真负责人
         addDemandMember(todoItem.getVerifierNo(), MemberTypeEnum.PRINCIPAL.getCode(), demandUuid, currentUserId, currentTimeStr, memberList,permissionReqList,usernameToUserIdMap);
         // 仿真执行人
-        addDemandMember(todoItem.getEmulationExecutor(), MemberTypeEnum.EXECUTOR.getCode(), demandUuid, currentUserId, currentTimeStr, memberList,permissionReqList,usernameToUserIdMap);
+        addDemandMember(todoItem.getPerformer(), MemberTypeEnum.EXECUTOR.getCode(), demandUuid, currentUserId, currentTimeStr, memberList,permissionReqList,usernameToUserIdMap);
         // 3D负责人
         addDemandMember(todoItem.getThreeDimensionalPerformer(), MemberTypeEnum.THREED.getCode(), demandUuid, currentUserId, currentTimeStr, memberList,permissionReqList,usernameToUserIdMap);
 

project/src/main/java/com/sdm/project/service/impl/TaskServiceImpl.java

@@ -88,8 +88,10 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -1668,42 +1670,94 @@ public class TaskServiceImpl implements ITaskService {
         taskReq.setName("");
         taskReq.setBeginTime("");
         taskReq.setEndTime("");
+        taskReq.setCreateTime(null);
+        taskReq.setStartTime(null);
+        taskReq.setFinishTime(null);
         SdmResponse response = analysisTaskList(taskReq);
         if (ObjectUtils.isEmpty(response)) {
-            log.error("指标查询中，未查询到任务1");
+            log.info("指标查询中，未查询到任务1");
             return SdmResponse.success(new ArrayList<>());
         }
         JSONObject data = (JSONObject) response.getData();
         List<SpdmAnalysisTaskVo> taskVoList = (List<SpdmAnalysisTaskVo>) data.get("data");
         if (CollectionUtils.isEmpty(taskVoList)) {
-            log.error("指标查询中，未查询到任务2");
+            log.info("指标查询中，未查询到任务2");
             return SdmResponse.success(new ArrayList<>());
         }
 
         List<String> taskIdList = taskVoList.stream().map(SpdmAnalysisTaskVo::getUuid).toList();
         List<PerformanceNodePo> performanceNodePoList = projectMapper.queryPerformanceNodeByNodeIdList(taskIdList, req);
         if (CollectionUtils.isEmpty(performanceNodePoList)) {
-            log.error("指标查询中，未查询到指标1");
+            log.info("指标查询中，未查询到指标1");
             return SdmResponse.success(new ArrayList<>());
         }
         if (StringUtils.isNotBlank(req.getPerformanceName())) {
             performanceNodePoList = performanceNodePoList.stream().filter(performance -> performance.getPerformanceName().contains(req.getName())).toList();
         }
         if (CollectionUtils.isEmpty(performanceNodePoList)) {
-            log.error("指标查询中，未查询到指标2");
+            log.info("指标查询中，未查询到指标2");
             return SdmResponse.success(new ArrayList<>());
         }
         if (StringUtils.isNotBlank(req.getRunId())) {
             String runId = req.getRunId();
             performanceNodePoList = performanceNodePoList.stream().filter(performance -> runId.equals(performance.getRunId())).toList();
             if (CollectionUtils.isEmpty(performanceNodePoList)) {
-                log.error("指标查询中，未查询到指标3");
+                log.info("指标查询中，未查询到指标3");
                 return SdmResponse.success(new ArrayList<>());
             }
         } else {
             // 不传runId 为导出任务下的指标 筛除掉算例下的指标
             performanceNodePoList = performanceNodePoList.stream().filter(performance -> StringUtils.isEmpty(performance.getRunId())).toList();
         }
+        if (CollectionUtils.isEmpty(performanceNodePoList)) {
+            log.info("指标查询中，未查询到指标3");
+            return SdmResponse.success(new ArrayList<>());
+        }
+
+
+        List<PerformanceNodePo> filterPerformanceList = new ArrayList<>();
+        // 根据创建时间过滤
+        if (CollectionUtils.isNotEmpty(req.getCreateTime())) {
+            LocalDateTime startTime = req.getStartTime();
+            LocalDateTime finishTime = req.getFinishTime();
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            for (PerformanceNodePo performanceNodePo : performanceNodePoList) {
+                if (StringUtils.isBlank(performanceNodePo.getCreateTime())) {
+                    continue;
+                }
+                try {
+                    Date createTimeDate = sdf.parse(performanceNodePo.getCreateTime());
+                    LocalDateTime createTime = createTimeDate.toInstant()
+                            .atZone(ZoneId.systemDefault())
+                            .toLocalDateTime();
+                    boolean isBetween = !createTime.isBefore(startTime) && !createTime.isAfter(finishTime);
+                    if (!isBetween) {
+                        continue;
+                    }
+                    filterPerformanceList.add(performanceNodePo);
+                } catch (ParseException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            performanceNodePoList = filterPerformanceList;
+        }
+
+        if (CollectionUtils.isEmpty(performanceNodePoList)) {
+            log.info("指标查询中，未查询到指标4");
+            return SdmResponse.success(new ArrayList<>());
+        }
+
+        // 根据仿真负责人过滤
+        Long pMembers = req.getPMembers();
+        if (ObjectUtils.isNotEmpty(pMembers)) {
+            performanceNodePoList = performanceNodePoList.stream().filter(performance -> pMembers.equals(performance.getCreator())).collect(Collectors.toList());
+        }
+
+        if (CollectionUtils.isEmpty(performanceNodePoList)) {
+            log.info("指标查询中，未查询到指标5");
+            return SdmResponse.success(new ArrayList<>());
+        }
+
         Map<String, SpdmAnalysisTaskVo> taskMap = taskVoList.stream().collect(Collectors.groupingBy(
                 SpdmAnalysisTaskVo::getUuid,
                 Collectors.collectingAndThen(
@@ -1790,7 +1844,7 @@ public class TaskServiceImpl implements ITaskService {
 
         TagReq tagReq = req.getTagReq();
         if (ObjectUtils.isEmpty(tagReq)){
-            log.info("tagReq为空");
+            log.error("tagReq为空");
             return oldAnalysisTaskList(req);
         }
         // key可能为多个，根据逗号转化为集合
@@ -1859,21 +1913,65 @@ public class TaskServiceImpl implements ITaskService {
                     tag1KeyList,tag2KeyList,tag3KeyList,tag4KeyList,tag5KeyList,tag6KeyList,tag7KeyList
                     ,tag8KeyList,tag9KeyList,tag10KeyList);
             if (CollectionUtils.isEmpty(taskVoList)) {
-                log.error("数据分析中未查询到任务信息");
+                log.info("数据分析中未查询到任务信息");
                 jsonObject.put("data", new ArrayList<>());
                 return SdmResponse.success(jsonObject);
             }
             allTaskVoList = taskVoList;
         }
         if (CollectionUtils.isEmpty(allTaskVoList)) {
-            log.error("数据分析中未查询到任务信息");
+            log.info("数据分析中未查询到任务信息");
             jsonObject.put("data", new ArrayList<>());
             return SdmResponse.success(jsonObject);
         }
+        List<SpdmAnalysisTaskVo> filterTaskVoList = new ArrayList<>();
+        // 根据创建时间过滤
+        if (CollectionUtils.isNotEmpty(req.getCreateTime())) {
+            LocalDateTime startTime = req.getStartTime();
+            LocalDateTime finishTime = req.getFinishTime();
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            for (SpdmAnalysisTaskVo spdmAnalysisTaskVo : allTaskVoList) {
+                if (StringUtils.isBlank(spdmAnalysisTaskVo.getCreateTime())) {
+                    continue;
+                }
+                try {
+                    Date createTimeDate = sdf.parse(spdmAnalysisTaskVo.getCreateTime());
+                    LocalDateTime createTime = createTimeDate.toInstant()
+                            .atZone(ZoneId.systemDefault())
+                            .toLocalDateTime();
+                    boolean isBetween = !createTime.isBefore(startTime) && !createTime.isAfter(finishTime);
+                    if (!isBetween) {
+                        continue;
+                    }
+                    filterTaskVoList.add(spdmAnalysisTaskVo);
+                } catch (ParseException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            allTaskVoList = filterTaskVoList;
+        }
+        if (CollectionUtils.isEmpty(allTaskVoList)) {
+            log.info("数据分析中未查询到任务信息");
+            jsonObject.put("data", new ArrayList<>());
+            return SdmResponse.success(jsonObject);
+        }
+
+        // 根据仿真负责人过滤
+        Long pMembers = req.getPMembers();
+        if (ObjectUtils.isNotEmpty(pMembers)) {
+            allTaskVoList = allTaskVoList.stream().filter(task -> pMembers.equals(task.getCreator())).collect(Collectors.toList());
+        }
+
+        if (CollectionUtils.isEmpty(allTaskVoList)) {
+            log.info("数据分析中未查询到任务信息");
+            jsonObject.put("data", new ArrayList<>());
+            return SdmResponse.success(jsonObject);
+        }
+
         jsonObject.put("total", allTaskVoList.size());
         taskVoList = allTaskVoList.stream().skip((long) (req.getCurrent() - 1) * req.getSize()).limit(req.getSize()).toList();
         if (CollectionUtils.isEmpty(taskVoList)) {
-            log.error("数据分析中未查询到任务信息");
+            log.info("数据分析中未查询到任务信息");
             jsonObject.put("data", new ArrayList<>());
             return SdmResponse.success(jsonObject);
         }
@@ -2133,27 +2231,74 @@ public class TaskServiceImpl implements ITaskService {
         taskReq.setName("");
         taskReq.setBeginTime("");
         taskReq.setEndTime("");
+        taskReq.setCreateTime(null);
+        taskReq.setStartTime(null);
+        taskReq.setFinishTime(null);
         SdmResponse response = analysisTaskList(taskReq);
         if (ObjectUtils.isEmpty(response)) {
-            log.error("指标查询中，未查询到任务1");
+            log.info("指标查询中，未查询到任务1");
             return SdmResponse.success(new ArrayList<>());
         }
         JSONObject data = (JSONObject) response.getData();
         List<SpdmAnalysisTaskVo> taskVoList = (List<SpdmAnalysisTaskVo>) data.get("data");
         if (CollectionUtils.isEmpty(taskVoList)) {
-            log.error("指标查询中，未查询到任务2");
+            log.info("指标查询中，未查询到任务2");
             return SdmResponse.success(new ArrayList<>());
         }
         List<String> taskIdList = taskVoList.stream().map(SpdmAnalysisTaskVo::getUuid).toList();
         List<TaskRunPo> runPoList = projectMapper.queryRunListByNodeIdList(taskIdList, req);
         if (CollectionUtils.isEmpty(runPoList)) {
-            log.error("算例查询中，未查询到算例1");
+            log.info("算例查询中，未查询到算例1");
             return SdmResponse.success(new ArrayList<>());
         }
         if (CollectionUtils.isEmpty(runPoList)) {
-            log.error("算例查询中，未查询到算例2");
+            log.info("算例查询中，未查询到算例2");
             return SdmResponse.success(new ArrayList<>());
         }
+
+        List<TaskRunPo> filterRunList = new ArrayList<>();
+        // 根据创建时间过滤
+        if (CollectionUtils.isNotEmpty(req.getCreateTime())) {
+            LocalDateTime startTime = req.getStartTime();
+            LocalDateTime finishTime = req.getFinishTime();
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            for (TaskRunPo runPo : runPoList) {
+                if (StringUtils.isBlank(runPo.getCreateTime())) {
+                    continue;
+                }
+                try {
+                    Date createTimeDate = sdf.parse(runPo.getCreateTime());
+                    LocalDateTime createTime = createTimeDate.toInstant()
+                            .atZone(ZoneId.systemDefault())
+                            .toLocalDateTime();
+                    boolean isBetween = !createTime.isBefore(startTime) && !createTime.isAfter(finishTime);
+                    if (!isBetween) {
+                        continue;
+                    }
+                    filterRunList.add(runPo);
+                } catch (ParseException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            runPoList = filterRunList;
+        }
+
+        if (CollectionUtils.isEmpty(runPoList)) {
+            log.info("算例查询中，未查询到算例3");
+            return SdmResponse.success(new ArrayList<>());
+        }
+
+        // 根据仿真负责人过滤
+        Long pMembers = req.getPMembers();
+        if (ObjectUtils.isNotEmpty(pMembers)) {
+            runPoList = runPoList.stream().filter(run -> pMembers.equals(run.getCreator())).collect(Collectors.toList());
+        }
+
+        if (CollectionUtils.isEmpty(runPoList)) {
+            log.info("算例查询中，未查询到算例4");
+            return SdmResponse.success(new ArrayList<>());
+        }
+
         Map<String, SpdmAnalysisTaskVo> taskMap = taskVoList.stream().collect(Collectors.groupingBy(
                 SpdmAnalysisTaskVo::getUuid,
                 Collectors.collectingAndThen(