package com.sinata.appointment.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.fasterxml.jackson.core.type.TypeReference;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.sinata.appointment.constants.ApprovalNodeCode;
|
import com.sinata.appointment.constants.ApprovalTaskStatus;
|
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;
|
import com.sinata.appointment.entity.BizApprovalNodeConfig;
|
import com.sinata.appointment.entity.MpStaffGroup;
|
import com.sinata.appointment.entity.MpUser;
|
import com.sinata.appointment.entity.SysDept;
|
import com.sinata.appointment.mapper.AppointmentOrderMapper;
|
import com.sinata.appointment.mapper.ApprovalInstanceMapper;
|
import com.sinata.appointment.mapper.ApprovalTaskMapper;
|
import com.sinata.appointment.mapper.BizApprovalNodeConfigMapper;
|
import com.sinata.appointment.mapper.MpStaffGroupMapper;
|
import com.sinata.appointment.mapper.MpUserMapper;
|
import com.sinata.appointment.mapper.SysDeptMapper;
|
import com.sinata.appointment.util.UuidAssert;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
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;
|
|
@Service
|
@RequiredArgsConstructor
|
public class ApprovalFlowViewApplicationService {
|
|
private static final TypeReference<List<String>> STRING_LIST_TYPE = new TypeReference<>() {};
|
|
private final ApprovalInstanceMapper approvalInstanceMapper;
|
private final ApprovalTaskMapper approvalTaskMapper;
|
private final BizApprovalNodeConfigMapper bizApprovalNodeConfigMapper;
|
private final AppointmentOrderMapper appointmentOrderMapper;
|
private final MpUserMapper mpUserMapper;
|
private final SysDeptMapper sysDeptMapper;
|
private final MpStaffGroupMapper mpStaffGroupMapper;
|
private final ObjectMapper objectMapper;
|
|
public List<ApprovalFlowNodeVo> treeByOrderId(Long orderId) {
|
return treeByOrderId(orderId, null);
|
}
|
|
public List<ApprovalFlowNodeVo> treeByOrderId(Long orderId, String orderUuid) {
|
if (orderId == null || orderId <= 0) {
|
return List.of();
|
}
|
ApprovalInstance inst = loadLatestInstance(orderId);
|
if (inst == null) {
|
return List.of();
|
}
|
AppointmentOrder order = appointmentOrderMapper.selectById(orderId);
|
if (order != null && StringUtils.hasText(orderUuid)) {
|
UuidAssert.match(order, orderUuid);
|
}
|
List<ApprovalTask> tasks =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getDelFlag, 0)
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.orderByAsc(ApprovalTask::getCreateTime)
|
.orderByAsc(ApprovalTask::getId));
|
if (tasks.isEmpty()) {
|
return List.of();
|
}
|
|
Map<String, String> nodeNameMap = loadNodeNameMap();
|
Map<Long, MpUser> userMap = loadUserMap(tasks);
|
Map<Long, String> deptNameMap = loadDeptNameMap(tasks);
|
Map<Long, String> staffGroupNameMap = loadStaffGroupNameMap(tasks);
|
List<String> localUnitNames = parseStringList(order == null ? null : order.getPassLocalUnitNames());
|
|
LinkedHashMap<String, LinkedHashMap<String, List<ApprovalTask>>> byNode = new LinkedHashMap<>();
|
for (ApprovalTask t : tasks) {
|
byNode.computeIfAbsent(t.getNodeCode(), k -> new LinkedHashMap<>())
|
.computeIfAbsent(t.getGroupKey(), k -> new ArrayList<>())
|
.add(t);
|
}
|
|
List<ApprovalFlowNodeVo> out = new ArrayList<>();
|
int tmpIdx = 1;
|
for (Map.Entry<String, LinkedHashMap<String, List<ApprovalTask>>> nodeEntry : byNode.entrySet()) {
|
String nodeCode = nodeEntry.getKey();
|
ApprovalFlowNodeVo nodeVo = new ApprovalFlowNodeVo();
|
nodeVo.setNodeCode(nodeCode);
|
nodeVo.setNodeName(nodeNameMap.getOrDefault(nodeCode, nodeCode));
|
|
for (Map.Entry<String, List<ApprovalTask>> groupEntry : nodeEntry.getValue().entrySet()) {
|
String groupKey = groupEntry.getKey();
|
List<ApprovalTask> groupTasks = groupEntry.getValue();
|
ApprovalFlowGroupVo g = new ApprovalFlowGroupVo();
|
g.setGroupKey(groupKey);
|
GroupMeta meta = resolveGroupMeta(nodeCode, groupKey, deptNameMap, staffGroupNameMap, localUnitNames, tmpIdx);
|
if ("TEMP_GROUP".equals(meta.groupType())) {
|
tmpIdx++;
|
}
|
g.setGroupType(meta.groupType());
|
g.setGroupName(meta.groupName());
|
g.setGroupStatus(calcStatus(groupTasks));
|
|
for (ApprovalTask t : groupTasks) {
|
ApprovalFlowTaskUserVo u = new ApprovalFlowTaskUserVo();
|
u.setTaskId(t.getId());
|
u.setUserId(t.getAssigneeUserId());
|
MpUser mp = userMap.get(t.getAssigneeUserId());
|
u.setUserName(resolveUserName(mp));
|
u.setAvatarUrl(mp == null ? null : mp.getAvatarUrl());
|
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);
|
}
|
nodeVo.setNodeStatus(calcNodeStatus(nodeVo.getGroups()));
|
out.add(nodeVo);
|
}
|
return out;
|
}
|
|
private ApprovalInstance loadLatestInstance(Long orderId) {
|
List<ApprovalInstance> list =
|
approvalInstanceMapper.selectList(
|
new LambdaQueryWrapper<ApprovalInstance>()
|
.eq(ApprovalInstance::getDelFlag, 0)
|
.eq(ApprovalInstance::getOrderId, orderId)
|
.orderByDesc(ApprovalInstance::getId));
|
return list.isEmpty() ? null : list.get(0);
|
}
|
|
private Map<String, String> loadNodeNameMap() {
|
List<BizApprovalNodeConfig> rows =
|
bizApprovalNodeConfigMapper.selectList(
|
new LambdaQueryWrapper<BizApprovalNodeConfig>()
|
.eq(BizApprovalNodeConfig::getDelFlag, 0)
|
.orderByAsc(BizApprovalNodeConfig::getSortOrder));
|
Map<String, String> map = new LinkedHashMap<>();
|
for (BizApprovalNodeConfig row : rows) {
|
map.put(row.getNodeCode(), row.getNodeName());
|
}
|
return map;
|
}
|
|
private Map<Long, MpUser> loadUserMap(List<ApprovalTask> tasks) {
|
Set<Long> ids = new LinkedHashSet<>();
|
for (ApprovalTask t : tasks) {
|
if (t.getAssigneeUserId() != null && t.getAssigneeUserId() > 0) {
|
ids.add(t.getAssigneeUserId());
|
}
|
}
|
if (ids.isEmpty()) {
|
return Map.of();
|
}
|
List<MpUser> rows =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.in(MpUser::getId, ids));
|
Map<Long, MpUser> out = new LinkedHashMap<>();
|
for (MpUser row : rows) {
|
out.put(row.getId(), row);
|
}
|
return out;
|
}
|
|
private Map<Long, String> loadDeptNameMap(List<ApprovalTask> tasks) {
|
Set<Long> deptIds = new LinkedHashSet<>();
|
for (ApprovalTask t : tasks) {
|
Long deptId = parseTailId(t.getGroupKey(), ":DEPT:");
|
if (deptId != null && deptId > 0) {
|
deptIds.add(deptId);
|
}
|
}
|
if (deptIds.isEmpty()) {
|
return Map.of();
|
}
|
List<SysDept> rows =
|
sysDeptMapper.selectList(
|
new LambdaQueryWrapper<SysDept>()
|
.eq(SysDept::getDelFlag, 0)
|
.in(SysDept::getId, deptIds));
|
Map<Long, String> out = new LinkedHashMap<>();
|
for (SysDept row : rows) {
|
out.put(row.getId(), row.getDeptName());
|
}
|
return out;
|
}
|
|
private Map<Long, String> loadStaffGroupNameMap(List<ApprovalTask> tasks) {
|
Set<Long> ids = new LinkedHashSet<>();
|
for (ApprovalTask t : tasks) {
|
Long gid = parseTailId(t.getGroupKey(), ":GROUP:");
|
if (gid != null && gid > 0) {
|
ids.add(gid);
|
}
|
}
|
if (ids.isEmpty()) {
|
return Map.of();
|
}
|
List<MpStaffGroup> rows =
|
mpStaffGroupMapper.selectList(
|
new LambdaQueryWrapper<MpStaffGroup>()
|
.eq(MpStaffGroup::getDelFlag, 0)
|
.in(MpStaffGroup::getId, ids));
|
Map<Long, String> out = new LinkedHashMap<>();
|
for (MpStaffGroup row : rows) {
|
out.put(row.getId(), row.getGroupName());
|
}
|
return out;
|
}
|
|
private GroupMeta resolveGroupMeta(
|
String nodeCode,
|
String groupKey,
|
Map<Long, String> deptNameMap,
|
Map<Long, String> staffGroupNameMap,
|
List<String> localUnitNames,
|
int tmpIdx) {
|
if (!ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(nodeCode)) {
|
return new GroupMeta("DEFAULT", "审批人");
|
}
|
Long deptId = parseTailId(groupKey, ":DEPT:");
|
if (deptId != null) {
|
String name = deptNameMap.getOrDefault(deptId, "部门#" + deptId);
|
return new GroupMeta("DEPT", name + "审批组");
|
}
|
Long gid = parseTailId(groupKey, ":GROUP:");
|
if (gid != null) {
|
String name = staffGroupNameMap.getOrDefault(gid, "分组#" + gid);
|
return new GroupMeta("STAFF_GROUP", name + "审批组");
|
}
|
if (groupKey != null && groupKey.contains(":TMP:")) {
|
String unitName =
|
localUnitNames.isEmpty()
|
? null
|
: (localUnitNames.size() == 1
|
? localUnitNames.get(0)
|
: localUnitNames.get(Math.min(tmpIdx - 1, localUnitNames.size() - 1)));
|
String label = StringUtils.hasText(unitName) ? unitName + "临时负责组" : "临时负责组";
|
return new GroupMeta("TEMP_GROUP", label);
|
}
|
return new GroupMeta("DEFAULT", "审批组");
|
}
|
|
private static Long parseTailId(String groupKey, String token) {
|
if (!StringUtils.hasText(groupKey) || !groupKey.contains(token)) {
|
return null;
|
}
|
int idx = groupKey.lastIndexOf(token);
|
if (idx < 0) {
|
return null;
|
}
|
String raw = groupKey.substring(idx + token.length());
|
if (!StringUtils.hasText(raw)) {
|
return null;
|
}
|
try {
|
return Long.parseLong(raw.trim());
|
} catch (Exception ex) {
|
return null;
|
}
|
}
|
|
private List<String> parseStringList(String json) {
|
if (!StringUtils.hasText(json)) {
|
return List.of();
|
}
|
try {
|
List<String> rows = objectMapper.readValue(json, STRING_LIST_TYPE);
|
if (rows == null) {
|
return List.of();
|
}
|
List<String> out = new ArrayList<>();
|
for (String row : rows) {
|
if (StringUtils.hasText(row)) {
|
out.add(row.trim());
|
}
|
}
|
return out;
|
} catch (Exception ex) {
|
return List.of();
|
}
|
}
|
|
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)) {
|
hasWaiting = true;
|
}
|
}
|
if (hasRejected) {
|
return ApprovalTaskStatus.REJECTED;
|
}
|
if (hasCancelled) {
|
return ApprovalTaskStatus.CANCELLED;
|
}
|
if (hasPending) {
|
return ApprovalTaskStatus.PENDING;
|
}
|
if (hasWaiting) {
|
return ApprovalTaskStatus.WAITING;
|
}
|
return ApprovalTaskStatus.APPROVED;
|
}
|
|
private String calcStatus(List<ApprovalTask> tasks) {
|
if (tasks == null || tasks.isEmpty()) {
|
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())) {
|
hasWaiting = true;
|
}
|
}
|
if (hasRejected) {
|
return ApprovalTaskStatus.REJECTED;
|
}
|
if (hasCancelled) {
|
return ApprovalTaskStatus.CANCELLED;
|
}
|
if (hasPending) {
|
return ApprovalTaskStatus.PENDING;
|
}
|
if (hasWaiting) {
|
return ApprovalTaskStatus.WAITING;
|
}
|
return ApprovalTaskStatus.APPROVED;
|
}
|
|
private static String resolveUserName(MpUser user) {
|
if (user == null) {
|
return "";
|
}
|
if (StringUtils.hasText(user.getNickName())) {
|
return user.getNickName();
|
}
|
if (StringUtils.hasText(user.getStaffNo())) {
|
return user.getStaffNo();
|
}
|
return String.valueOf(Objects.requireNonNullElse(user.getId(), 0L));
|
}
|
|
private record GroupMeta(String groupType, String groupName) {}
|
}
|
