package com.ruoyi.web.controller.service;
|
|
import cn.hutool.core.collection.CollUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.system.domain.SysVisitorRecord;
|
import com.ruoyi.system.mapper.SysVisitorRecordMapper;
|
import com.ruoyi.web.integration.dahua.DahuaVisitorAccessService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.support.TransactionSynchronization;
|
import org.springframework.transaction.support.TransactionSynchronizationManager;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.concurrent.TimeUnit;
|
|
@Service
|
@Slf4j
|
@Transactional(rollbackFor = Exception.class)
|
public class SysVisitorRecordService extends ServiceImpl<SysVisitorRecordMapper, SysVisitorRecord> {
|
|
@Autowired
|
private RedisTemplate<String, String> redisTemplate;
|
|
@Autowired
|
private DahuaVisitorAccessService dahuaVisitorAccessService;
|
|
private static final String REDIS_KEY_PREFIX = "visitor:expire:";
|
|
/**
|
* 登记访客时设置 Redis 过期 Key
|
*/
|
public void registerVisitor(SysVisitorRecord record) {
|
if (record.getValidEndTime() == null) {
|
throw new IllegalArgumentException("访客有效期结束时间不能为空");
|
}
|
if (!record.getValidEndTime().after(new Date())) {
|
log.warn("访客记录 {} 登记时已超期，不下发门禁权限", record.getRecordId());
|
autoSignOut(record);
|
return;
|
}
|
|
// 下发门禁权限后设置过期监听，确保登记与到期撤权使用同一条业务链路。
|
DahuaVisitorAccessService.OperationResult accessResult = dahuaVisitorAccessService.grant(record);
|
registerGrantRollbackCompensation(record, accessResult);
|
setRedisExpireKey(record);
|
|
log.info("访客 {} 登记成功，有效期至：{}", record.getRecordId(), record.getValidEndTime());
|
}
|
|
/**
|
* 设置 Redis 过期 Key
|
*/
|
private void setRedisExpireKey(SysVisitorRecord record) {
|
Date now = new Date();
|
Date validEndTime = record.getValidEndTime();
|
|
if (validEndTime == null) {
|
throw new IllegalArgumentException("访客有效期结束时间不能为空");
|
}
|
|
// 如果有效期结束时间小于当前时间，直接签离
|
if (validEndTime.before(now)) {
|
log.warn("访客记录 {} 已超期，直接签离", record.getRecordId());
|
autoSignOut(record);
|
return;
|
}
|
|
// 计算过期时间（毫秒）
|
long expireTime = validEndTime.getTime() - now.getTime();
|
String key = REDIS_KEY_PREFIX + record.getRecordId();
|
|
// 设置 Redis Key，过期时间为 validEndTime
|
redisTemplate.opsForValue().set(
|
key,
|
record.getRecordId().toString(),
|
expireTime,
|
TimeUnit.MILLISECONDS
|
);
|
|
log.info("设置Redis过期Key成功，Key：{}，过期时间：{} 毫秒", key, expireTime);
|
}
|
|
/**
|
* 根据记录ID自动签离（由Redis过期事件触发）
|
*/
|
@Transactional
|
public void autoSignOutByRecordId(Long recordId) {
|
try {
|
// 1. 查询记录
|
SysVisitorRecord record = this.getById(recordId);
|
if (record == null) {
|
log.warn("访客记录不存在，ID：{}", recordId);
|
return;
|
}
|
|
// 2. 检查状态（只有 VISITING 状态才处理）
|
if (!"VISITING".equals(record.getStatus())) {
|
log.info("访客记录 {} 状态为 {}，无需处理", recordId, record.getStatus());
|
return;
|
}
|
|
// 3. 检查是否真的超期（双重检查）
|
Date now = new Date();
|
if (!record.getValidEndTime().before(now)) {
|
log.info("访客记录 {} 有效期未结束，无需签离", recordId);
|
return;
|
}
|
|
// 4. 执行签离
|
autoSignOut(record);
|
|
// 5. 删除 Redis Key（防止重复触发）
|
redisTemplate.delete(REDIS_KEY_PREFIX + recordId);
|
|
log.info("Redis过期触发签离成功，记录ID：{}，签离时间：{}", recordId, now);
|
|
} catch (Exception e) {
|
log.error("自动签离失败，记录ID：{}", recordId, e);
|
throw e;
|
}
|
}
|
|
/**
|
* 执行自动签离
|
*/
|
private void autoSignOut(SysVisitorRecord record) {
|
Date now = new Date();
|
revokeAccess(record);
|
record.setStatus("PENDING_CONFIRM");
|
record.setSignTime(now);
|
record.setRemark("逾期滞留，等待确认");
|
record.setUpdateTime(now);
|
this.updateById(record);
|
}
|
|
/**
|
* 撤销访客在大华门禁设备上的人脸及人员权限。
|
*/
|
public void revokeAccess(SysVisitorRecord record) {
|
dahuaVisitorAccessService.revoke(record);
|
}
|
|
private void registerGrantRollbackCompensation(SysVisitorRecord record,
|
DahuaVisitorAccessService.OperationResult accessResult) {
|
if (accessResult.getSuccessCount() <= 0 || !TransactionSynchronizationManager.isSynchronizationActive()) {
|
return;
|
}
|
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
|
@Override
|
public void afterCompletion(int status) {
|
if (status != TransactionSynchronization.STATUS_ROLLED_BACK) {
|
return;
|
}
|
redisTemplate.delete(REDIS_KEY_PREFIX + record.getRecordId());
|
try {
|
dahuaVisitorAccessService.revoke(record);
|
log.info("访客登记事务回滚，大华门禁权限补偿撤销完成，recordId={}", record.getRecordId());
|
} catch (Exception e) {
|
log.error("访客登记事务回滚，大华门禁权限补偿撤销失败，recordId={}",
|
record.getRecordId(), e);
|
}
|
}
|
});
|
}
|
|
/**
|
* 更新访客记录（并重置 Redis 过期时间）
|
*/
|
public boolean updateVisitor(SysVisitorRecord record) {
|
// 1. 更新记录
|
boolean updated = this.updateById(record);
|
if (!updated) {
|
return false;
|
}
|
|
// 2. 如果状态变更为 VISITING，重新设置过期时间
|
if ("VISITING".equals(record.getStatus())) {
|
setRedisExpireKey(record);
|
}
|
|
// 3. 如果已签离，删除 Redis Key
|
if ("SIGNED_OUT".equals(record.getStatus()) ||
|
"OVERDUE_AUTO_SIGNED_OUT".equals(record.getStatus())) {
|
redisTemplate.delete(REDIS_KEY_PREFIX + record.getRecordId());
|
}
|
|
return true;
|
}
|
|
/**
|
* 兜底方案：启动时检查所有超期记录
|
*/
|
@Transactional
|
public int checkAndAutoSignOutOnStartup() {
|
// 查询所有超期记录
|
LambdaQueryWrapper<SysVisitorRecord> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.eq(SysVisitorRecord::getStatus, "VISITING")
|
.lt(SysVisitorRecord::getValidEndTime, new Date());
|
|
List<SysVisitorRecord> overdueRecords = this.list(queryWrapper);
|
|
if (CollUtil.isEmpty(overdueRecords)) {
|
log.info("启动检查：没有超期访客记录");
|
return 0;
|
}
|
|
log.info("启动检查：发现 {} 条超期记录，开始处理", overdueRecords.size());
|
|
Date now = new Date();
|
int count = 0;
|
for (SysVisitorRecord record : overdueRecords) {
|
try {
|
revokeAccess(record);
|
record.setStatus("OVERDUE_AUTO_SIGNED_OUT");
|
record.setSignTime(now);
|
record.setRemark("系统自动签离（启动时检查）");
|
record.setUpdateTime(now);
|
this.updateById(record);
|
|
// 删除 Redis Key
|
redisTemplate.delete(REDIS_KEY_PREFIX + record.getRecordId());
|
count++;
|
} catch (Exception e) {
|
log.error("启动检查处理记录失败，ID：{}", record.getRecordId(), e);
|
}
|
}
|
|
log.info("启动检查完成，处理 {} 条超期记录", count);
|
return count;
|
}
|
}
|
