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.ApprovalInstanceStatus;
|
import com.sinata.appointment.constants.ApprovalNodeCode;
|
import com.sinata.appointment.constants.ApprovalTaskStatus;
|
import com.sinata.appointment.constants.LocalUnitApproverType;
|
import com.sinata.appointment.constants.MiniUserType;
|
import com.sinata.appointment.constants.SystemSettingKeys;
|
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.MpPassLocalUnit;
|
import com.sinata.appointment.entity.MpPassLocalUnitMember;
|
import com.sinata.appointment.entity.MpStaffGroupMember;
|
import com.sinata.appointment.entity.MpUser;
|
import com.sinata.appointment.entity.SysDept;
|
import com.sinata.appointment.exception.BizException;
|
import com.sinata.appointment.mapper.ApprovalInstanceMapper;
|
import com.sinata.appointment.mapper.ApprovalTaskMapper;
|
import com.sinata.appointment.mapper.BizApprovalNodeConfigMapper;
|
import com.sinata.appointment.mapper.MpPassLocalUnitMapper;
|
import com.sinata.appointment.mapper.MpPassLocalUnitMemberMapper;
|
import com.sinata.appointment.mapper.MpStaffGroupMemberMapper;
|
import com.sinata.appointment.mapper.MpUserMapper;
|
import com.sinata.appointment.mapper.SysDeptMapper;
|
import com.sinata.appointment.constants.BizErrorCode;
|
import java.time.LocalDateTime;
|
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 lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
|
/**
|
* 审批引擎：节点链解析、任务创建、组内任一通过、拒绝终止。
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class ApprovalEngineService {
|
|
private static final TypeReference<List<Long>> LONG_LIST_TYPE = new TypeReference<>() {};
|
private static final String AUTO_APPROVE_COMMENT = "前序节点已审批，系统自动同意";
|
private static final String LOCAL_UNIT_GROUP_TOKEN = ":UNIT:";
|
|
private final BizApprovalNodeConfigMapper bizApprovalNodeConfigMapper;
|
private final ApprovalInstanceMapper approvalInstanceMapper;
|
private final ApprovalTaskMapper approvalTaskMapper;
|
private final MpUserMapper mpUserMapper;
|
private final SysDeptMapper sysDeptMapper;
|
private final MpPassLocalUnitMapper mpPassLocalUnitMapper;
|
private final MpPassLocalUnitMemberMapper mpPassLocalUnitMemberMapper;
|
private final MpStaffGroupMemberMapper mpStaffGroupMemberMapper;
|
private final SysBizSettingCacheService sysBizSettingCacheService;
|
private final ObjectMapper objectMapper;
|
|
public List<String> resolveEnabledNodeChain(AppointmentOrder order) {
|
List<BizApprovalNodeConfig> configs =
|
bizApprovalNodeConfigMapper.selectList(
|
new LambdaQueryWrapper<BizApprovalNodeConfig>()
|
.eq(BizApprovalNodeConfig::getEnabled, 1)
|
.orderByAsc(BizApprovalNodeConfig::getSortOrder));
|
List<String> chain = new ArrayList<>();
|
for (BizApprovalNodeConfig c : configs) {
|
String nc = c.getNodeCode();
|
if (ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER.equals(nc)
|
&& !Boolean.TRUE.equals(order.getHolidayFlag())) {
|
continue;
|
}
|
// 预约流程已不使用“是否涉及其他属地单位(key_area_flag)”字段，三级节点在预约阶段固定跳过。
|
if (ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(nc)) {
|
continue;
|
}
|
chain.add(nc);
|
}
|
return chain;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public ApprovalInstance startFlow(AppointmentOrder order) {
|
List<String> chain = resolveEnabledNodeChain(order);
|
if (chain.isEmpty()) {
|
return null;
|
}
|
String firstNode = resolveFirstNodeWithAssignees(chain, order);
|
if (firstNode == null) {
|
return null;
|
}
|
ApprovalInstance inst = new ApprovalInstance();
|
inst.setOrderId(order.getId());
|
inst.setCurrentNodeCode(firstNode);
|
inst.setStatus(ApprovalInstanceStatus.IN_PROGRESS);
|
approvalInstanceMapper.insert(inst);
|
for (String nodeCode : chain) {
|
String status =
|
Objects.equals(nodeCode, firstNode)
|
? ApprovalTaskStatus.PENDING
|
: ApprovalTaskStatus.WAITING;
|
createTasksForNode(inst, order, nodeCode, status);
|
}
|
return inst;
|
}
|
|
public int createTasksForNode(
|
ApprovalInstance inst, AppointmentOrder order, String nodeCode, String initialStatus) {
|
List<Long> assignees = resolveAssignees(nodeCode, order);
|
return createTasksWithGroupKey(inst.getId(), nodeCode, nodeCode, assignees, initialStatus);
|
}
|
|
public List<Long> resolveAssignees(String nodeCode, AppointmentOrder order) {
|
if (ApprovalNodeCode.LEVEL1_HANDLER.equals(nodeCode)) {
|
return order.getVisitedUserId() == null ? List.of() : List.of(order.getVisitedUserId());
|
}
|
if (ApprovalNodeCode.LEVEL2_DEPT_LEADER.equals(nodeCode)) {
|
Long deptId = resolveVisitedDeptId(order);
|
return getDeptLeaderIds(deptId);
|
}
|
if (ApprovalNodeCode.LEVEL4_VISIT_DEPT.equals(nodeCode)) {
|
Long competentDeptId = getVisitCompetentDeptId();
|
return listEmployeeIdsByDeptWithLeaderFallback(competentDeptId);
|
}
|
if (ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER.equals(nodeCode)) {
|
Long competentDeptId = getVisitCompetentDeptId();
|
return getDeptLeaderIds(competentDeptId);
|
}
|
if (ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(nodeCode)) {
|
return List.of();
|
}
|
return List.of();
|
}
|
|
private Long resolveVisitedDeptId(AppointmentOrder order) {
|
if (order.getVisitedUserId() != null) {
|
MpUser visited = mpUserMapper.selectById(order.getVisitedUserId());
|
if (visited != null
|
&& (visited.getDelFlag() == null || visited.getDelFlag() == 0)
|
&& MiniUserType.EMPLOYEE.equals(visited.getUserType())
|
&& visited.getDeptId() != null
|
&& visited.getDeptId() > 0) {
|
return visited.getDeptId();
|
}
|
}
|
return order.getVisitedDeptId();
|
}
|
|
private Long getVisitCompetentDeptId() {
|
String raw = sysBizSettingCacheService.getValue(SystemSettingKeys.VISIT_COMPETENT_DEPT_ID);
|
if (raw == null || raw.trim().isEmpty()) {
|
return null;
|
}
|
try {
|
long id = Long.parseLong(raw.trim());
|
return id > 0 ? id : null;
|
} catch (NumberFormatException ex) {
|
return null;
|
}
|
}
|
|
private List<Long> getDeptLeaderIds(Long deptId) {
|
if (deptId == null || deptId <= 0) {
|
return List.of();
|
}
|
SysDept dept = sysDeptMapper.selectById(deptId);
|
if (dept == null || dept.getDelFlag() != null && dept.getDelFlag() == 1) {
|
return List.of();
|
}
|
List<Long> leaderIds = parseDeptLeaderIds(dept);
|
if (leaderIds.isEmpty()) {
|
return List.of();
|
}
|
List<MpUser> leaders =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.eq(MpUser::getStatus, 1)
|
.eq(MpUser::getUserType, MiniUserType.EMPLOYEE)
|
.in(MpUser::getId, leaderIds));
|
Map<Long, MpUser> leaderMap = new LinkedHashMap<>();
|
for (MpUser leader : leaders) {
|
leaderMap.put(leader.getId(), leader);
|
}
|
List<Long> result = new ArrayList<>();
|
for (Long id : leaderIds) {
|
if (leaderMap.containsKey(id)) {
|
result.add(id);
|
}
|
}
|
return result;
|
}
|
|
private List<Long> parseDeptLeaderIds(SysDept dept) {
|
List<Long> ids = new ArrayList<>();
|
Set<Long> seen = new LinkedHashSet<>();
|
if (StringUtils.hasText(dept.getLeaderIds())) {
|
for (String part : dept.getLeaderIds().split(",")) {
|
if (!StringUtils.hasText(part)) {
|
continue;
|
}
|
try {
|
Long id = Long.parseLong(part.trim());
|
if (id > 0 && seen.add(id)) {
|
ids.add(id);
|
}
|
} catch (NumberFormatException ignored) {
|
}
|
}
|
}
|
return ids;
|
}
|
|
private List<Long> listAllActiveEmployeeIdsByDept(Long deptId) {
|
if (deptId == null || deptId <= 0) {
|
return List.of();
|
}
|
List<MpUser> users =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.eq(MpUser::getStatus, 1)
|
.eq(MpUser::getUserType, MiniUserType.EMPLOYEE)
|
.eq(MpUser::getDeptId, deptId));
|
return users.stream().map(MpUser::getId).filter(Objects::nonNull).distinct().toList();
|
}
|
|
private List<Long> listEmployeeIdsByDeptWithLeaderFallback(Long deptId) {
|
return listAllActiveEmployeeIdsByDept(deptId);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void markGroupSkippedExcept(ApprovalTask approvedTask) {
|
List<ApprovalTask> siblings =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, approvedTask.getInstanceId())
|
.eq(ApprovalTask::getNodeCode, approvedTask.getNodeCode())
|
.eq(ApprovalTask::getGroupKey, approvedTask.getGroupKey())
|
.eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.PENDING));
|
for (ApprovalTask s : siblings) {
|
if (!Objects.equals(s.getId(), approvedTask.getId())) {
|
s.setTaskStatus(ApprovalTaskStatus.SKIPPED);
|
approvalTaskMapper.updateById(s);
|
}
|
}
|
}
|
|
public boolean isCurrentNodeComplete(ApprovalInstance inst) {
|
long pending =
|
approvalTaskMapper.selectCount(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.eq(ApprovalTask::getNodeCode, inst.getCurrentNodeCode())
|
.eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.PENDING));
|
return pending == 0;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void advanceOrComplete(ApprovalInstance inst, AppointmentOrder order) {
|
List<String> chain = resolveAdvanceChain(inst, order);
|
int idx = chain.indexOf(inst.getCurrentNodeCode());
|
if (idx < 0) {
|
inst.setStatus(ApprovalInstanceStatus.APPROVED);
|
inst.setFinishedAt(LocalDateTime.now());
|
inst.setCurrentNodeCode(null);
|
approvalInstanceMapper.updateById(inst);
|
return;
|
}
|
for (int i = idx + 1; i < chain.size(); i++) {
|
String next = chain.get(i);
|
if (activateWaitingTasks(inst.getId(), next) > 0) {
|
inst.setCurrentNodeCode(next);
|
approvalInstanceMapper.updateById(inst);
|
autoApproveCurrentNodeByHistory(inst.getId(), next);
|
if (!isCurrentNodeComplete(inst)) {
|
return;
|
}
|
}
|
}
|
inst.setStatus(ApprovalInstanceStatus.APPROVED);
|
inst.setFinishedAt(LocalDateTime.now());
|
inst.setCurrentNodeCode(null);
|
approvalInstanceMapper.updateById(inst);
|
}
|
|
private List<String> resolveAdvanceChain(ApprovalInstance inst, AppointmentOrder order) {
|
List<ApprovalTask> instanceTasks =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getDelFlag, 0)
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.select(ApprovalTask::getNodeCode));
|
boolean containsLocalUnitNode =
|
instanceTasks.stream()
|
.map(ApprovalTask::getNodeCode)
|
.anyMatch(ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER::equals);
|
return containsLocalUnitNode
|
? resolveEnabledNodeChainForPostHandler(order)
|
: resolveEnabledNodeChain(order);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void rejectInstance(ApprovalInstance inst, String reason) {
|
inst.setStatus(ApprovalInstanceStatus.REJECTED);
|
inst.setFinishedAt(LocalDateTime.now());
|
approvalInstanceMapper.updateById(inst);
|
List<ApprovalTask> remainingTasks =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.in(
|
ApprovalTask::getTaskStatus,
|
ApprovalTaskStatus.PENDING,
|
ApprovalTaskStatus.WAITING));
|
for (ApprovalTask t : remainingTasks) {
|
t.setTaskStatus(ApprovalTaskStatus.REJECTED);
|
t.setComment(null);
|
approvalTaskMapper.updateById(t);
|
}
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void cancelInstance(ApprovalInstance inst, String reason) {
|
inst.setStatus(ApprovalInstanceStatus.CANCELLED);
|
inst.setFinishedAt(LocalDateTime.now());
|
approvalInstanceMapper.updateById(inst);
|
List<ApprovalTask> pending =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.in(
|
ApprovalTask::getTaskStatus,
|
ApprovalTaskStatus.PENDING,
|
ApprovalTaskStatus.WAITING));
|
for (ApprovalTask t : pending) {
|
t.setTaskStatus(ApprovalTaskStatus.CANCELLED);
|
t.setComment(reason);
|
approvalTaskMapper.updateById(t);
|
}
|
}
|
|
private String resolveFirstNodeWithAssignees(List<String> chain, AppointmentOrder order) {
|
for (String nodeCode : chain) {
|
List<Long> assignees = resolveAssignees(nodeCode, order);
|
if (assignees != null && !assignees.isEmpty()) {
|
return nodeCode;
|
}
|
}
|
return null;
|
}
|
|
private int activateWaitingTasks(Long instanceId, String nodeCode) {
|
List<ApprovalTask> waiting =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, instanceId)
|
.eq(ApprovalTask::getNodeCode, nodeCode)
|
.eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.WAITING));
|
for (ApprovalTask t : waiting) {
|
t.setTaskStatus(ApprovalTaskStatus.PENDING);
|
approvalTaskMapper.updateById(t);
|
}
|
return waiting.size();
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void rebuildAfterHandlerApproved(
|
ApprovalTask approvedTask, ApprovalInstance inst, AppointmentOrder order) {
|
approvalTaskMapper.delete(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, inst.getId())
|
.ne(ApprovalTask::getId, approvedTask.getId()));
|
|
List<String> chain = resolveEnabledNodeChainForPostHandler(order);
|
int idx = chain.indexOf(ApprovalNodeCode.LEVEL1_HANDLER);
|
int start = idx >= 0 ? idx + 1 : 0;
|
|
String firstNode = null;
|
for (int i = start; i < chain.size(); i++) {
|
String nodeCode = chain.get(i);
|
String status = firstNode == null ? ApprovalTaskStatus.PENDING : ApprovalTaskStatus.WAITING;
|
int created;
|
if (ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(nodeCode)) {
|
created = createTasksForLocalUnitNodeStrict(inst.getId(), order, status);
|
} else {
|
created = createTasksForNodeStrict(inst, order, nodeCode, status);
|
}
|
if (created > 0 && firstNode == null) {
|
firstNode = nodeCode;
|
}
|
}
|
|
if (firstNode == null) {
|
inst.setStatus(ApprovalInstanceStatus.APPROVED);
|
inst.setFinishedAt(LocalDateTime.now());
|
inst.setCurrentNodeCode(null);
|
approvalInstanceMapper.updateById(inst);
|
return;
|
}
|
inst.setCurrentNodeCode(firstNode);
|
inst.setStatus(ApprovalInstanceStatus.IN_PROGRESS);
|
inst.setFinishedAt(null);
|
approvalInstanceMapper.updateById(inst);
|
autoApproveCurrentNodeByHistory(inst.getId(), firstNode);
|
if (isCurrentNodeComplete(inst)) {
|
advanceOrComplete(inst, order);
|
}
|
}
|
|
private List<String> resolveEnabledNodeChainForPostHandler(AppointmentOrder order) {
|
List<BizApprovalNodeConfig> configs =
|
bizApprovalNodeConfigMapper.selectList(
|
new LambdaQueryWrapper<BizApprovalNodeConfig>()
|
.eq(BizApprovalNodeConfig::getEnabled, 1)
|
.orderByAsc(BizApprovalNodeConfig::getSortOrder));
|
List<String> chain = new ArrayList<>();
|
List<Long> localUnitIds = parseLongJsonArray(order.getPassLocalUnitIds());
|
for (BizApprovalNodeConfig c : configs) {
|
String nc = c.getNodeCode();
|
if (ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER.equals(nc)
|
&& !Boolean.TRUE.equals(order.getHolidayFlag())) {
|
continue;
|
}
|
if (ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER.equals(nc)) {
|
if (!Boolean.TRUE.equals(order.getInvolveOtherLocalUnit()) || localUnitIds.isEmpty()) {
|
continue;
|
}
|
}
|
chain.add(nc);
|
}
|
return chain;
|
}
|
|
private int createTasksForLocalUnitNode(Long instanceId, AppointmentOrder order, String initialStatus) {
|
List<LocalUnitApprovalGroup> groups = resolveLocalUnitApprovalGroups(order, false);
|
int total = 0;
|
for (LocalUnitApprovalGroup group : groups) {
|
total +=
|
createTasksWithGroupKey(
|
instanceId,
|
ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER,
|
buildLocalUnitGroupKey(group.unitId()),
|
group.assigneeIds(),
|
initialStatus);
|
}
|
return total;
|
}
|
|
private int createTasksForNodeStrict(
|
ApprovalInstance inst, AppointmentOrder order, String nodeCode, String initialStatus) {
|
List<Long> assignees = resolveAssignees(nodeCode, order);
|
int created = createTasksWithGroupKey(inst.getId(), nodeCode, nodeCode, assignees, initialStatus);
|
if (created <= 0) {
|
throw new BizException(
|
BizErrorCode.CONFIG_NOT_FOUND,
|
"节点无审批人: " + resolveNodeName(nodeCode));
|
}
|
return created;
|
}
|
|
private int createTasksForLocalUnitNodeStrict(
|
Long instanceId, AppointmentOrder order, String initialStatus) {
|
List<Long> localUnitIds = parseLongJsonArray(order.getPassLocalUnitIds());
|
if (!Boolean.TRUE.equals(order.getInvolveOtherLocalUnit()) || localUnitIds.isEmpty()) {
|
throw new BizException(
|
BizErrorCode.CONFIG_NOT_FOUND,
|
"节点无审批人: " + resolveNodeName(ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER));
|
}
|
|
List<LocalUnitApprovalGroup> groups = resolveLocalUnitApprovalGroups(order, true);
|
int total = 0;
|
for (LocalUnitApprovalGroup group : groups) {
|
total +=
|
createTasksWithGroupKey(
|
instanceId,
|
ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER,
|
buildLocalUnitGroupKey(group.unitId()),
|
group.assigneeIds(),
|
initialStatus);
|
}
|
if (total <= 0) {
|
throw new BizException(
|
BizErrorCode.CONFIG_NOT_FOUND,
|
"节点无审批人: " + resolveNodeName(ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER));
|
}
|
return total;
|
}
|
|
private List<LocalUnitApprovalGroup> resolveLocalUnitApprovalGroups(
|
AppointmentOrder order, boolean strict) {
|
List<Long> localUnitIds = parseLongJsonArray(order.getPassLocalUnitIds());
|
if (localUnitIds.isEmpty()) {
|
return List.of();
|
}
|
List<MpPassLocalUnit> units =
|
mpPassLocalUnitMapper.selectList(
|
new LambdaQueryWrapper<MpPassLocalUnit>()
|
.eq(MpPassLocalUnit::getDelFlag, 0)
|
.in(MpPassLocalUnit::getId, localUnitIds));
|
Map<Long, MpPassLocalUnit> unitMap =
|
units.stream()
|
.collect(
|
java.util.stream.Collectors.toMap(
|
MpPassLocalUnit::getId, x -> x, (a, b) -> a));
|
if (strict && unitMap.size() != localUnitIds.size()) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位配置缺失，无法生成审批人");
|
}
|
|
List<LocalUnitApprovalGroup> groups = new ArrayList<>();
|
for (Long unitId : localUnitIds) {
|
MpPassLocalUnit unit = unitMap.get(unitId);
|
if (unit == null) {
|
if (strict) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位配置缺失，无法生成审批人");
|
}
|
continue;
|
}
|
List<Long> assignees = resolveLocalUnitAssignees(unitId, unit, strict);
|
if (assignees.isEmpty()) {
|
continue;
|
}
|
groups.add(new LocalUnitApprovalGroup(unitId, assignees));
|
}
|
return groups;
|
}
|
|
private List<Long> resolveLocalUnitAssignees(Long unitId, MpPassLocalUnit unit, boolean strict) {
|
Integer approverType = unit.getApproverType();
|
if (approverType == null) {
|
if (strict) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位审批类型缺失: " + unitId);
|
}
|
return List.of();
|
}
|
if (approverType == LocalUnitApproverType.DEPT) {
|
List<Long> deptIds = parseLongJsonArray(unit.getApproverDeptIds());
|
if (deptIds.isEmpty()) {
|
if (strict) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位审批部门未配置: " + unitId);
|
}
|
return List.of();
|
}
|
LinkedHashSet<Long> assignees = new LinkedHashSet<>();
|
for (Long deptId : deptIds) {
|
List<Long> deptApprovers = listAllActiveEmployeeIdsByDept(deptId);
|
if (strict && deptApprovers.isEmpty()) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "审批部门无可用审批人: " + deptId);
|
}
|
assignees.addAll(deptApprovers);
|
}
|
return assignees.stream().toList();
|
}
|
if (approverType == LocalUnitApproverType.STAFF_GROUP) {
|
Long groupId = unit.getApproverGroupId();
|
if (groupId == null || groupId <= 0) {
|
if (strict) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位审批分组未配置: " + unitId);
|
}
|
return List.of();
|
}
|
List<MpStaffGroupMember> members =
|
mpStaffGroupMemberMapper.selectList(
|
new LambdaQueryWrapper<MpStaffGroupMember>()
|
.eq(MpStaffGroupMember::getDelFlag, 0)
|
.eq(MpStaffGroupMember::getGroupId, groupId)
|
.orderByAsc(MpStaffGroupMember::getId));
|
LinkedHashSet<Long> mids = new LinkedHashSet<>();
|
for (MpStaffGroupMember member : members) {
|
if (member.getMpUserId() != null && member.getMpUserId() > 0) {
|
mids.add(member.getMpUserId());
|
}
|
}
|
List<Long> assignees = filterActiveEmployeeIds(mids.stream().toList());
|
if (strict && assignees.isEmpty()) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "审批分组无有效成员: " + groupId);
|
}
|
return assignees;
|
}
|
if (approverType == LocalUnitApproverType.STAFF) {
|
List<MpPassLocalUnitMember> members =
|
mpPassLocalUnitMemberMapper.selectList(
|
new LambdaQueryWrapper<MpPassLocalUnitMember>()
|
.eq(MpPassLocalUnitMember::getDelFlag, 0)
|
.eq(MpPassLocalUnitMember::getUnitId, unitId)
|
.orderByAsc(MpPassLocalUnitMember::getId));
|
LinkedHashSet<Long> mids = new LinkedHashSet<>();
|
for (MpPassLocalUnitMember member : members) {
|
if (member.getMpUserId() != null && member.getMpUserId() > 0) {
|
mids.add(member.getMpUserId());
|
}
|
}
|
List<Long> assignees = filterActiveEmployeeIds(mids.stream().toList());
|
if (strict && assignees.isEmpty()) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位审批人员未配置: " + unitId);
|
}
|
return assignees;
|
}
|
if (strict) {
|
throw new BizException(BizErrorCode.CONFIG_NOT_FOUND, "属地单位审批类型无效: " + unitId);
|
}
|
return List.of();
|
}
|
|
private String buildLocalUnitGroupKey(Long unitId) {
|
return ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER + LOCAL_UNIT_GROUP_TOKEN + unitId;
|
}
|
|
private String resolveNodeName(String nodeCode) {
|
if (!StringUtils.hasText(nodeCode)) {
|
return "未知节点";
|
}
|
return switch (nodeCode) {
|
case ApprovalNodeCode.LEVEL1_HANDLER -> "经办人（一级）";
|
case ApprovalNodeCode.LEVEL2_DEPT_LEADER -> "部门负责人（二级）";
|
case ApprovalNodeCode.LEVEL3_LOCAL_DEPT_LEADER -> "属地管理部门领导（三级）";
|
case ApprovalNodeCode.LEVEL4_VISIT_DEPT -> "访客主管部门（四级）";
|
case ApprovalNodeCode.LEVEL5_VISIT_DEPT_LEADER -> "访客主管部门领导（五级）";
|
default -> nodeCode;
|
};
|
}
|
|
private int createTasksWithGroupKey(
|
Long instanceId, String nodeCode, String groupKey, List<Long> assignees, String initialStatus) {
|
Set<Long> unique = new LinkedHashSet<>(assignees == null ? List.of() : assignees);
|
unique.removeIf(x -> x == null || x <= 0);
|
if (unique.isEmpty()) {
|
return 0;
|
}
|
for (Long uid : unique) {
|
ApprovalTask t = new ApprovalTask();
|
t.setInstanceId(instanceId);
|
t.setNodeCode(nodeCode);
|
t.setGroupKey(groupKey);
|
t.setAssigneeUserId(uid);
|
t.setTaskStatus(initialStatus);
|
approvalTaskMapper.insert(t);
|
}
|
return unique.size();
|
}
|
|
private void autoApproveCurrentNodeByHistory(Long instanceId, String nodeCode) {
|
List<ApprovalTask> approvedHistory =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, instanceId)
|
.eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.APPROVED)
|
.ne(ApprovalTask::getNodeCode, nodeCode));
|
if (approvedHistory.isEmpty()) {
|
return;
|
}
|
Set<Long> approvedAssigneeIds = new LinkedHashSet<>();
|
for (ApprovalTask t : approvedHistory) {
|
if (t.getAssigneeUserId() != null) {
|
approvedAssigneeIds.add(t.getAssigneeUserId());
|
}
|
}
|
if (approvedAssigneeIds.isEmpty()) {
|
return;
|
}
|
List<ApprovalTask> pending =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getInstanceId, instanceId)
|
.eq(ApprovalTask::getNodeCode, nodeCode)
|
.eq(ApprovalTask::getTaskStatus, ApprovalTaskStatus.PENDING)
|
.orderByAsc(ApprovalTask::getId));
|
Set<String> handledGroupKeys = new LinkedHashSet<>();
|
for (ApprovalTask task : pending) {
|
if (!approvedAssigneeIds.contains(task.getAssigneeUserId())) {
|
continue;
|
}
|
String groupKey = StringUtils.hasText(task.getGroupKey()) ? task.getGroupKey() : ("TASK:" + task.getId());
|
if (!handledGroupKeys.add(groupKey)) {
|
continue;
|
}
|
ApprovalTask latest = approvalTaskMapper.selectById(task.getId());
|
if (latest == null || !ApprovalTaskStatus.PENDING.equals(latest.getTaskStatus())) {
|
continue;
|
}
|
latest.setTaskStatus(ApprovalTaskStatus.APPROVED);
|
if (!StringUtils.hasText(latest.getComment())) {
|
latest.setComment(AUTO_APPROVE_COMMENT);
|
}
|
approvalTaskMapper.updateById(latest);
|
markGroupSkippedExcept(latest);
|
}
|
}
|
|
private List<Long> parseLongJsonArray(String raw) {
|
if (!StringUtils.hasText(raw)) {
|
return List.of();
|
}
|
try {
|
List<Long> list = objectMapper.readValue(raw, LONG_LIST_TYPE);
|
if (list == null || list.isEmpty()) {
|
return List.of();
|
}
|
LinkedHashSet<Long> set = new LinkedHashSet<>();
|
for (Long id : list) {
|
if (id != null && id > 0) {
|
set.add(id);
|
}
|
}
|
return set.stream().toList();
|
} catch (Exception ex) {
|
return List.of();
|
}
|
}
|
|
private List<Long> filterActiveEmployeeIds(List<Long> ids) {
|
if (ids == null || ids.isEmpty()) {
|
return List.of();
|
}
|
List<MpUser> users =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.eq(MpUser::getStatus, 1)
|
.eq(MpUser::getUserType, MiniUserType.EMPLOYEE)
|
.in(MpUser::getId, ids));
|
Map<Long, MpUser> userMap =
|
users.stream().collect(java.util.stream.Collectors.toMap(MpUser::getId, x -> x, (a, b) -> a));
|
List<Long> out = new ArrayList<>();
|
for (Long id : ids) {
|
if (userMap.containsKey(id)) {
|
out.add(id);
|
}
|
}
|
return out;
|
}
|
|
private record LocalUnitApprovalGroup(Long unitId, List<Long> assigneeIds) {}
|
}
|
