首页添加会签提醒

src/main/java/com/biutag/supervision/controller/work/WorkController.java

@@ -29,4 +29,10 @@ public class WorkController {
         return Result.success(negativeWorkService.page(workParam, WorkStatusEnum.done.name()));
     }
 
+    @GetMapping("todoCountersign")
+    public Result<Page<NegativeWorkModel>> todoCountersign(NegativeQueryParam workParam) {
+        return Result.success(negativeWorkService.todoCountersign(workParam, WorkStatusEnum.todo.name()));
+    }
+
+
 }

src/main/java/com/biutag/supervision/pojo/model/NegativeWorkModel.java

@@ -1,6 +1,7 @@
 package com.biutag.supervision.pojo.model;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -97,4 +98,8 @@ public class NegativeWorkModel {
     // 当前处理对象
     private String currentProcessingObject;
 
+
+    @Schema(description = "会签标识  1进行中，2完成")
+    private String countersignCompleted;
+
 }

src/main/java/com/biutag/supervision/service/NegativeWorkService.java

@@ -10,9 +10,7 @@ import com.biutag.supervision.common.UserContextHolder;
 import com.biutag.supervision.constants.enums.DepartLevelEnum;
 import com.biutag.supervision.constants.enums.ProcessingStatusEnum;
 import com.biutag.supervision.mapper.NegativeWorkMapper;
-import com.biutag.supervision.pojo.entity.NegativeBlame;
+import com.biutag.supervision.pojo.entity.*;
-import com.biutag.supervision.pojo.entity.NegativeHistory;
-import com.biutag.supervision.pojo.entity.NegativeWork;
 import com.biutag.supervision.pojo.model.NegativeWorkModel;
 import com.biutag.supervision.pojo.model.UserAuth;
 import com.biutag.supervision.pojo.param.NegativeQueryParam;
@@ -21,10 +19,7 @@ import com.biutag.supervision.util.TimeUtil;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
 import java.util.stream.Collectors;
 
 @RequiredArgsConstructor
@@ -37,6 +32,10 @@ public class NegativeWorkService extends ServiceImpl<NegativeWorkMapper, Negativ
 
     private final NegativeHistoryService historyService;
 
