package com.ruoyi.system.service.impl;
|
|
import java.math.BigDecimal;
|
import java.util.Date;
|
import java.util.List;
|
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.ruoyi.common.annotation.DataSource;
|
import com.ruoyi.common.enums.DataSourceType;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.system.domain.PaidMoneyAdd;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskAdditionalFee;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.mapper.PaidMoneyAddMapper;
|
import com.ruoyi.system.mapper.SysTaskAdditionalFeeMapper;
|
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.mapper.SysUserMapper;
|
import com.ruoyi.system.service.IAdditionalFeeSyncService;
|
|
/**
|
* 附加费用同步Service实现
|
*
|
* @author ruoyi
|
* @date 2025-01-15
|
*/
|
@Service
|
public class AdditionalFeeSyncServiceImpl implements IAdditionalFeeSyncService {
|
|
private static final Logger log = LoggerFactory.getLogger(AdditionalFeeSyncServiceImpl.class);
|
|
@Autowired
|
private SysTaskAdditionalFeeMapper additionalFeeMapper;
|
|
@Autowired
|
private PaidMoneyAddMapper paidMoneyAddMapper;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
/**
|
* 附加费用类型映射（新系统 -> 旧系统）
|
* 新系统字典值：1-等待费, 2-担架, 3-居家ICU, 4-医疗设备
|
* 旧系统AddMoneyType：直接使用字典值
|
*/
|
private Integer convertFeeTypeToLegacy(String feeType) {
|
if (feeType == null || feeType.trim().isEmpty()) {
|
return 1; // 默认等待费
|
}
|
try {
|
return Integer.parseInt(feeType);
|
} catch (NumberFormatException e) {
|
log.warn("无效的费用类型: {}", feeType);
|
return 1; // 默认等待费
|
}
|
}
|
|
/**
|
* 附加费用类型映射（旧系统 -> 新系统）
|
*/
|
private String convertFeeTypeFromLegacy(Integer addMoneyType) {
|
if (addMoneyType == null) {
|
return "1"; // 默认等待费
|
}
|
return String.valueOf(addMoneyType);
|
}
|
|
/**
|
* 获取费用类型名称
|
*/
|
private String getFeeTypeName(String feeType) {
|
switch (feeType) {
|
case "1": return "等待费";
|
case "2": return "担架";
|
case "3": return "居家ICU";
|
case "4": return "医疗设备";
|
default: return "其他费用";
|
}
|
}
|
|
@Override
|
public boolean syncAdditionalFeeToLegacy(Long feeId) {
|
try {
|
// 1. 查询新系统附加费用记录
|
SysTaskAdditionalFee fee = additionalFeeMapper.selectByTaskId(null).stream()
|
.filter(f -> f.getId().equals(feeId))
|
.findFirst()
|
.orElse(null);
|
|
if (fee == null) {
|
log.info("新系统附加费用记录不存在，feeId: {}", feeId);
|
return false;
|
}
|
|
// 2. 如果已同步过，跳过
|
if (fee.getPid() != null && fee.getPid() > 0) {
|
log.info("附加费用已同步，feeId: {}, pid: {}", feeId, fee.getPid());
|
return true;
|
}
|
|
// 3. 查询任务信息获取ServiceOrdID和DispatchOrdID
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(fee.getTaskId());
|
if (task == null) {
|
log.error("任务不存在，taskId: {}", fee.getTaskId());
|
return false;
|
}
|
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(fee.getTaskId());
|
if (emergency == null || emergency.getLegacyServiceOrdId() == null || emergency.getLegacyDispatchOrdId() == null) {
|
log.error("任务未同步到旧系统或缺少ServiceOrdID/DispatchOrdID，taskId: {}", fee.getTaskId());
|
return false;
|
}
|
|
// 4. 获取创建人OA用户ID
|
Integer oaUserId = null;
|
try {
|
String createdBy = fee.getCreatedBy();
|
if (createdBy != null) {
|
SysUser user = sysUserMapper.selectUserByUserName(createdBy);
|
if (user != null) {
|
oaUserId = user.getOaUserId();
|
}
|
}
|
} catch (Exception e) {
|
log.warn("获取创建人OA用户ID失败，使用默认值", e);
|
}
|
|
// 5. 构建PaidMoneyAdd对象
|
PaidMoneyAdd paidMoneyAdd = new PaidMoneyAdd();
|
paidMoneyAdd.setToServiceOrdID(emergency.getLegacyServiceOrdId());
|
paidMoneyAdd.setToDispatchOrdID(emergency.getLegacyDispatchOrdId());
|
paidMoneyAdd.setAddMoneyType(convertFeeTypeToLegacy(fee.getFeeType()));
|
paidMoneyAdd.setAddMoney(fee.getTotalAmount());
|
paidMoneyAdd.setAddMoneyExplain(fee.getFeeName() +
|
(fee.getRemark() != null && !fee.getRemark().isEmpty() ? "(" + fee.getRemark() + ")" : ""));
|
paidMoneyAdd.setAddMoneyTime(fee.getCreatedTime() != null ? fee.getCreatedTime() : new Date());
|
paidMoneyAdd.setAddMoneyOAID(oaUserId);
|
|
// 6. 插入旧系统PaidMoney_Add表
|
int result = paidMoneyAddMapper.insert(paidMoneyAdd);
|
if (result > 0) {
|
// 7. 更新新系统附加费用记录的同步信息
|
additionalFeeMapper.updateSyncInfo(feeId, paidMoneyAdd.getId(), 2, new Date());
|
log.info("附加费用同步到旧系统成功，feeId: {}, pid: {}", feeId, paidMoneyAdd.getId());
|
return true;
|
} else {
|
log.error("插入旧系统PaidMoney_Add表失败，feeId: {}", feeId);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步附加费用到旧系统异常，feeId: {}", feeId, e);
|
// 更新同步状态为失败
|
try {
|
additionalFeeMapper.updateSyncInfo(feeId, null, 3, new Date());
|
} catch (Exception ex) {
|
log.error("更新同步状态失败", ex);
|
}
|
return false;
|
}
|
}
|
|
@Override
|
public boolean syncAdditionalFeeFromLegacy(Long paidMoneyAddId) {
|
try {
|
// 1. 查询旧系统PaidMoney_Add记录
|
PaidMoneyAdd paidMoneyAdd = paidMoneyAddMapper.selectById(paidMoneyAddId);
|
if (paidMoneyAdd == null) {
|
log.error("旧系统附加费用记录不存在，paidMoneyAddId: {}", paidMoneyAddId);
|
return false;
|
}
|
|
// 2. 检查是否已同步过
|
SysTaskAdditionalFee existFee = additionalFeeMapper.selectByPid(paidMoneyAddId);
|
if (existFee != null) {
|
log.info("旧系统附加费用记录已同步，paidMoneyAddId: {}, feeId: {}", paidMoneyAddId, existFee.getId());
|
return true;
|
}
|
|
// 3. 根据ServiceOrdID查询新系统任务
|
if (paidMoneyAdd.getToServiceOrdID() == null) {
|
log.warn("旧系统附加费用记录缺少ServiceOrdID，paidMoneyAddId: {}，跳过同步", paidMoneyAddId);
|
return false;
|
}
|
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(paidMoneyAdd.getToServiceOrdID());
|
if (emergency == null) {
|
log.warn("未找到对应的转运任务，ServiceOrdID: {}，跳过同步", paidMoneyAdd.getToServiceOrdID());
|
return false;
|
}
|
|
// 4. 验证DispatchOrdID是否匹配
|
if (paidMoneyAdd.getToDispatchOrdID() == null) {
|
log.warn("旧系统附加费用记录缺少DispatchOrdID，paidMoneyAddId: {}，跳过同步", paidMoneyAddId);
|
return false;
|
}
|
|
if (!paidMoneyAdd.getToDispatchOrdID().equals(emergency.getLegacyDispatchOrdId())) {
|
log.warn("转运任务DispatchOrdID不匹配，ServiceOrdID: {}, 附加费用DispatchOrdID: {} vs 任务DispatchOrdID: {}，跳过同步",
|
paidMoneyAdd.getToServiceOrdID(), paidMoneyAdd.getToDispatchOrdID(), emergency.getLegacyDispatchOrdId());
|
return false;
|
}
|
|
// 5. 构建SysTaskAdditionalFee对象
|
SysTaskAdditionalFee fee = new SysTaskAdditionalFee();
|
fee.setTaskId(emergency.getTaskId());
|
fee.setFeeType(convertFeeTypeFromLegacy(paidMoneyAdd.getAddMoneyType()));
|
fee.setFeeName(getFeeTypeName(fee.getFeeType()));
|
fee.setUnitAmount(paidMoneyAdd.getAddMoney());
|
fee.setQuantity(1);
|
fee.setTotalAmount(paidMoneyAdd.getAddMoney());
|
fee.setRemark(paidMoneyAdd.getAddMoneyExplain());
|
fee.setCreatedBy("system");
|
fee.setCreatedTime(paidMoneyAdd.getAddMoneyTime() != null ? paidMoneyAdd.getAddMoneyTime() : new Date());
|
fee.setPid(paidMoneyAddId);
|
fee.setSyncStatus(2); // 同步成功
|
fee.setSyncTime(new Date());
|
|
// 6. 插入新系统附加费用记录
|
int result = additionalFeeMapper.insert(fee);
|
if (result > 0) {
|
log.info("旧系统附加费用记录同步到新系统成功，paidMoneyAddId: {}, feeId: {}", paidMoneyAddId, fee.getId());
|
return true;
|
} else {
|
log.error("插入新系统附加费用记录失败，paidMoneyAddId: {}", paidMoneyAddId);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步旧系统附加费用记录到新系统异常，paidMoneyAddId: {}", paidMoneyAddId, e);
|
return false;
|
}
|
}
|
|
@Override
|
public int batchSyncAdditionalFeeToLegacy() {
|
int successCount = 0;
|
try {
|
// 查询未同步的附加费用记录
|
List<SysTaskAdditionalFee> unsyncedFees = additionalFeeMapper.selectUnsyncedFees();
|
|
log.info("开始批量同步附加费用到旧系统，待同步记录数: {}", unsyncedFees.size());
|
|
for (SysTaskAdditionalFee fee : unsyncedFees) {
|
try {
|
if (syncAdditionalFeeToLegacy(fee.getId())) {
|
successCount++;
|
}
|
// 每条记录间隔1秒，避免过于频繁
|
Thread.sleep(1000);
|
} catch (Exception e) {
|
log.error("同步附加费用失败，feeId: {}", fee.getId(), e);
|
}
|
}
|
|
log.info("批量同步附加费用到旧系统完成，成功: {}, 总数: {}", successCount, unsyncedFees.size());
|
|
} catch (Exception e) {
|
log.error("批量同步附加费用到旧系统异常", e);
|
}
|
|
return successCount;
|
}
|
|
@Override
|
public int batchSyncAdditionalFeeFromLegacy(Integer hours) {
|
int successCount = 0;
|
try {
|
if (hours == null || hours <= 0) {
|
hours = 24; // 默认24小时
|
}
|
|
// 查询最近N小时的附加费用记录
|
List<PaidMoneyAdd> recentRecords = paidMoneyAddMapper.selectRecentRecords(hours);
|
|
log.info("开始批量同步旧系统附加费用到新系统，最近{}小时记录数: {}", hours, recentRecords.size());
|
|
for (PaidMoneyAdd paidMoneyAdd : recentRecords) {
|
try {
|
if (syncAdditionalFeeFromLegacy(paidMoneyAdd.getId())) {
|
successCount++;
|
}
|
// 每条记录间隔1秒，避免过于频繁
|
Thread.sleep(1000);
|
} catch (Exception e) {
|
log.error("同步旧系统附加费用失败，paidMoneyAddId: {}", paidMoneyAdd.getId(), e);
|
}
|
}
|
|
log.info("批量同步旧系统附加费用到新系统完成，成功: {}, 总数: {}", successCount, recentRecords.size());
|
|
} catch (Exception e) {
|
log.error("批量同步旧系统附加费用到新系统异常", e);
|
}
|
|
return successCount;
|
}
|
}
|
