package com.ruoyi.system.service.impl;
|
|
import java.util.Date;
|
import java.util.List;
|
|
import com.ruoyi.common.utils.LongUtil;
|
import com.ruoyi.system.domain.*;
|
import com.ruoyi.system.mapper.*;
|
import com.ruoyi.system.service.*;
|
import com.ruoyi.system.task.ITaskAttachmentService;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.stereotype.Service;
|
|
import com.ruoyi.common.config.LegacySystemConfig;
|
|
/**
|
* 旧系统同步Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2024-01-20
|
*/
|
@Service
|
public class LegacySystemSyncServiceImpl implements ILegacySystemSyncService {
|
|
private static final Logger log = LoggerFactory.getLogger(LegacySystemSyncServiceImpl.class);
|
|
@Autowired
|
private LegacySystemConfig legacyConfig;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired
|
private SysDeptMapper sysDeptMapper;
|
|
@Autowired
|
private SysTaskVehicleMapper sysTaskVehicleMapper;
|
|
@Autowired
|
private SysTaskAssigneeMapper sysTaskAssigneeMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
@Autowired
|
private IDispatchOrdService dispatchOrdService;
|
|
@Autowired
|
private ISysTaskEmergencyService sysTaskEmergencyService;
|
|
@Autowired
|
private ITaskAttachmentSyncService taskAttachmentSyncService;
|
|
@Autowired
|
private ISysTaskService sysTaskService;
|
|
@Autowired
|
private ITaskAttachmentService taskAttachmentService;
|
|
|
@Autowired
|
private ApplicationEventPublisher eventPublisher;
|
|
@Autowired
|
private LegacyTransferSyncMapper legacyTransferSyncMapper;
|
|
|
@Autowired
|
private TaskEmergencySyncService taskEmergencySyncService;
|
|
|
@Autowired
|
private ITaskDispatchSyncService taskDispatchSyncService;
|
|
|
|
|
@Override
|
public Long syncEmergencyTaskToLegacy(Long taskId) {
|
return taskEmergencySyncService.syncEmergency(taskId);
|
}
|
|
/**
|
* 批量同步未同步的急救转运任务
|
* 使用分页查询，确保所有符合条件的任务都能被同步
|
*/
|
@Override
|
public int batchSyncPendingTasks() {
|
if (!legacyConfig.isEnabled()) {
|
log.info("旧系统同步已禁用");
|
return 0;
|
}
|
|
try {
|
int totalSuccessCount = 0;
|
int pageSize = 100; // 每页100条
|
int offset = 0;
|
|
while (true) {
|
// 分页查询未同步的急救转运任务（同步状态为0或3的任务）
|
List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingSyncTasks(offset, pageSize);
|
|
if (pendingTasks == null || pendingTasks.isEmpty()) {
|
log.info("没有更多需要同步的任务，offset: {}", offset);
|
break; // 没有更多数据，退出循环
|
}
|
|
// log.info("开始同步第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
|
|
int pageSuccessCount = 0;
|
for (SysTaskEmergency emergency : pendingTasks) {
|
Long serviceOrdId = syncEmergencyTaskToLegacy(emergency.getTaskId());
|
if (LongUtil.isNotEmpty(serviceOrdId)) {
|
pageSuccessCount++;
|
}
|
|
// 避免过于频繁的请求
|
try {
|
Thread.sleep(1000); // 每个请求间隔1秒
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("同步被中断");
|
return totalSuccessCount + pageSuccessCount;
|
}
|
}
|
|
totalSuccessCount += pageSuccessCount;
|
// log.info("第 {} 页同步完成，总数: {}, 成功: {}",
|
// (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
|
|
// 如果本页数据少于每页大小，说明已经是最后一页
|
if (pendingTasks.size() < pageSize) {
|
// log.info("已到达最后一页，同步结束");
|
break;
|
}
|
|
offset += pageSize; // 下一页
|
}
|
|
// log.info("批量同步完成，总成功数: {}", totalSuccessCount);
|
return totalSuccessCount;
|
|
} catch (Exception e) {
|
log.error("批量同步任务异常", e);
|
return 0;
|
}
|
}
|
|
/**
|
* 重新同步失败的任务
|
*/
|
@Override
|
public boolean retrySyncTask(Long taskId) {
|
try {
|
// 重置同步状态
|
SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
|
if (emergency != null) {
|
emergency.setSyncStatus(0); // 重置为未同步
|
emergency.setLegacyServiceOrdId(null);
|
emergency.setSyncErrorMsg(null);
|
sysTaskEmergencyService.updateSysTaskEmergency(emergency);
|
}
|
|
// 重新同步
|
Long serviceOrdId = syncEmergencyTaskToLegacy(taskId);
|
return LongUtil.isNotEmpty(serviceOrdId);
|
|
} catch (Exception e) {
|
log.error("重新同步任务失败，任务ID: {}", taskId, e);
|
return false;
|
}
|
}
|
|
@Override
|
public Long syncDispatchOrderToLegacy(Long taskId) {
|
return taskDispatchSyncService.syncDispatch(taskId);
|
}
|
|
|
/**
|
* 同步任务附件到旧系统
|
* @param taskAttachments
|
* @param serviceOrdId
|
* @param dispatchOrdId
|
* @param oaUserID
|
*/
|
public void syncAttachmentToLegacy(List<SysTaskAttachment> taskAttachments, Long serviceOrdId,Long dispatchOrdId,Integer oaUserID) {
|
taskAttachments.forEach((taskAttachment)->{
|
Long imageDataId= taskAttachmentSyncService.syncAttachmentToImageData(taskAttachment,serviceOrdId,dispatchOrdId,oaUserID);
|
if (imageDataId != null && imageDataId > 0) {
|
|
taskAttachment.setSyncedToImageData(1);
|
taskAttachment.setSyncTime(new Date());
|
taskAttachment.setImageDataId(imageDataId);
|
taskAttachmentService.updateAttachment(taskAttachment);
|
}
|
});
|
}
|
|
|
@Override
|
public void syncTaskAttachment(Long taskId, Long dispatchOrdId, Long serviceOrdId, Integer oaUserID){
|
List<SysTaskAttachment> taskAttachments= sysTaskService.getAttachmentsByTaskId(taskId);
|
if (taskAttachments != null && !taskAttachments.isEmpty()) {
|
//同步附件
|
this.syncAttachmentToLegacy(taskAttachments,serviceOrdId,dispatchOrdId,oaUserID);
|
}
|
}
|
|
/**
|
* 批量同步未同步的调度单
|
* 使用分页查询，确保所有符合条件的任务都能被同步
|
*/
|
@Override
|
public int batchSyncPendingDispatchOrders() {
|
if (!legacyConfig.isEnabled()) {
|
log.info("旧系统同步已禁用");
|
return 0;
|
}
|
|
try {
|
int totalSuccessCount = 0;
|
int pageSize = 100; // 每页100条
|
int offset = 0;
|
|
while (true) {
|
// 分页查询已同步服务单但未同步调度单的任务
|
List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingDispatchSyncTasks(offset, pageSize);
|
// log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size());
|
if (pendingTasks == null || pendingTasks.isEmpty()) {
|
log.info("没有更多需要同步调度单的任务，offset: {}", offset);
|
break; // 没有更多数据，退出循环
|
}
|
|
// log.info("开始同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
|
|
int pageSuccessCount = 0;
|
for (SysTaskEmergency emergency : pendingTasks) {
|
// log.info("开始同步调度单，任务ID: {}", emergency.getTaskId());
|
Long dispatchOrdId = syncDispatchOrderToLegacy(emergency.getTaskId());
|
|
if (dispatchOrdId != null && dispatchOrdId > 0) {
|
pageSuccessCount++;
|
}
|
|
// 避免过于频繁的请求
|
try {
|
Thread.sleep(1000); // 每个请求间隔1秒
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("同步调度单被中断");
|
return totalSuccessCount + pageSuccessCount;
|
}
|
}
|
|
totalSuccessCount += pageSuccessCount;
|
// log.info("调度单第 {} 页同步完成，总数: {}, 成功: {}",
|
// (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
|
|
// 如果本页数据少于每页大小，说明已经是最后一页
|
if (pendingTasks.size() < pageSize) {
|
// log.info("已到达最后一页，调度单同步结束");
|
break;
|
}
|
|
offset += pageSize; // 下一页
|
}
|
|
// log.info("批量同步调度单完成，总成功数: {}", totalSuccessCount);
|
return totalSuccessCount;
|
|
} catch (Exception e) {
|
log.error("批量同步调度单异常", e);
|
return 0;
|
}
|
}
|
|
@Override
|
public boolean resyncDispatchOrderToLegacy(Long taskId) {
|
SysTaskEmergency emergency=sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
|
Long dispatchOrderId = emergency.getLegacyDispatchOrdId();
|
if(LongUtil.isEmpty(dispatchOrderId)){
|
Long serviceOrderId= taskEmergencySyncService.syncEmergency(taskId);
|
if(LongUtil.isNotEmpty(serviceOrderId)) {
|
emergency.setNeedResync(0);
|
// emergency.setSyncStatus(2);
|
emergency.setSyncTime(new Date());
|
sysTaskEmergencyService.updateSysTaskEmergency(emergency);
|
return true;
|
}
|
return false;
|
}else {
|
return taskDispatchSyncService.resyncDispatchOrderToLegacy(taskId);
|
}
|
}
|
|
|
/**
|
* 批量重新同步需要更新的调度单
|
*/
|
@Override
|
public int batchResyncPendingDispatchOrders() {
|
if (!legacyConfig.isEnabled()) {
|
log.info("旧系统同步已禁用");
|
return 0;
|
}
|
|
try {
|
int totalSuccessCount = 0;
|
int pageSize = 100; // 每页100条
|
int offset = 0;
|
|
while (true) {
|
// 分页查询需要重新同步的任务
|
List<SysTaskEmergency> needResyncTasks = sysTaskEmergencyMapper.selectNeedResyncTasks(offset, pageSize);
|
|
// log.info("查询到需要重新同步的任务数量: {}", needResyncTasks.size());
|
if (needResyncTasks == null || needResyncTasks.isEmpty()) {
|
log.info("没有更多需要重新同步的任务，offset: {}", offset);
|
break; // 没有更多数据，退出循环
|
}
|
|
// log.info("开始重新同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, needResyncTasks.size());
|
|
int pageSuccessCount = 0;
|
for (SysTaskEmergency emergency : needResyncTasks) {
|
Long dispatchOrdId = emergency.getLegacyDispatchOrdId();
|
Long taskId = emergency.getTaskId();
|
if (LongUtil.isEmpty(dispatchOrdId)) {
|
//没有调度单，我们就调用创建调度单
|
Long serviceOrderId = syncDispatchOrderToLegacy(taskId);
|
if (LongUtil.isNotEmpty(serviceOrderId)) {
|
emergency.setNeedResync(0);
|
emergency.setDispatchSyncTime(new Date());
|
emergency.setDispatchSyncErrorMsg(null);
|
sysTaskEmergencyService.updateSysTaskEmergency(emergency);
|
|
continue;
|
}
|
// log.info("开始重新同步调度单，任务ID: {}", emergency.getTaskId());
|
boolean success = resyncDispatchOrderToLegacy(emergency.getTaskId());
|
|
if (success) {
|
pageSuccessCount++;
|
}
|
|
// 避免过于频繁的请求
|
try {
|
Thread.sleep(1000); // 每个请求间隔1秒
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("重新同步调度单被中断");
|
return totalSuccessCount + pageSuccessCount;
|
}
|
}
|
|
totalSuccessCount += pageSuccessCount;
|
// log.info("调度单重新同步第 {} 页完成，总数: {}, 成功: {}",
|
// (offset / pageSize) + 1, needResyncTasks.size(), pageSuccessCount);
|
|
// 如果本页数据少于每页大小，说明已经是最后一页
|
if (needResyncTasks.size() < pageSize) {
|
// log.info("已到达最后一页，调度单重新同步结束");
|
break;
|
}
|
|
offset += pageSize; // 下一页
|
}
|
}
|
// log.info("批量重新同步调度单完成，总成功数: {}", totalSuccessCount);
|
return totalSuccessCount;
|
|
} catch (Exception e) {
|
log.error("批量重新同步调度单异常", e);
|
return 0;
|
}
|
}
|
}
|
