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.config.MiniStpUtil;
|
import com.sinata.appointment.constants.AppointmentBizConstants;
|
import com.sinata.appointment.constants.AppointmentOrderStatus;
|
import com.sinata.appointment.constants.ApprovalNodeCode;
|
import com.sinata.appointment.constants.ApprovalTaskStatus;
|
import com.sinata.appointment.constants.BizErrorCode;
|
import com.sinata.appointment.dto.ApprovalFlowNodeVo;
|
import com.sinata.appointment.dto.MiniApprovalDetailVisitorVo;
|
import com.sinata.appointment.dto.MiniApprovalDetailVo;
|
import com.sinata.appointment.dto.MiniLocalUnitVo;
|
import com.sinata.appointment.dto.MiniVisitedUserVo;
|
import com.sinata.appointment.entity.AppointmentOrder;
|
import com.sinata.appointment.entity.AppointmentVehicle;
|
import com.sinata.appointment.entity.AppointmentVisitor;
|
import com.sinata.appointment.entity.ApprovalInstance;
|
import com.sinata.appointment.entity.ApprovalTask;
|
import com.sinata.appointment.entity.BizVisitReason;
|
import com.sinata.appointment.entity.MpPassLocalUnit;
|
import com.sinata.appointment.entity.MpVisitor;
|
import com.sinata.appointment.entity.MpUser;
|
import com.sinata.appointment.entity.SysDept;
|
import com.sinata.appointment.exception.BizException;
|
import com.sinata.appointment.mapper.AppointmentOrderMapper;
|
import com.sinata.appointment.mapper.AppointmentVehicleMapper;
|
import com.sinata.appointment.mapper.AppointmentVisitorMapper;
|
import com.sinata.appointment.mapper.ApprovalInstanceMapper;
|
import com.sinata.appointment.mapper.ApprovalTaskMapper;
|
import com.sinata.appointment.mapper.BizVisitReasonMapper;
|
import com.sinata.appointment.mapper.MpPassLocalUnitMapper;
|
import com.sinata.appointment.mapper.MpVisitorMapper;
|
import com.sinata.appointment.mapper.MpUserMapper;
|
import com.sinata.appointment.mapper.SysDeptMapper;
|
import com.sinata.appointment.util.MobileMaskUtil;
|
import com.sinata.appointment.util.SensitiveDataUtil;
|
import com.sinata.appointment.util.UuidAssert;
|
import java.time.LocalDate;
|
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 MiniApprovalDetailApplicationService {
|
|
private static final String PAGE_MODE_HANDLER_PENDING = "HANDLER_PENDING";
|
private static final String PAGE_MODE_GENERAL_PENDING = "GENERAL_PENDING";
|
private static final String PAGE_MODE_GENERAL_READONLY = "GENERAL_READONLY";
|
private static final TypeReference<List<Long>> LONG_LIST_TYPE = new TypeReference<>() {};
|
private static final TypeReference<List<String>> STRING_LIST_TYPE = new TypeReference<>() {};
|
|
private final ApprovalTaskMapper approvalTaskMapper;
|
private final ApprovalInstanceMapper approvalInstanceMapper;
|
private final AppointmentOrderMapper appointmentOrderMapper;
|
private final AppointmentVisitorMapper appointmentVisitorMapper;
|
private final AppointmentVehicleMapper appointmentVehicleMapper;
|
private final MpVisitorMapper mpVisitorMapper;
|
private final MpUserMapper mpUserMapper;
|
private final SysDeptMapper sysDeptMapper;
|
private final BizVisitReasonMapper bizVisitReasonMapper;
|
private final MpPassLocalUnitMapper mpPassLocalUnitMapper;
|
private final ApprovalFlowViewApplicationService approvalFlowViewApplicationService;
|
private final ObjectMapper objectMapper;
|
|
public MiniApprovalDetailVo detail(Long taskId, String taskUuid, Long orderId, String orderUuid) {
|
long uid = MiniStpUtil.getLoginIdAsLong();
|
ApprovalTask task = null;
|
if (taskId != null && taskId > 0) {
|
task = approvalTaskMapper.selectById(taskId);
|
if (task == null || (task.getDelFlag() != null && task.getDelFlag() == 1)) {
|
throw new BizException(BizErrorCode.APPROVAL_TASK_NOT_FOUND, "审批任务不存在");
|
}
|
UuidAssert.match(task, taskUuid);
|
}
|
|
ApprovalInstance instance = loadInstance(task, orderId);
|
AppointmentOrder order = loadOrder(instance, orderId, orderUuid);
|
ApprovalTask currentUserTask = resolveCurrentUserTask(task, uid, instance, order);
|
|
if (currentUserTask == null && !Objects.equals(order.getVisitedUserId(), uid)) {
|
throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "无权查看该审批详情");
|
}
|
|
MiniApprovalDetailVo vo = new MiniApprovalDetailVo();
|
vo.setTaskId(currentUserTask == null ? null : currentUserTask.getId());
|
vo.setTaskUuid(currentUserTask == null ? null : currentUserTask.getUuid());
|
vo.setOrderId(order.getId());
|
vo.setOrderUuid(order.getUuid());
|
vo.setOrderNo(order.getOrderNo());
|
MpUser submitter = loadSubmitter(order.getSubmitterId());
|
vo.setSubmitterName(resolveSubmitterName(submitter, order.getSubmitterId()));
|
vo.setSubmitTime(order.getCreateTime());
|
vo.setTaskStatus(currentUserTask == null ? null : currentUserTask.getTaskStatus());
|
vo.setNodeCode(currentUserTask == null ? null : currentUserTask.getNodeCode());
|
vo.setNodeName(resolveNodeName(currentUserTask == null ? null : currentUserTask.getNodeCode()));
|
fillMode(vo, uid, order, currentUserTask);
|
|
vo.setVisitedUserId(order.getVisitedUserId());
|
vo.setVisitedUserName(order.getVisitedUserName());
|
vo.setVisitedDeptName(loadDeptName(order.getVisitedDeptId()));
|
vo.setAccessAreaText(joinNames(parseStringList(order.getPassAccessAreaNames())));
|
vo.setVisitTypeText(buildVisitTypeText(order));
|
vo.setVisitReasonText(buildVisitReasonText(order));
|
vo.setVisitReasonOther(order.getVisitReasonOther());
|
vo.setVisitTimeText(buildVisitTimeText(order));
|
vo.setPassAccessAreaIds(parseLongList(order.getPassAccessAreaIds()));
|
vo.setPassAccessAreaNames(parseStringList(order.getPassAccessAreaNames()));
|
vo.setInvolveOtherLocalUnit(Boolean.TRUE.equals(order.getInvolveOtherLocalUnit()));
|
vo.setLocalUnits(loadLocalUnits(parseLongList(order.getPassLocalUnitIds())));
|
vo.setNoticeUsers(loadNoticeUsers(parseCommaSeparatedIds(currentUserTask == null ? null : currentUserTask.getNoticeIds())));
|
vo.setVisitors(loadVisitors(order.getId()));
|
List<ApprovalFlowNodeVo> flowTree = approvalFlowViewApplicationService.treeByOrderId(order.getId());
|
vo.setFlowTree(flowTree == null ? List.of() : flowTree);
|
return vo;
|
}
|
|
private void fillMode(
|
MiniApprovalDetailVo vo, long uid, AppointmentOrder order, ApprovalTask currentUserTask) {
|
boolean canApprove =
|
currentUserTask != null
|
&& ApprovalTaskStatus.PENDING.equals(currentUserTask.getTaskStatus())
|
&& Objects.equals(currentUserTask.getAssigneeUserId(), uid);
|
vo.setCanApprove(canApprove);
|
if (canApprove
|
&& Objects.equals(order.getVisitedUserId(), uid)
|
&& ApprovalNodeCode.LEVEL1_HANDLER.equals(currentUserTask.getNodeCode())) {
|
vo.setPageMode(PAGE_MODE_HANDLER_PENDING);
|
vo.setApprovalStatusText("待审批");
|
return;
|
}
|
if (canApprove) {
|
vo.setPageMode(PAGE_MODE_GENERAL_PENDING);
|
vo.setApprovalStatusText("待审批");
|
return;
|
}
|
vo.setPageMode(PAGE_MODE_GENERAL_READONLY);
|
if (currentUserTask == null) {
|
vo.setApprovalStatusText("已查看");
|
return;
|
}
|
if (AppointmentOrderStatus.CANCELLED.equals(order.getStatus())) {
|
vo.setApprovalStatusText("已取消");
|
return;
|
}
|
if (ApprovalTaskStatus.APPROVED.equals(currentUserTask.getTaskStatus())) {
|
vo.setApprovalStatusText("已同意");
|
return;
|
}
|
if (ApprovalTaskStatus.REJECTED.equals(currentUserTask.getTaskStatus())) {
|
vo.setApprovalStatusText("已拒绝");
|
return;
|
}
|
if (ApprovalTaskStatus.CANCELLED.equals(currentUserTask.getTaskStatus())) {
|
vo.setApprovalStatusText("已取消");
|
return;
|
}
|
vo.setApprovalStatusText("待审批");
|
}
|
|
private ApprovalInstance loadInstance(ApprovalTask task, Long orderId) {
|
if (task != null) {
|
ApprovalInstance instance = approvalInstanceMapper.selectById(task.getInstanceId());
|
if (instance == null || (instance.getDelFlag() != null && instance.getDelFlag() == 1)) {
|
throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "审批实例不存在");
|
}
|
return instance;
|
}
|
if (orderId == null || orderId <= 0) {
|
throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
|
}
|
List<ApprovalInstance> rows =
|
approvalInstanceMapper.selectList(
|
new LambdaQueryWrapper<ApprovalInstance>()
|
.eq(ApprovalInstance::getDelFlag, 0)
|
.eq(ApprovalInstance::getOrderId, orderId)
|
.orderByDesc(ApprovalInstance::getId)
|
.last("limit 1"));
|
if (rows.isEmpty()) {
|
throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "审批实例不存在");
|
}
|
return rows.get(0);
|
}
|
|
private AppointmentOrder loadOrder(ApprovalInstance instance, Long orderId, String orderUuid) {
|
Long targetOrderId = instance != null ? instance.getOrderId() : orderId;
|
AppointmentOrder order = appointmentOrderMapper.selectById(targetOrderId);
|
if (order == null || (order.getDelFlag() != null && order.getDelFlag() == 1)) {
|
throw new BizException(BizErrorCode.ORDER_NOT_FOUND, "预约单不存在");
|
}
|
if (orderId != null && orderId > 0) {
|
UuidAssert.match(order, orderUuid);
|
}
|
return order;
|
}
|
|
private ApprovalTask resolveCurrentUserTask(
|
ApprovalTask task, long uid, ApprovalInstance instance, AppointmentOrder order) {
|
if (task != null) {
|
if (!Objects.equals(task.getAssigneeUserId(), uid)) {
|
throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "无权查看该审批任务");
|
}
|
return task;
|
}
|
List<ApprovalTask> rows =
|
approvalTaskMapper.selectList(
|
new LambdaQueryWrapper<ApprovalTask>()
|
.eq(ApprovalTask::getDelFlag, 0)
|
.eq(ApprovalTask::getInstanceId, instance.getId())
|
.eq(ApprovalTask::getAssigneeUserId, uid)
|
.orderByDesc(ApprovalTask::getUpdateTime)
|
.orderByDesc(ApprovalTask::getId));
|
return rows.isEmpty() ? null : rows.get(0);
|
}
|
|
private List<MiniApprovalDetailVisitorVo> loadVisitors(Long orderId) {
|
List<AppointmentVisitor> rows =
|
appointmentVisitorMapper.selectList(
|
new LambdaQueryWrapper<AppointmentVisitor>()
|
.eq(AppointmentVisitor::getDelFlag, 0)
|
.eq(AppointmentVisitor::getOrderId, orderId)
|
.orderByAsc(AppointmentVisitor::getId));
|
if (rows.isEmpty()) {
|
return List.of();
|
}
|
List<Long> visitorIds =
|
rows.stream()
|
.map(AppointmentVisitor::getMpVisitorId)
|
.filter(Objects::nonNull)
|
.toList();
|
Map<Long, MpVisitor> visitorMap = loadVisitorMap(visitorIds);
|
Map<Long, String> plateMap = loadVisitorPlateMap(orderId);
|
List<MiniApprovalDetailVisitorVo> result = new ArrayList<>();
|
for (AppointmentVisitor row : rows) {
|
MpVisitor visitor = visitorMap.get(row.getMpVisitorId());
|
MiniApprovalDetailVisitorVo vo = new MiniApprovalDetailVisitorVo();
|
vo.setVisitorId(row.getMpVisitorId());
|
vo.setName(firstNonBlank(row.getName(), visitor == null ? null : visitor.getVisitorName(), "-"));
|
vo.setGender(visitor == null ? null : visitor.getGender());
|
vo.setCompanyName(visitor == null ? null : visitor.getVisitorCompany());
|
vo.setMobileMasked(
|
firstNonBlank(
|
row.getMobile(),
|
visitor == null ? null : visitor.getVisitorMobile(),
|
null));
|
String idCardPlain =
|
StringUtils.hasText(row.getIdCardCipher())
|
? SensitiveDataUtil.decryptIdCard(row.getIdCardCipher())
|
: (visitor != null && StringUtils.hasText(visitor.getIdCardCipher())
|
? SensitiveDataUtil.decryptIdCard(visitor.getIdCardCipher())
|
: null);
|
vo.setIdCardMasked(
|
StringUtils.hasText(idCardPlain)
|
? SensitiveDataUtil.maskIdCard(idCardPlain)
|
: null);
|
vo.setPlateNo(plateMap.get(row.getMpVisitorId()));
|
result.add(vo);
|
}
|
return result;
|
}
|
|
private Map<Long, MpVisitor> loadVisitorMap(List<Long> visitorIds) {
|
if (visitorIds.isEmpty()) {
|
return Map.of();
|
}
|
List<MpVisitor> rows =
|
mpVisitorMapper.selectList(
|
new LambdaQueryWrapper<MpVisitor>()
|
.eq(MpVisitor::getDelFlag, 0)
|
.in(MpVisitor::getId, visitorIds));
|
return rows.stream().collect(Collectors.toMap(MpVisitor::getId, x -> x, (a, b) -> a));
|
}
|
|
private Map<Long, String> loadVisitorPlateMap(Long orderId) {
|
List<AppointmentVehicle> rows =
|
appointmentVehicleMapper.selectList(
|
new LambdaQueryWrapper<AppointmentVehicle>()
|
.eq(AppointmentVehicle::getDelFlag, 0)
|
.eq(AppointmentVehicle::getOrderId, orderId)
|
.orderByAsc(AppointmentVehicle::getId));
|
if (rows.isEmpty()) {
|
return Map.of();
|
}
|
Map<Long, List<String>> plates = new LinkedHashMap<>();
|
for (AppointmentVehicle row : rows) {
|
if (row.getDriverVisitorId() == null) {
|
continue;
|
}
|
plates.computeIfAbsent(row.getDriverVisitorId(), k -> new ArrayList<>());
|
if (StringUtils.hasText(row.getPlateNo())) {
|
plates.get(row.getDriverVisitorId()).add(row.getPlateNo().trim());
|
}
|
}
|
Map<Long, String> out = new LinkedHashMap<>();
|
for (Map.Entry<Long, List<String>> entry : plates.entrySet()) {
|
out.put(entry.getKey(), String.join("、", entry.getValue()));
|
}
|
return out;
|
}
|
|
private List<MiniLocalUnitVo> loadLocalUnits(List<Long> unitIds) {
|
if (unitIds.isEmpty()) {
|
return List.of();
|
}
|
List<MpPassLocalUnit> rows =
|
mpPassLocalUnitMapper.selectList(
|
new LambdaQueryWrapper<MpPassLocalUnit>()
|
.eq(MpPassLocalUnit::getDelFlag, 0)
|
.in(MpPassLocalUnit::getId, unitIds));
|
Map<Long, String> nameMap =
|
rows.stream()
|
.collect(Collectors.toMap(MpPassLocalUnit::getId, MpPassLocalUnit::getUnitName, (a, b) -> a));
|
List<MiniLocalUnitVo> result = new ArrayList<>();
|
for (Long unitId : unitIds) {
|
String name = nameMap.get(unitId);
|
if (!StringUtils.hasText(name)) {
|
continue;
|
}
|
MiniLocalUnitVo vo = new MiniLocalUnitVo();
|
vo.setId(unitId);
|
vo.setUnitName(name);
|
result.add(vo);
|
}
|
return result;
|
}
|
|
private List<MiniVisitedUserVo> loadNoticeUsers(List<Long> noticeIds) {
|
if (noticeIds.isEmpty()) {
|
return List.of();
|
}
|
List<MpUser> users =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.in(MpUser::getId, noticeIds));
|
if (users.isEmpty()) {
|
return List.of();
|
}
|
Map<Long, MpUser> userMap =
|
users.stream().collect(Collectors.toMap(MpUser::getId, x -> x, (a, b) -> a, LinkedHashMap::new));
|
List<Long> deptIds =
|
users.stream().map(MpUser::getDeptId).filter(id -> id != null && id > 0).distinct().toList();
|
Map<Long, String> deptNameMap = new LinkedHashMap<>();
|
if (!deptIds.isEmpty()) {
|
deptNameMap =
|
sysDeptMapper.selectList(
|
new LambdaQueryWrapper<SysDept>()
|
.eq(SysDept::getDelFlag, 0)
|
.in(SysDept::getId, deptIds))
|
.stream()
|
.collect(Collectors.toMap(SysDept::getId, SysDept::getDeptName, (a, b) -> a, LinkedHashMap::new));
|
}
|
List<MiniVisitedUserVo> result = new ArrayList<>();
|
for (Long noticeId : noticeIds) {
|
MpUser user = userMap.get(noticeId);
|
if (user == null) {
|
continue;
|
}
|
MiniVisitedUserVo vo = new MiniVisitedUserVo();
|
vo.setId(user.getId());
|
vo.setRealName(trimToNull(user.getNickName()));
|
vo.setDeptName(user.getDeptId() == null ? null : deptNameMap.get(user.getDeptId()));
|
result.add(vo);
|
}
|
return result;
|
}
|
|
private String buildVisitTypeText(AppointmentOrder order) {
|
boolean personEntry = order.getPersonEntryFlag() == null || Boolean.TRUE.equals(order.getPersonEntryFlag());
|
boolean vehicleEntry = Boolean.TRUE.equals(order.getVehicleEntryFlag());
|
if (personEntry && vehicleEntry) {
|
return "访客+车辆预约";
|
}
|
if (vehicleEntry) {
|
return "车辆预约";
|
}
|
return "访客预约";
|
}
|
|
private String buildVisitReasonText(AppointmentOrder order) {
|
String code = trimToNull(order.getVisitReasonCode());
|
if (!StringUtils.hasText(code)) {
|
return "-";
|
}
|
if (AppointmentBizConstants.VISIT_REASON_OTHER.equalsIgnoreCase(code)) {
|
return "其他";
|
}
|
List<BizVisitReason> rows =
|
bizVisitReasonMapper.selectList(
|
new LambdaQueryWrapper<BizVisitReason>()
|
.eq(BizVisitReason::getDelFlag, 0)
|
.eq(BizVisitReason::getReasonCode, code)
|
.last("limit 1"));
|
return rows.isEmpty() || !StringUtils.hasText(rows.get(0).getReasonName())
|
? code
|
: rows.get(0).getReasonName();
|
}
|
|
private String buildVisitTimeText(AppointmentOrder order) {
|
if (AppointmentBizConstants.TIME_MODE_SINGLE.equals(order.getVisitTimeMode())) {
|
String slotLabel =
|
switch (trimToNull(order.getVisitTimeSlot())) {
|
case AppointmentBizConstants.TIME_SLOT_ALL_DAY -> "00:00-23:59";
|
case AppointmentBizConstants.TIME_SLOT_AM -> "00:00-11:59";
|
case AppointmentBizConstants.TIME_SLOT_PM -> "12:00-23:59";
|
default -> "";
|
};
|
if (order.getVisitStartDate() == null) {
|
return slotLabel;
|
}
|
return StringUtils.hasText(slotLabel)
|
? order.getVisitStartDate() + " " + slotLabel
|
: order.getVisitStartDate().toString();
|
}
|
if (order.getVisitStartDate() == null && order.getVisitEndDate() == null) {
|
return "-";
|
}
|
if (Objects.equals(order.getVisitStartDate(), order.getVisitEndDate()) || order.getVisitEndDate() == null) {
|
return String.valueOf(order.getVisitStartDate());
|
}
|
return order.getVisitStartDate() + " 至 " + order.getVisitEndDate();
|
}
|
|
private String loadDeptName(Long deptId) {
|
if (deptId == null || deptId <= 0) {
|
return null;
|
}
|
SysDept dept = sysDeptMapper.selectById(deptId);
|
return dept == null ? null : dept.getDeptName();
|
}
|
|
private String resolveNodeName(String nodeCode) {
|
if (!StringUtils.hasText(nodeCode)) {
|
return null;
|
}
|
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 MpUser loadSubmitter(Long submitterId) {
|
if (submitterId == null) {
|
return null;
|
}
|
List<MpUser> users =
|
mpUserMapper.selectList(
|
new LambdaQueryWrapper<MpUser>()
|
.eq(MpUser::getDelFlag, 0)
|
.eq(MpUser::getId, submitterId)
|
.last("limit 1"));
|
return users.isEmpty() ? null : users.get(0);
|
}
|
|
private String resolveSubmitterName(MpUser submitter, Long submitterId) {
|
if (submitter != null) {
|
String name = trimToNull(submitter.getNickName());
|
if (StringUtils.hasText(name)) {
|
return name;
|
}
|
String mobile = trimToNull(submitter.getMobile());
|
if (StringUtils.hasText(mobile)) {
|
return mobile;
|
}
|
}
|
return submitterId == null ? "发起人" : "用户" + submitterId;
|
}
|
|
private List<Long> parseLongList(String json) {
|
if (!StringUtils.hasText(json)) {
|
return List.of();
|
}
|
try {
|
List<Long> rows = objectMapper.readValue(json, LONG_LIST_TYPE);
|
if (rows == null) {
|
return List.of();
|
}
|
return rows.stream()
|
.filter(Objects::nonNull)
|
.filter(id -> id > 0)
|
.collect(Collectors.toCollection(ArrayList::new));
|
} catch (Exception ex) {
|
return List.of();
|
}
|
}
|
|
private List<Long> parseCommaSeparatedIds(String raw) {
|
if (!StringUtils.hasText(raw)) {
|
return List.of();
|
}
|
Set<Long> result = new LinkedHashSet<>();
|
String[] parts = raw.split(",");
|
for (String part : parts) {
|
if (!StringUtils.hasText(part)) {
|
continue;
|
}
|
try {
|
long id = Long.parseLong(part.trim());
|
if (id > 0) {
|
result.add(id);
|
}
|
} catch (NumberFormatException ignored) {
|
}
|
}
|
return new ArrayList<>(result);
|
}
|
|
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();
|
}
|
return rows.stream().filter(StringUtils::hasText).map(String::trim).toList();
|
} catch (Exception ex) {
|
return List.of();
|
}
|
}
|
|
private String joinNames(List<String> names) {
|
if (names == null || names.isEmpty()) {
|
return null;
|
}
|
return names.stream()
|
.filter(StringUtils::hasText)
|
.map(String::trim)
|
.collect(Collectors.joining("、"));
|
}
|
|
private String firstNonBlank(String... values) {
|
if (values == null) {
|
return null;
|
}
|
for (String value : values) {
|
if (StringUtils.hasText(value)) {
|
return value.trim();
|
}
|
}
|
return null;
|
}
|
|
private String trimToNull(String value) {
|
if (!StringUtils.hasText(value)) {
|
return null;
|
}
|
return value.trim();
|
}
|
}
|
