package com.sinata.appointment.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.sinata.appointment.dto.OpLogListVo;
|
import com.sinata.appointment.entity.BizOpLog;
|
import com.sinata.appointment.entity.MpUser;
|
import com.sinata.appointment.entity.SysUser;
|
import com.sinata.appointment.mapper.BizOpLogMapper;
|
import com.sinata.appointment.mapper.MpUserMapper;
|
import com.sinata.appointment.mapper.SysUserMapper;
|
import java.time.LocalDateTime;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
import lombok.RequiredArgsConstructor;
|
import org.slf4j.MDC;
|
import org.springframework.scheduling.annotation.Async;
|
import org.springframework.util.StringUtils;
|
import org.springframework.stereotype.Service;
|
|
@Service
|
@RequiredArgsConstructor
|
public class OpLogApplicationService {
|
|
public static final String MDC_TRACE = "traceId";
|
public static final String SOURCE_ADMIN = "ADMIN";
|
public static final String SOURCE_MINI_EMPLOYEE = "MINI_EMPLOYEE";
|
|
private final BizOpLogMapper bizOpLogMapper;
|
private final SysUserMapper sysUserMapper;
|
private final MpUserMapper mpUserMapper;
|
|
public IPage<OpLogListVo> page(long page, long size, String sourceType) {
|
Page<BizOpLog> pager = new Page<>(page, size);
|
LambdaQueryWrapper<BizOpLog> query =
|
new LambdaQueryWrapper<BizOpLog>()
|
.eq(BizOpLog::getDelFlag, 0)
|
.orderByDesc(BizOpLog::getOpTime)
|
.orderByDesc(BizOpLog::getId);
|
String normalizedSourceType = normalizeSourceType(sourceType);
|
if (normalizedSourceType != null) {
|
query.eq(BizOpLog::getSourceType, normalizedSourceType);
|
}
|
IPage<BizOpLog> logPage = bizOpLogMapper.selectPage(pager, query);
|
Page<OpLogListVo> result =
|
new Page<>(logPage.getCurrent(), logPage.getSize(), logPage.getTotal());
|
List<BizOpLog> records = logPage.getRecords();
|
result.setRecords(toListVos(records));
|
return result;
|
}
|
|
@Async("applicationTaskExecutor")
|
public void recordAsync(
|
String sourceType,
|
Long operatorUserId,
|
String module,
|
String action,
|
String resourceType,
|
String resourceId,
|
String detailJson) {
|
String normalizedSourceType = normalizeSourceType(sourceType);
|
if (!StringUtils.hasText(normalizedSourceType)) {
|
return;
|
}
|
if (SOURCE_MINI_EMPLOYEE.equals(normalizedSourceType) && !isEmployee(operatorUserId)) {
|
return;
|
}
|
BizOpLog log = new BizOpLog();
|
log.setSourceType(normalizedSourceType);
|
log.setOperatorUserId(operatorUserId);
|
log.setModule(module);
|
log.setAction(action);
|
log.setResourceType(resourceType);
|
log.setResourceId(resourceId);
|
log.setDetailJson(detailJson);
|
log.setOpTime(LocalDateTime.now());
|
log.setTraceId(MDC.get(MDC_TRACE));
|
bizOpLogMapper.insert(log);
|
}
|
|
private List<OpLogListVo> toListVos(List<BizOpLog> records) {
|
if (records == null || records.isEmpty()) {
|
return List.of();
|
}
|
List<Long> adminUserIds =
|
records.stream()
|
.filter(item -> SOURCE_ADMIN.equals(item.getSourceType()))
|
.map(BizOpLog::getOperatorUserId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.toList();
|
List<Long> mpUserIds =
|
records.stream()
|
.filter(item -> SOURCE_MINI_EMPLOYEE.equals(item.getSourceType()))
|
.map(BizOpLog::getOperatorUserId)
|
.filter(Objects::nonNull)
|
.distinct()
|
.toList();
|
Map<Long, String> adminNameMap = loadAdminNameMap(adminUserIds);
|
Map<Long, String> mpNameMap = loadMpNameMap(mpUserIds);
|
return records.stream()
|
.map(item -> toListVo(item, adminNameMap, mpNameMap))
|
.toList();
|
}
|
|
private OpLogListVo toListVo(
|
BizOpLog item, Map<Long, String> adminNameMap, Map<Long, String> mpNameMap) {
|
OpLogListVo vo = new OpLogListVo();
|
vo.setId(item.getId());
|
vo.setSourceType(item.getSourceType());
|
vo.setSourceTypeText(resolveSourceTypeText(item.getSourceType()));
|
vo.setOperatorUserId(item.getOperatorUserId());
|
vo.setModule(item.getModule());
|
vo.setAction(item.getAction());
|
vo.setResourceType(item.getResourceType());
|
vo.setResourceId(item.getResourceId());
|
vo.setDetailJson(item.getDetailJson());
|
vo.setTraceId(item.getTraceId());
|
vo.setOpTime(item.getOpTime());
|
if (SOURCE_MINI_EMPLOYEE.equals(item.getSourceType())) {
|
vo.setOperatorName(mpNameMap.getOrDefault(item.getOperatorUserId(), "—"));
|
} else {
|
vo.setOperatorName(adminNameMap.getOrDefault(item.getOperatorUserId(), "—"));
|
}
|
return vo;
|
}
|
|
private Map<Long, String> loadAdminNameMap(List<Long> userIds) {
|
if (userIds == null || userIds.isEmpty()) {
|
return Map.of();
|
}
|
return sysUserMapper.selectBatchIds(userIds).stream()
|
.collect(
|
Collectors.toMap(
|
SysUser::getId,
|
user -> firstNonBlank(user.getRealName(), user.getUsername(), "—"),
|
(a, _b) -> a));
|
}
|
|
private Map<Long, String> loadMpNameMap(List<Long> userIds) {
|
if (userIds == null || userIds.isEmpty()) {
|
return Map.of();
|
}
|
return mpUserMapper.selectBatchIds(userIds).stream()
|
.filter(user -> "EMPLOYEE".equals(user.getUserType()))
|
.collect(
|
Collectors.toMap(
|
MpUser::getId,
|
user -> firstNonBlank(user.getNickName(), user.getMobile(), "—"),
|
(a, _b) -> a));
|
}
|
|
private boolean isEmployee(Long operatorUserId) {
|
if (operatorUserId == null) {
|
return false;
|
}
|
MpUser user = mpUserMapper.selectById(operatorUserId);
|
return user != null && "EMPLOYEE".equals(user.getUserType());
|
}
|
|
private String normalizeSourceType(String sourceType) {
|
if (!StringUtils.hasText(sourceType)) {
|
return null;
|
}
|
String normalized = sourceType.trim().toUpperCase();
|
if (SOURCE_ADMIN.equals(normalized)) {
|
return SOURCE_ADMIN;
|
}
|
if (SOURCE_MINI_EMPLOYEE.equals(normalized)) {
|
return SOURCE_MINI_EMPLOYEE;
|
}
|
return null;
|
}
|
|
private String resolveSourceTypeText(String sourceType) {
|
if (SOURCE_MINI_EMPLOYEE.equals(sourceType)) {
|
return "员工端";
|
}
|
return "管理后台";
|
}
|
|
private String firstNonBlank(String... values) {
|
for (String value : values) {
|
if (StringUtils.hasText(value)) {
|
return value.trim();
|
}
|
}
|
return "—";
|
}
|
}
|
