package com.ruoyi.system.service.impl;
|
|
import java.math.BigDecimal;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
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.core.domain.entity.SysUser;
|
import com.ruoyi.common.enums.DataSourceType;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.system.domain.PaidMoney;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.SysTaskPayment;
|
import com.ruoyi.system.mapper.PaidMoneyMapper;
|
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.mapper.SysTaskPaymentMapper;
|
import com.ruoyi.system.mapper.SysUserMapper;
|
import com.ruoyi.system.service.IPaymentSyncService;
|
|
/**
|
* 支付信息同步Service实现
|
*
|
* @author ruoyi
|
* @date 2025-01-15
|
*/
|
@Service
|
public class PaymentSyncServiceImpl implements IPaymentSyncService {
|
|
private static final Logger log = LoggerFactory.getLogger(PaymentSyncServiceImpl.class);
|
|
@Autowired
|
private SysTaskPaymentMapper sysTaskPaymentMapper;
|
|
@Autowired
|
private PaidMoneyMapper paidMoneyMapper;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
/**
|
* 支付方式映射（新系统 -> 旧系统）
|
* 新系统：CASH现金, ON_ACCOUNT挂账, WECHAT微信, ALIPAY支付宝
|
* 旧系统：1-现金, 2-银行转账, 3-微信支付, 4-支付宝, 5-POS收款, 6-挂账, 7-易医通挂账
|
*/
|
private Integer convertPaymentMethodToLegacy(String paymentMethod) {
|
return Integer.valueOf(paymentMethod); // 直接转换，假设paymentMethod已经是正确的 legacy 值
|
}
|
|
/**
|
* 支付方式映射（旧系统 -> 新系统）
|
*/
|
private String convertPaymentMethodFromLegacy(Integer paidMoneyType) {
|
return paidMoneyType.toString(); // 直接转换，假设paidMoneyType已经是正确的 paymentMethod 值
|
}
|
|
/**
|
* 将新系统支付记录同步到旧系统PaidMoney表
|
*/
|
@Override
|
public boolean syncPaymentToLegacy(SysTaskPayment payment) {
|
Long paymentId = payment.getId();
|
try {
|
|
|
// 2. 如果已同步过，跳过
|
if (payment.getPid() != null && payment.getPid() > 0) {
|
log.info("支付记录已同步，paymentId: {}, pid: {}", payment.getId(), payment.getPid());
|
return true;
|
}
|
|
// 3. 查询任务信息获取ServiceOrdIDDt和DispatchOrdIDDt
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(payment.getTaskId());
|
if (task == null) {
|
log.error("任务不存在，taskId: {}", payment.getTaskId());
|
return false;
|
}
|
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(payment.getTaskId());
|
if (emergency == null || emergency.getLegacyServiceOrdId() == null || emergency.getLegacyDispatchOrdId() == null) {
|
log.error("任务未同步到旧系统或缺少ServiceOrdID/DispatchOrdID，taskId: {}", payment.getTaskId());
|
return false;
|
}
|
|
// 4. 获取支付人OA用户ID
|
Integer oaUserId = null;
|
try {
|
String createdBy = payment.getCreatedBy();
|
if (createdBy != null) {
|
SysUser user = sysUserMapper.selectUserByUserName(createdBy);
|
if (user != null) {
|
oaUserId = user.getOaUserId();
|
}
|
}
|
} catch (Exception e) {
|
log.warn("获取支付人OA用户ID失败，使用默认值", e);
|
}
|
|
// 5. 构建PaidMoney对象
|
PaidMoney paidMoney = new PaidMoney();
|
paidMoney.setPaidMoneyClass("FI"); // 默认FI
|
paidMoney.setServiceOrdIDDt(emergency.getLegacyServiceOrdId());
|
if(emergency.getLegacyDispatchOrdId()!=null) {
|
paidMoney.setDispatchOrdIDDt(emergency.getLegacyDispatchOrdId());
|
}
|
paidMoney.setPaidMoney(payment.getSettlementAmount());
|
paidMoney.setPaidMoneyType(convertPaymentMethodToLegacy(payment.getPaymentMethod()));
|
paidMoney.setPaidMoneyMono(payment.getTradeNo() != null ? payment.getTradeNo() : payment.getOutTradeNo());
|
paidMoney.setPaidMoneyTime(payment.getPayTime() != null ? payment.getPayTime() : new Date());
|
paidMoney.setPaidMoneyOaID(oaUserId);
|
paidMoney.setPaidMoneyUnitID(0); // 默认为0
|
paidMoney.setPaidMoneyAPCheck(0); // 已确认
|
paidMoney.setPaidMoneyAPTime(new Date());
|
paidMoney.setPaidMoneyTimestamp(String.valueOf(System.currentTimeMillis()));
|
|
// 6. 插入旧系统PaidMoney表
|
int result = paidMoneyMapper.insert(paidMoney);
|
if (result > 0) {
|
// 7. 更新新系统支付记录的同步信息
|
sysTaskPaymentMapper.updateSyncInfo(paymentId, paidMoney.getId(), 2, new Date());
|
log.info("支付记录同步到旧系统成功，paymentId: {}, pid: {}", paymentId, paidMoney.getId());
|
return true;
|
} else {
|
log.error("插入旧系统PaidMoney表失败，paymentId: {}", paymentId);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步支付记录到旧系统异常，paymentId: {}", paymentId, e);
|
// 更新同步状态为失败
|
try {
|
sysTaskPaymentMapper.updateSyncInfo(paymentId, null, 3, new Date());
|
} catch (Exception ex) {
|
log.error("更新同步状态失败", ex);
|
}
|
return false;
|
}
|
}
|
|
/**
|
* 将旧系统PaidMoney记录同步到新系统
|
*/
|
@Override
|
public boolean syncPaymentFromLegacy(PaidMoney paidMoney) {
|
Long paidMoneyId = paidMoney.getId();
|
try {
|
|
|
// 2. 检查是否已同步过
|
SysTaskPayment existPayment = sysTaskPaymentMapper.selectByPid(paidMoney.getId());
|
if (existPayment != null) {
|
log.info("旧系统支付记录已同步，paidMoneyId: {}, paymentId: {}", paidMoney.getId(), existPayment.getId());
|
return true;
|
}
|
|
// 3. 根据ServiceOrdIDDt查询新系统任务
|
if (paidMoney.getServiceOrdIDDt() == null) {
|
log.warn("旧系统支付记录缺少ServiceOrdID，paidMoneyId: {}，跳过同步", paidMoneyId);
|
return false;
|
}
|
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(paidMoney.getServiceOrdIDDt());
|
if (emergency == null) {
|
log.warn("未找到对应的转运任务，ServiceOrdID: {}，跳过同步", paidMoney.getServiceOrdIDDt());
|
return false;
|
}
|
|
// 4. 验证DispatchOrdID是否匹配
|
if (paidMoney.getDispatchOrdIDDt() == null) {
|
log.warn("旧系统支付记录缺少DispatchOrdID，paidMoneyId: {}，跳过同步", paidMoneyId);
|
return false;
|
}
|
|
if (!paidMoney.getDispatchOrdIDDt().equals(emergency.getLegacyDispatchOrdId())) {
|
log.warn("转运任务DispatchOrdID不匹配，ServiceOrdID: {}, 支付记录DispatchOrdID: {} vs 任务DispatchOrdID: {}，跳过同步",
|
paidMoney.getServiceOrdIDDt(), paidMoney.getDispatchOrdIDDt(), emergency.getLegacyDispatchOrdId());
|
return false;
|
}
|
|
// 5. 查询任务信息
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(emergency.getTaskId());
|
if (task == null) {
|
log.error("任务不存在，taskId: {}", emergency.getTaskId());
|
return false;
|
}
|
|
// 6. 构建SysTaskPayment对象
|
SysTaskPayment payment = new SysTaskPayment();
|
payment.setTaskId(task.getTaskId());
|
payment.setTotalAmount(paidMoney.getPaidMoney());
|
payment.setSettlementAmount(paidMoney.getPaidMoney());
|
payment.setPaymentMethod(convertPaymentMethodFromLegacy(paidMoney.getPaidMoneyType()));
|
payment.setPayStatus("PAID"); // 已支付
|
payment.setPayTime(paidMoney.getPaidMoneyTime() != null ? paidMoney.getPaidMoneyTime() : new Date());
|
payment.setOutTradeNo(task.getTaskCode() + "-" + paidMoneyId);
|
payment.setTradeNo(paidMoney.getPaidMoneyMono());
|
payment.setPid(paidMoneyId);
|
payment.setSyncStatus(2); // 同步成功
|
payment.setSyncTime(new Date());
|
payment.setCreatedBy("system");
|
payment.setCreatedTime(paidMoney.getPaidMoneyTime() != null ? paidMoney.getPaidMoneyTime() : new Date());
|
|
// 7. 插入新系统支付记录
|
int result = sysTaskPaymentMapper.insert(payment);
|
if (result > 0) {
|
log.info("旧系统支付记录同步到新系统成功，paidMoneyId: {}, paymentId: {}", paidMoneyId, payment.getId());
|
return true;
|
} else {
|
log.error("插入新系统支付记录失败，paidMoneyId: {}", paidMoneyId);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步旧系统支付记录到新系统异常，paidMoneyId: {}", paidMoneyId, e);
|
return false;
|
}
|
}
|
|
/**
|
* 批量同步新系统未同步的支付记录到旧系统
|
*/
|
@Override
|
public int batchSyncPaymentToLegacy() {
|
int successCount = 0;
|
try {
|
// 查询未同步的支付成功记录
|
List<SysTaskPayment> unsyncedPayments = sysTaskPaymentMapper.selectUnsyncedPaidPayments();
|
|
log.info("开始批量同步支付记录到旧系统，待同步记录数: {}", unsyncedPayments.size());
|
|
for (SysTaskPayment payment : unsyncedPayments) {
|
try {
|
if (syncPaymentToLegacy(payment)) {
|
successCount++;
|
}
|
// 每条记录间隔1秒，避免过于频繁
|
Thread.sleep(1000);
|
} catch (Exception e) {
|
log.error("同步支付记录失败，paymentId: {}", payment.getId(), e);
|
}
|
}
|
|
log.info("批量同步支付记录到旧系统完成，成功: {}, 总数: {}", successCount, unsyncedPayments.size());
|
|
} catch (Exception e) {
|
log.error("批量同步支付记录到旧系统异常", e);
|
}
|
|
return successCount;
|
}
|
|
/**
|
* 批量同步旧系统新增的支付记录到新系统
|
*/
|
@Override
|
public int batchSyncPaymentFromLegacy() {
|
int successCount = 0;
|
try {
|
// 查询旧系统最近7天的支付记录
|
List<PaidMoney> recentPayments = paidMoneyMapper.selectRecentRecords(7);
|
|
log.info("开始批量同步旧系统支付记录到新系统，最近7天记录数: {}", recentPayments.size());
|
|
for (PaidMoney paidMoney : recentPayments) {
|
try {
|
if (syncPaymentFromLegacy(paidMoney)) {
|
successCount++;
|
}
|
// 每条记录间隔1秒，避免过于频繁
|
Thread.sleep(1000);
|
} catch (Exception e) {
|
log.error("同步旧系统支付记录失败，paidMoneyId: {}", paidMoney.getId(), e);
|
}
|
}
|
|
log.info("批量同步旧系统支付记录到新系统完成，成功: {}, 总数: {}", successCount, recentPayments.size());
|
|
} catch (Exception e) {
|
log.error("批量同步旧系统支付记录到新系统异常", e);
|
}
|
|
return successCount;
|
}
|
}
|
