package com.ruoyi.system.service.impl;
|
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.system.domain.VehicleInfo;
|
import com.ruoyi.system.domain.VehicleDept;
|
import com.ruoyi.system.domain.VehicleSyncDTO;
|
import com.ruoyi.system.mapper.SysDeptMapper;
|
import com.ruoyi.system.mapper.VehicleInfoMapper;
|
import com.ruoyi.system.service.IVehicleInfoService;
|
import com.ruoyi.system.service.IVehicleSyncDataService;
|
import com.ruoyi.system.service.IVehicleSyncService;
|
import org.apache.commons.lang3.StringUtils;
|
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 java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 车辆同步服务实现
|
*
|
* 职责：将从 SQL Server 查询到的车辆数据同步到 MySQL
|
*
|
* 数据流向：接收 DTO → 同步到 MySQL
|
*
|
* @author ruoyi
|
* @date 2025-10-20
|
*/
|
@Service
|
public class VehicleSyncServiceImpl implements IVehicleSyncService
|
{
|
private static final Logger log = LoggerFactory.getLogger(VehicleSyncServiceImpl.class);
|
|
@Autowired
|
private IVehicleInfoService vehicleInfoService;
|
|
@Autowired
|
private SysDeptMapper sysDeptMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
|
/**
|
* 同步车辆数据到MySQL
|
*
|
* @param vehicles 从SQL Server查询的车辆列表
|
* @return 同步结果
|
*/
|
@Override
|
@Transactional
|
public AjaxResult syncVehicles(List<VehicleSyncDTO> vehicles)
|
{
|
if (vehicles == null || vehicles.isEmpty())
|
{
|
return AjaxResult.error("车辆数据为空，无法同步");
|
}
|
|
try
|
{
|
log.info("开始同步 {} 条车辆数据到 MySQL...", vehicles.size());
|
|
int insertCount = 0;
|
int updateCount = 0;
|
int skipCount = 0;
|
Map<String, String> errorMessages = new HashMap<>();
|
|
for (VehicleSyncDTO vehicleDTO : vehicles)
|
{
|
try
|
{
|
// 提取车牌号（去除括号中的内容）
|
String plateNumber = extractPlateNumber(vehicleDTO.getCarLicense());
|
|
if (StringUtils.isBlank(plateNumber))
|
{
|
log.warn("车辆 CarID={} 车牌号为空，跳过同步", vehicleDTO.getCarId());
|
skipCount++;
|
continue;
|
}
|
|
// 查询车辆是否存在
|
VehicleInfo existingVehicle = findVehicleByPlateNumber(plateNumber);
|
|
// 解析所有分公司ID（CarOrdClass可能包含多个编码，如：HB,TI）
|
List<VehicleDept> vehicleDepts = parseVehicleDepts(vehicleDTO.getCarOrdClass());
|
|
// 设置默认的主部门ID（第一个分公司）
|
Long primaryDeptId = null;
|
if (!vehicleDepts.isEmpty()) {
|
primaryDeptId = vehicleDepts.get(0).getDeptId();
|
}
|
|
if (existingVehicle != null)
|
{
|
// 更新车辆信息
|
existingVehicle.setCarId(vehicleDTO.getCarId());
|
existingVehicle.setDeptId(primaryDeptId); // 设置主部门
|
vehicleInfoService.updateVehicleInfo(existingVehicle);
|
|
// 更新车辆-分公司关联
|
syncVehicleDepts(existingVehicle.getVehicleId(), vehicleDepts);
|
|
updateCount++;
|
log.debug("更新车辆: {} (CarID={}), 关联分公司数: {}",
|
plateNumber, vehicleDTO.getCarId(), vehicleDepts.size());
|
}
|
else
|
{
|
// 新增车辆信息
|
VehicleInfo newVehicle = new VehicleInfo();
|
newVehicle.setVehicleNo(plateNumber);
|
newVehicle.setCarId(vehicleDTO.getCarId());
|
newVehicle.setDeptId(primaryDeptId); // 设置主部门
|
newVehicle.setStatus("0");
|
newVehicle.setPlatformCode("LEGACY"); // 标记为旧系统同步
|
newVehicle.setRemark("从旧系统同步，CarID: " + vehicleDTO.getCarId());
|
vehicleInfoService.insertVehicleInfo(newVehicle);
|
|
// 新增车辆-分公司关联
|
syncVehicleDepts(newVehicle.getVehicleId(), vehicleDepts);
|
|
insertCount++;
|
log.debug("新增车辆: {} (CarID={}), 关联分公司数: {}",
|
plateNumber, vehicleDTO.getCarId(), vehicleDepts.size());
|
}
|
}
|
catch (Exception e)
|
{
|
String errorMsg = String.format("同步车辆 CarID=%d 失败: %s",
|
vehicleDTO.getCarId(), e.getMessage());
|
log.error(errorMsg, e);
|
errorMessages.put("CarID_" + vehicleDTO.getCarId(), errorMsg);
|
}
|
}
|
|
String resultMsg = String.format(
|
"车辆同步完成 - 新增: %d, 更新: %d, 跳过: %d, 失败: %d",
|
insertCount, updateCount, skipCount, errorMessages.size());
|
|
log.info(resultMsg);
|
|
Map<String, Object> result = new HashMap<>();
|
result.put("insertCount", insertCount);
|
result.put("updateCount", updateCount);
|
result.put("skipCount", skipCount);
|
result.put("errorCount", errorMessages.size());
|
result.put("errors", errorMessages);
|
|
if (errorMessages.isEmpty())
|
{
|
return AjaxResult.success(resultMsg, result);
|
}
|
else
|
{
|
return AjaxResult.warn(resultMsg, result);
|
}
|
}
|
catch (Exception e)
|
{
|
log.error("同步车辆数据到 MySQL 失败", e);
|
return AjaxResult.error("同步失败: " + e.getMessage());
|
}
|
}
|
|
|
/**
|
* 提取车牌号（去除括号中的内容）
|
* 例如：浙A12345（奔驰） -> 浙A12345
|
*
|
* @param carLicense 原始车牌号
|
* @return 提取后的车牌号
|
*/
|
private String extractPlateNumber(String carLicense)
|
{
|
if (StringUtils.isBlank(carLicense))
|
{
|
return null;
|
}
|
|
// 去除空格
|
String license = carLicense.trim();
|
|
// 查找左括号位置（支持中文和英文括号）
|
int leftBracketIndex = license.indexOf('(');
|
int leftBracketIndexCn = license.indexOf('（');
|
|
// 取最小的有效括号位置
|
int bracketIndex = -1;
|
if (leftBracketIndex >= 0 && leftBracketIndexCn >= 0)
|
{
|
bracketIndex = Math.min(leftBracketIndex, leftBracketIndexCn);
|
}
|
else if (leftBracketIndex >= 0)
|
{
|
bracketIndex = leftBracketIndex;
|
}
|
else if (leftBracketIndexCn >= 0)
|
{
|
bracketIndex = leftBracketIndexCn;
|
}
|
|
// 如果找到括号，截取括号前的部分；否则返回原字符串
|
if (bracketIndex > 0)
|
{
|
return license.substring(0, bracketIndex).trim();
|
}
|
|
return license;
|
}
|
|
/**
|
* 根据车牌号查找车辆（模糊匹配）
|
*
|
* @param plateNumber 车牌号
|
* @return 车辆信息
|
*/
|
private VehicleInfo findVehicleByPlateNumber(String plateNumber)
|
{
|
// 先尝试精确匹配
|
VehicleInfo vehicle = vehicleInfoService.selectVehicleInfoByPlateNumber(plateNumber);
|
|
if (vehicle != null)
|
{
|
return vehicle;
|
}
|
|
// 如果精确匹配失败，尝试模糊匹配（查询所有车辆，找到包含该车牌号的）
|
VehicleInfo query = new VehicleInfo();
|
List<VehicleInfo> allVehicles = vehicleInfoService.selectVehicleInfoList(query);
|
|
for (VehicleInfo v : allVehicles)
|
{
|
if (StringUtils.isNotBlank(v.getVehicleNo()))
|
{
|
// 如果数据库中的车牌号包含查询的车牌号，或查询的车牌号包含数据库中的车牌号
|
String dbPlateNumber = extractPlateNumber(v.getVehicleNo());
|
if (plateNumber.contains(dbPlateNumber) || dbPlateNumber.contains(plateNumber))
|
{
|
return v;
|
}
|
}
|
}
|
|
return null;
|
}
|
|
/**
|
* 从 CarOrdClass 解析多个分公司关联
|
* CarOrdClass格式可能是：HB、HB,TI、HB.TI等
|
*
|
* @param carOrdClass 车辆单据类型编码
|
* @return 车辆-分公司关联列表
|
*/
|
private List<VehicleDept> parseVehicleDepts(String carOrdClass)
|
{
|
List<VehicleDept> vehicleDepts = new ArrayList<>();
|
|
if (StringUtils.isBlank(carOrdClass))
|
{
|
log.debug("CarOrdClass为空，无法解析分公司");
|
return vehicleDepts;
|
}
|
|
// 拆分CarOrdClass，可能的分隔符：, . 空格
|
String[] codes = carOrdClass.split("[.,\\s]+");
|
|
for (String code : codes)
|
{
|
if (StringUtils.isBlank(code))
|
{
|
continue;
|
}
|
|
code = code.trim();
|
|
// 查询匹配dispatch_order_class或service_order_class的部门
|
SysDept dept = findDeptByOrderClass(code);
|
if (dept != null && dept.getParentId() != null && dept.getParentId() == 100L)
|
{
|
// 只处理分公司（parent_id=100）
|
VehicleDept vehicleDept = new VehicleDept();
|
vehicleDept.setDeptId(dept.getDeptId());
|
vehicleDept.setOrderClass(code);
|
vehicleDept.setCreateBy("system");
|
vehicleDepts.add(vehicleDept);
|
|
log.debug("通过order_class='{}' 找到分公司: {} (ID={})",
|
code, dept.getDeptName(), dept.getDeptId());
|
}
|
else
|
{
|
log.debug("未找到匹配order_class='{}' 的分公司", code);
|
}
|
}
|
|
return vehicleDepts;
|
}
|
|
/**
|
* 同步车辆-分公司关联
|
*
|
* @param vehicleId 车辆ID
|
* @param vehicleDepts 分公司关联列表
|
*/
|
private void syncVehicleDepts(Long vehicleId, List<VehicleDept> vehicleDepts)
|
{
|
if (vehicleId == null || vehicleDepts == null)
|
{
|
return;
|
}
|
|
// 先删除旧的关联
|
vehicleInfoMapper.deleteVehicleDeptByVehicleId(vehicleId);
|
|
// 再插入新的关联
|
if (!vehicleDepts.isEmpty())
|
{
|
for (VehicleDept vd : vehicleDepts)
|
{
|
vd.setVehicleId(vehicleId);
|
}
|
vehicleInfoMapper.batchInsertVehicleDept(vehicleDepts);
|
log.debug("同步车辆ID={} 的分公司关联，数量: {}", vehicleId, vehicleDepts.size());
|
}
|
}
|
|
/**
|
* 根据order_class查询部门（同时匹配dispatch_order_class和service_order_class）
|
*
|
* @param orderClass 编码
|
* @return 部门信息
|
*/
|
private SysDept findDeptByOrderClass(String orderClass)
|
{
|
if (StringUtils.isBlank(orderClass))
|
{
|
return null;
|
}
|
|
try
|
{
|
// 先尝试匹配dispatch_order_class
|
SysDept query = new SysDept();
|
query.setDispatchOrderClass(orderClass);
|
List<SysDept> depts = sysDeptMapper.selectDeptList(query);
|
|
if (depts != null && !depts.isEmpty())
|
{
|
return depts.get(0);
|
}
|
|
// 如果没有找到，尝试匹配service_order_class
|
query = new SysDept();
|
query.setServiceOrderClass(orderClass);
|
depts = sysDeptMapper.selectDeptList(query);
|
|
if (depts != null && !depts.isEmpty())
|
{
|
return depts.get(0);
|
}
|
}
|
catch (Exception e)
|
{
|
log.error("查询order_class='{}' 的部门失败", orderClass, e);
|
}
|
|
return null;
|
}
|
}
|