+    private final NegativeCountersignApplyService negativeCountersignApplyService;
+
+    private final NegativeCountersignService negativeCountersignService;
+
     public Page<NegativeWorkModel> page(NegativeQueryParam param, String workStatus) {
         UserAuth user = UserContextHolder.getCurrentUser();
         if (user.getRoleCodes().isEmpty() || user.getAuthDepartIds().isEmpty() || user.getAuthSources().isEmpty()) {
@@ -164,4 +163,175 @@ public class NegativeWorkService extends ServiceImpl<NegativeWorkMapper, Negativ
     public List<NegativeWork> list(String negativeId) {
         return list(new LambdaQueryWrapper<NegativeWork>().eq(NegativeWork::getNegativeId, negativeId));
     }
+
+    public Page<NegativeWorkModel> todoCountersign(NegativeQueryParam param, String workStatus) {
+        UserAuth user = UserContextHolder.getCurrentUser();
+        if (user.getRoleCodes().isEmpty() || user.getAuthDepartIds().isEmpty() || user.getAuthSources().isEmpty()) {
+            return new Page<NegativeWorkModel>().setTotal(0).setRecords(new ArrayList<>());
+        }
+        QueryWrapper<NegativeWorkModel> queryWrapper = new QueryWrapper<>();
+        queryWrapper.in("w.role_code", user.getRoleCodes())
+                .in("w.depart_id", user.getAuthDepartIds())
+                .in("w.problem_sources_code", user.getAuthSources())
+                .eq("w.status", workStatus)
+                .and(StrUtil.isNotBlank(param.getOriginId()), (qw) -> {
+                    qw.like("n.originId", param.getOriginId()).or().like("n.id", param.getOriginId());
+                })
+                .in(CollectionUtil.isNotEmpty(param.getProblemSourcesCode()), "n.problemSourcesCode", param.getProblemSourcesCode())
+                .eq(StrUtil.isNotBlank(param.getBusinessTypeCode()), "n.businessTypeCode", param.getBusinessTypeCode())
+                .like(StrUtil.isNotBlank(param.getThingDesc()), "n.thingDesc", param.getThingDesc())
+                .eq(StrUtil.isNotBlank(param.getInvolveDepartId()), "n.involveDepartId", param.getInvolveDepartId())
+                .in(Objects.nonNull(param.getProcessingStatus()) && !param.getProcessingStatus().isEmpty(), "n.processing_status", param.getProcessingStatus())
+                .in(CollectionUtil.isNotEmpty(param.getCheckStatus()), "n.checkStatus", param.getCheckStatus())
+                .eq(StrUtil.isNotBlank(param.getIsRectifyCode()), "n.isRectifyCode", param.getIsRectifyCode())
+                .eq(StrUtil.isNotBlank(param.getSpecialSupervision()), "n.special_supervision", param.getSpecialSupervision())
+
+                .eq(StrUtil.isNotBlank(param.getFlowKey()), "n.flow_key", param.getFlowKey())
+                .eq(StrUtil.isNotBlank(param.getSpecialSupervision()), "n.special_supervision", param.getSpecialSupervision())
+                .eq(Objects.nonNull(param.getCrtDepartLevel()), "n.crt_depart_level", param.getCrtDepartLevel())
+                .like(StrUtil.isNotBlank(param.getReportNumber()), "n.report_number", param.getReportNumber())
+                .like(StrUtil.isNotBlank(param.getCaseNumber()), "n.case_number", param.getCaseNumber())
+                .orderByDesc("w.create_time");
+
+        if (param.getHappenTime().size() == 2) {
+            queryWrapper.between("n.happenTime", param.getHappenTime().get(0), param.getHappenTime().get(1));
+        }
+        if (param.getDiscoveryTime().size() == 2) {
+            queryWrapper.between("n.discoveryTime", param.getDiscoveryTime().get(0), param.getDiscoveryTime().get(1));
+        }
+        if (param.getCrtTime().size() == 2) {
+            queryWrapper.between("n.crtTime", param.getCrtTime().get(0), param.getCrtTime().get(1));
+        }
+        if (StrUtil.isNotBlank(param.getResponderKey()) && StrUtil.isNotBlank(param.getResponderValue())) {
+            switch (param.getResponderKey()) {
+                case "name":
+                    queryWrapper.like("n.responderName", param.getResponderValue());
+                    break;
+                case "phone":
+                    queryWrapper.like("n.contactPhone", param.getResponderValue());
+                    break;
+            }
+        }
+        LambdaQueryWrapper<NegativeBlame> blameQueryWrapper = new LambdaQueryWrapper<>();
+
+
+        boolean blameQueryFlag = false;
+        if (StrUtil.isNotBlank(param.getBlameKey()) && StrUtil.isNotBlank(param.getBlameValue())) {
+            switch (param.getResponderKey()) {
+                case "name":
+                    blameQueryWrapper.like(NegativeBlame::getBlameName, param.getBlameValue());
+                    blameQueryFlag = true;
+                    break;
+                case "empNo":
+                    blameQueryWrapper.like(NegativeBlame::getBlameEmpNo, param.getBlameValue());
+                    blameQueryFlag = true;
+                    break;
+                case "idCode":
+                    blameQueryWrapper.like(NegativeBlame::getBlameIdCode, param.getBlameValue());
+                    blameQueryFlag = true;
+                    break;
+            }
+        }
+        boolean handleResultCodeQueryFlag = Objects.nonNull(param.getHandleResultCode()) && !param.getHandleResultCode().isEmpty();
+        blameQueryWrapper.in(handleResultCodeQueryFlag, NegativeBlame::getHandleResultCode, param.getHandleResultCode());
+        if (blameQueryFlag || handleResultCodeQueryFlag) {
+            Set<String> negativeIds = blameService.list(blameQueryWrapper).stream().map(NegativeBlame::getNegativeId).collect(Collectors.toSet());
+            if (negativeIds.isEmpty()) {
+                return new Page<NegativeWorkModel>().setTotal(0).setRecords(new ArrayList<>());
+            }
+            queryWrapper.in("w.negative_id", negativeIds);
+        }
+
+        if (Objects.nonNull(param.getTimeoutFlag())) {
+            if (param.getTimeoutFlag()) {
+                queryWrapper.eq("n.processing_status", ProcessingStatusEnum.completed.name()).gt("n.handle_timeout", 0);
+            } else {
+                queryWrapper
+                        .and(query -> {
+                            query.ne("n.processing_status", ProcessingStatusEnum.completed.name()).or().gt("n.handle_timeout", 0);
+                        });
+            }
+        }
+        // 办理单位
+        if (StrUtil.isNotBlank(param.getHandleDepartId())) {
+            List<DepartTree> nodes = departService.getAllNode(List.of(param.getHandleDepartId()));
+            List<String> secondIds = nodes.stream().filter(node -> DepartLevelEnum.SECOND.getValue().equals(node.getLevel())).map(DepartTree::getId).toList();
+            if (!secondIds.isEmpty()) {
+                queryWrapper.in("n.handle_second_depart_id", secondIds);
+            } else {
+                queryWrapper.in("n.handle_three_depart_id", nodes.stream().filter(node -> DepartLevelEnum.THREE.getValue().equals(node.getLevel())).map(DepartTree::getId).toList());
+            }
+        }
+        // 是否延期
+        if (Objects.nonNull(param.getExtensionFlag())) {
+            if (param.getExtensionFlag()) {
+                queryWrapper.and(query -> {
+                    query.eq("n.extension_apply_flag", false).or().gt("n.extension_days", 0);
+                });
+            } else {
+                queryWrapper.eq("n.extension_apply_flag", true).or().isNull("n.extension_days");
+            }
+        }
+        // 操作人姓名
+        if (StrUtil.isNotBlank(param.getOperator())) {
+            List<NegativeHistory> historyList = historyService.list(new LambdaQueryWrapper<NegativeHistory>().like(NegativeHistory::getCrtName, param.getOperator()));
+            if (historyList.isEmpty()) {
+                return new Page<NegativeWorkModel>().setTotal(0).setRecords(new ArrayList<>());
+            }
+            Set<String> negativeIds = historyList.stream().map(NegativeHistory::getNegativeId).collect(Collectors.toSet());
+            queryWrapper.in("n.id", negativeIds);
+        }
+        Page<NegativeWorkModel> modelPage = baseMapper.queryPage(Page.of(param.getCurrent(), param.getSize()), queryWrapper);
+        modelPage.getRecords().forEach(item -> {
+            item.setRemainingDuration(TimeUtil.getRemainingDuration(item.getFirstDistributeTime(), item.getMaxSignDuration(), item.getMaxHandleDuration(), item.getExtensionDays(), item.getFlowKey()));
+        });
+        String username = user.getUserName();
+        // 自己创建的会签
+        List<String> createdCountersignNegativeIds = negativeCountersignApplyService
+                .list(new LambdaQueryWrapper<NegativeCountersignApply>()
+                        .eq(NegativeCountersignApply::getCreator, username))
+                .stream()
+                .map(NegativeCountersignApply::getNegativeId)
+                .filter(StrUtil::isNotBlank)
+                .collect(Collectors.toCollection(ArrayList::new));
+
+        // 2) 我需要会签的：negativeId 列表
+        List<String> needCountersignNegativeIds = negativeCountersignService
+                .list(new LambdaQueryWrapper<NegativeCountersign>()
+                        .in(CollectionUtil.isNotEmpty(createdCountersignNegativeIds),
+                                NegativeCountersign::getCountersignApplyId,
+                                createdCountersignNegativeIds))
+                .stream()
+                .map(NegativeCountersign::getNegativeId)
+                .filter(StrUtil::isNotBlank)
+                .toList();
+
+        Set<String> relatedNegativeIdSet = new HashSet<>(createdCountersignNegativeIds);
+        relatedNegativeIdSet.addAll(needCountersignNegativeIds);
+        List<NegativeWorkModel> filteredRecords = modelPage.getRecords().stream()
+                .filter(record -> relatedNegativeIdSet.contains(record.getNegativeId()))
+                .toList();
+        // 会签状态
+        for (NegativeWorkModel filteredRecord : filteredRecords) {
+            String negativeId = filteredRecord.getNegativeId();
+            List<NegativeCountersign> countersigns = negativeCountersignService.list(
+                    new LambdaQueryWrapper<NegativeCountersign>()
+                            .eq(NegativeCountersign::getNegativeId, negativeId)
+            );
+            String countersignStatus = "2";
+            if (CollectionUtil.isNotEmpty(countersigns)) {
+                boolean allCompleted = countersigns.stream().allMatch(cs -> "completed".equals(cs.getState()));
+                // 全部 completed → 结束（1）
+                if (allCompleted) {
+                    countersignStatus = "1";
+                }
+            }
+            filteredRecord.setCountersignCompleted(countersignStatus);
+        }
+        modelPage.setRecords(filteredRecords);
+        modelPage.setTotal(filteredRecords.size());
+        return modelPage;
+
+    }
+
 }