小程序对接finish

longz

2026-04-27 25df88d0ab9d7444ed1d162b9efa1259ac2f6f66

 backend/src/main/java/com/sinata/appointment/service/ApprovalFlowViewApplicationService.java

@@ -8,6 +8,7 @@
import com.sinata.appointment.dto.ApprovalFlowGroupVo;
import com.sinata.appointment.dto.ApprovalFlowNodeVo;
import com.sinata.appointment.dto.ApprovalFlowTaskUserVo;
import com.sinata.appointment.dto.MiniVisitedUserVo;
import com.sinata.appointment.entity.AppointmentOrder;
import com.sinata.appointment.entity.ApprovalInstance;
import com.sinata.appointment.entity.ApprovalTask;
@@ -30,6 +31,7 @@
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
@@ -120,6 +122,7 @@
                    u.setTaskStatus(t.getTaskStatus());
                    u.setComment(t.getComment());
                    u.setActionTime(t.getUpdateTime());
                    u.setNoticeUsers(loadNoticeUsers(t.getNoticeIds(), userMap, deptNameMap));
                    g.getUsers().add(u);
                }
                nodeVo.getGroups().add(g);
@@ -294,17 +297,97 @@
        }
    }

    private List<MiniVisitedUserVo> loadNoticeUsers(
            String noticeIds, Map<Long, MpUser> existingUserMap, Map<Long, String> existingDeptNameMap) {
        List<Long> ids = parseCommaSeparatedIds(noticeIds);
        if (ids.isEmpty()) {
            return List.of();
        }
        Map<Long, MpUser> userMap = existingUserMap;
        LinkedHashSet<Long> missingIds = ids.stream()
                .filter(id -> !existingUserMap.containsKey(id))
                .collect(Collectors.toCollection(LinkedHashSet::new));
        if (!missingIds.isEmpty()) {
            List<MpUser> extraUsers =
                    mpUserMapper.selectList(
                            new LambdaQueryWrapper<MpUser>()
                                    .eq(MpUser::getDelFlag, 0)
                                    .in(MpUser::getId, missingIds));
            userMap = new LinkedHashMap<>(existingUserMap);
            for (MpUser extraUser : extraUsers) {
                userMap.put(extraUser.getId(), extraUser);
            }
        }

        Map<Long, String> deptNameMap = existingDeptNameMap;
        LinkedHashSet<Long> missingDeptIds = ids.stream()
                .map(userMap::get)
                .filter(Objects::nonNull)
                .map(MpUser::getDeptId)
                .filter(Objects::nonNull)
                .filter(id -> id > 0 && !existingDeptNameMap.containsKey(id))
                .collect(Collectors.toCollection(LinkedHashSet::new));
        if (!missingDeptIds.isEmpty()) {
            deptNameMap = new LinkedHashMap<>(existingDeptNameMap);
            List<SysDept> depts =
                    sysDeptMapper.selectList(
                            new LambdaQueryWrapper<SysDept>()
                                    .eq(SysDept::getDelFlag, 0)
                                    .in(SysDept::getId, missingDeptIds));
            for (SysDept dept : depts) {
                deptNameMap.put(dept.getId(), dept.getDeptName());
            }
        }

        List<MiniVisitedUserVo> result = new ArrayList<>();
        for (Long id : ids) {
            MpUser user = userMap.get(id);
            if (user == null) {
                continue;
            }
            MiniVisitedUserVo vo = new MiniVisitedUserVo();
            vo.setId(user.getId());
            vo.setRealName(resolveUserName(user));
            vo.setDeptName(user.getDeptId() == null ? null : deptNameMap.get(user.getDeptId()));
            result.add(vo);
        }
        return result;
    }

    private List<Long> parseCommaSeparatedIds(String raw) {
        if (!StringUtils.hasText(raw)) {
            return List.of();
        }
        LinkedHashSet<Long> out = new LinkedHashSet<>();
        for (String part : raw.split(",")) {
            if (!StringUtils.hasText(part)) {
                continue;
            }
            try {
                long id = Long.parseLong(part.trim());
                if (id > 0) {
                    out.add(id);
                }
            } catch (NumberFormatException ignored) {
            }
        }
        return new ArrayList<>(out);
    }

    private String calcNodeStatus(List<ApprovalFlowGroupVo> groups) {
        if (groups.isEmpty()) {
            return ApprovalTaskStatus.WAITING;
        }
        boolean hasRejected = false;
        boolean hasCancelled = false;
        boolean hasPending = false;
        boolean hasWaiting = false;
        for (ApprovalFlowGroupVo g : groups) {
            String s = g.getGroupStatus();
            if (ApprovalTaskStatus.REJECTED.equals(s)) {
                hasRejected = true;
            } else if (ApprovalTaskStatus.CANCELLED.equals(s)) {
                hasCancelled = true;
            } else if (ApprovalTaskStatus.PENDING.equals(s)) {
                hasPending = true;
            } else if (ApprovalTaskStatus.WAITING.equals(s)) {
@@ -313,6 +396,9 @@
        }
        if (hasRejected) {
            return ApprovalTaskStatus.REJECTED;
        }
        if (hasCancelled) {
            return ApprovalTaskStatus.CANCELLED;
        }
        if (hasPending) {
            return ApprovalTaskStatus.PENDING;
@@ -328,11 +414,14 @@
            return ApprovalTaskStatus.WAITING;
        }
        boolean hasRejected = false;
        boolean hasCancelled = false;
        boolean hasPending = false;
        boolean hasWaiting = false;
        for (ApprovalTask t : tasks) {
            if (ApprovalTaskStatus.REJECTED.equals(t.getTaskStatus())) {
                hasRejected = true;
            } else if (ApprovalTaskStatus.CANCELLED.equals(t.getTaskStatus())) {
                hasCancelled = true;
            } else if (ApprovalTaskStatus.PENDING.equals(t.getTaskStatus())) {
                hasPending = true;
            } else if (ApprovalTaskStatus.WAITING.equals(t.getTaskStatus())) {
@@ -342,6 +431,9 @@
        if (hasRejected) {
            return ApprovalTaskStatus.REJECTED;
        }
        if (hasCancelled) {
            return ApprovalTaskStatus.CANCELLED;
        }
        if (hasPending) {
            return ApprovalTaskStatus.PENDING;
        }