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.VehicleSyncDTO;
|
import com.ruoyi.system.mapper.SysDeptMapper;
|
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.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;
|
|
|
/**
|
* 同步车辆数据到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);
|
|
// 解析部门信息
|
Long deptId = parseDeptIdFromCarOrdClass(vehicleDTO.getCarOrdClass());
|
|
if (existingVehicle != null)
|
{
|
// 更新车辆信息
|
existingVehicle.setCarId(vehicleDTO.getCarId());
|
existingVehicle.setDeptId(deptId);
|
// 可以选择是否更新其他字段
|
vehicleInfoService.updateVehicleInfo(existingVehicle);
|
updateCount++;
|
log.debug("更新车辆: {} (CarID={}), 部门ID={}", plateNumber, vehicleDTO.getCarId(), deptId);
|
}
|
else
|
{
|
// 新增车辆信息
|
VehicleInfo newVehicle = new VehicleInfo();
|
newVehicle.setVehicleNo(plateNumber);
|
newVehicle.setCarId(vehicleDTO.getCarId());
|
newVehicle.setDeptId(deptId);
|
newVehicle.setStatus("0");
|
newVehicle.setPlatformCode("LEGACY"); // 标记为旧系统同步
|
newVehicle.setRemark("从旧系统同步，CarID: " + vehicleDTO.getCarId());
|
vehicleInfoService.insertVehicleInfo(newVehicle);
|
insertCount++;
|
log.debug("新增车辆: {} (CarID={}), 部门ID={}", plateNumber, vehicleDTO.getCarId(), deptId);
|
}
|
}
|
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 解析部门ID，并转换为分公司ID
|
* CarOrdClass格式可能是：ZB、HB.TI等
|
* 需要拆分并在sys_dept中匹配dispatch_order_class字段
|
*
|
* @param carOrdClass 车辆单据类型编码
|
* @return 分公司ID，如果未找到返回null
|
*/
|
private Long parseDeptIdFromCarOrdClass(String carOrdClass)
|
{
|
if (StringUtils.isBlank(carOrdClass))
|
{
|
log.debug("CarOrdClass为空，无法解析部门");
|
return null;
|
}
|
|
// 拆分CarOrdClass，可能的分隔符：. , 空格
|
String[] codes = carOrdClass.split("[.,\\s]+");
|
|
for (String code : codes)
|
{
|
if (StringUtils.isBlank(code))
|
{
|
continue;
|
}
|
|
code = code.trim();
|
|
// 查询匹配dispatch_order_class的部门
|
SysDept dept = findDeptByDispatchOrderClass(code);
|
if (dept != null)
|
{
|
log.debug("通过dispatch_order_class='{}' 找到部门: {} (ID={})",
|
code, dept.getDeptName(), dept.getDeptId());
|
|
// 将部门ID转换为分公司ID
|
Long branchCompanyId = sysDeptMapper.selectBranchCompanyIdByDeptId(dept.getDeptId());
|
if (branchCompanyId != null)
|
{
|
log.debug("将部门ID {} 转换为分公司ID: {}", dept.getDeptId(), branchCompanyId);
|
return branchCompanyId;
|
}
|
else
|
{
|
log.warn("部门ID {} 无法转换为分公司ID，可能是总公司或数据异常", dept.getDeptId());
|
return null;
|
}
|
}
|
}
|
|
log.warn("未找到匹配CarOrdClass='{}' 的部门", carOrdClass);
|
return null;
|
}
|
|
/**
|
* 根据dispatch_order_class查询部门
|
*
|
* @param dispatchOrderClass 调度单编码
|
* @return 部门信息
|
*/
|
private SysDept findDeptByDispatchOrderClass(String dispatchOrderClass)
|
{
|
if (StringUtils.isBlank(dispatchOrderClass))
|
{
|
return null;
|
}
|
|
try
|
{
|
SysDept query = new SysDept();
|
query.setDispatchOrderClass(dispatchOrderClass);
|
List<SysDept> depts = sysDeptMapper.selectDeptList(query);
|
|
if (depts != null && !depts.isEmpty())
|
{
|
// 返回第一个匹配的部门
|
return depts.get(0);
|
}
|
}
|
catch (Exception e)
|
{
|
log.error("查询dispatch_order_class='{}' 的部门失败", dispatchOrderClass, e);
|
}
|
|
return null;
|
}
|
}
|
