package com.ruoyi.api.third.controller;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import cn.hutool.json.JSONUtil;
|
import com.ruoyi.cwgl.domain.DispatchOrder;
|
import com.ruoyi.tms.mapper.*;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.common.core.controller.BaseController;
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import com.ruoyi.common.core.domain.entity.SysDictData;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.api.third.util.ApiAuthUtil;
|
import com.ruoyi.system.mapper.SysDictDataMapper;
|
import com.ruoyi.tms.domain.*;
|
import com.ruoyi.tms.domain.vo.*;
|
import com.ruoyi.tms.service.ITmsDispatchOrderService;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletRequest;
|
|
/**
|
* AI调度专用第三方接口 (无需权限, 使用appId/secret认证)
|
*
|
* @author ruoyi
|
* @date 2026-03-06
|
*/
|
@RestController
|
@RequestMapping("/api/third/aiDispatch")
|
public class TmsAiDispatchController extends BaseController
|
{
|
@Resource
|
private TransportRouteViMapper transportRouteViMapper;
|
|
@Resource
|
private TmsCustomerInfoMapper tmsCustomerInfoMapper;
|
|
@Resource
|
private TmsServiceProviderMapper tmsServiceProviderMapper;
|
|
@Resource
|
private TmsDriverMapper tmsDriverMapper;
|
|
@Resource
|
private TmsVehicleMapper tmsVehicleMapper;
|
|
@Resource
|
private TmsConsignorMapper tmsConsignorMapper;
|
|
@Autowired
|
private ITmsDispatchOrderService tmsDispatchOrderService;
|
|
@Autowired
|
private SysDictDataMapper sysDictDataMapper;
|
|
@Autowired
|
private ApiAuthUtil apiAuthUtil;
|
|
/**
|
* 验证客户是否存在，且返回客户信息接口
|
* @param customerName
|
* @return
|
*/
|
@GetMapping("/getCustomerData")
|
public AjaxResult getCustomerData( @RequestParam(value = "customerName", required = true) String customerName){
|
logger.info("getCustomerData:{}",customerName);
|
TmsCustomerInfo tmsCustomerInfo = tmsCustomerInfoMapper.selectOne(new LambdaQueryWrapper<TmsCustomerInfo>()
|
.like(TmsCustomerInfo::getCustomerFullName, customerName)
|
.last("limit 1")
|
);
|
if (tmsCustomerInfo == null){
|
return error("客户不存在");
|
}else{
|
return AjaxResult.success(tmsCustomerInfo);
|
}
|
|
}
|
|
/**
|
* 验证车辆是否存在，且返回车辆信息接口
|
* @param licensePlate
|
* @param licenseHk
|
* @param licenseMo
|
* @return
|
*/
|
@GetMapping("/getVehicleData")
|
public AjaxResult getVehicleData(
|
@RequestParam(value = "licensePlate", required = false) String licensePlate,
|
@RequestParam(value = "licenseHk", required = false) String licenseHk,
|
@RequestParam(value = "licenseMo", required = false) String licenseMo
|
){
|
logger.info("getVehicleData:{},{},{}",licensePlate,licenseHk,licenseMo);
|
|
TmsVehicle tmsCustomerInfo = tmsVehicleMapper.selectOne(new LambdaQueryWrapper<TmsVehicle>()
|
.like(StringUtils.isNotEmpty(licensePlate),TmsVehicle::getLicensePlate, licensePlate)
|
.like(StringUtils.isNotEmpty(licenseHk),TmsVehicle::getLicenseHk, licenseHk)
|
.like(StringUtils.isNotEmpty(licenseMo),TmsVehicle::getLicenseMo, licenseMo)
|
.last("limit 1")
|
);
|
if (tmsCustomerInfo == null){
|
return error("车辆不存在");
|
}else{
|
return AjaxResult.success(tmsCustomerInfo);
|
}
|
|
}
|
|
|
/**
|
* 获取司机接口 (公开接口, 无需认证)
|
* 支持按名称筛选
|
*
|
* @param driverName 司机名称(可选，模糊查询)
|
* @return 司机列表
|
*/
|
@GetMapping("/getDriverData")
|
public AjaxResult getDriverData(
|
@RequestParam(value = "driverName", required = true) String driverName)
|
{
|
logger.info("getVehicleData:{}",driverName);
|
|
TmsDriver tmsDriver = tmsDriverMapper.selectOne(new LambdaQueryWrapper<TmsDriver>()
|
.like(TmsDriver::getDriverName, driverName)
|
.last("limit 1")
|
);
|
|
if (tmsDriver == null){
|
return error("司机信息不存在");
|
}else{
|
return AjaxResult.success(tmsDriver);
|
}
|
|
}
|
@GetMapping("/getVehicleProviderData")
|
public AjaxResult getVehicleProviderData(
|
@RequestParam(value = "serviceName", required = true) String serviceName)
|
{
|
logger.info("getVehicleProviderData:{}",serviceName);
|
|
TmsServiceProvider provider = tmsServiceProviderMapper.selectOne(new LambdaQueryWrapper<TmsServiceProvider>()
|
.like(TmsServiceProvider::getServiceName, serviceName)
|
.last("limit 1")
|
);
|
|
if (provider == null){
|
return error("车辆服务商信息不存在");
|
}else{
|
return AjaxResult.success(provider);
|
}
|
|
}
|
|
@GetMapping("/getConsignorData")
|
public AjaxResult getConsignorData(
|
@RequestParam(value = "consignorName", required = true) String consignorName,
|
@RequestParam(value = "customerName", required = true) String customerName)
|
{
|
logger.info("getConsignorData:{}",consignorName);
|
|
TmsConsignor tmsConsignor = tmsConsignorMapper.selectOne(new LambdaQueryWrapper<TmsConsignor>()
|
.like(TmsConsignor::getConsignorName, consignorName)
|
.eq(TmsConsignor::getCustomerName, customerName)
|
.last("limit 1")
|
);
|
|
if (tmsConsignor == null){
|
return error("装卸货点不存在");
|
}else{
|
return AjaxResult.success(tmsConsignor);
|
}
|
}
|
|
|
|
/**
|
* 路线验证接口 (需要appId/secret认证)
|
*
|
* @param vo 路线验证请求
|
* @param request HTTP请求
|
* @return 验证结果
|
*/
|
@PostMapping("/validateRoute")
|
public AjaxResult validateRoute(@RequestBody RouteValidationVO vo, HttpServletRequest request)
|
{
|
logger.info("validateRoute:{}", JSONUtil.toJsonStr(vo));
|
AiValidationResultVO result = new AiValidationResultVO();
|
List<String> errors = new ArrayList<>();
|
List<String> warnings = new ArrayList<>();
|
|
// 验证必填字段
|
if (StringUtils.isEmpty(vo.getOriginCity())) {
|
errors.add("起始城市不能为空");
|
}
|
if (StringUtils.isEmpty(vo.getDestCity())) {
|
errors.add("目的地城市不能为空");
|
}
|
if (StringUtils.isEmpty(vo.getVehicleType())) {
|
errors.add("车辆类型不能为空");
|
}
|
|
// 如果有错误，直接返回
|
if (!errors.isEmpty()) {
|
result.setIsValid(false);
|
result.setErrors(errors);
|
result.setWarnings(warnings);
|
return success(result);
|
}
|
|
// 查询匹配的路线
|
LambdaQueryWrapper<TransportRouteVi> wrapper = new LambdaQueryWrapper<>();
|
if (StringUtils.isNotEmpty(vo.getOriginCity())) {
|
wrapper.like(TransportRouteVi::getTransportRoute, vo.getOriginCity());
|
}
|
if (StringUtils.isNotEmpty(vo.getDestCity())) {
|
wrapper.like(TransportRouteVi::getTransportRoute, vo.getDestCity());
|
}
|
wrapper.eq(TransportRouteVi::getVehicleType, vo.getVehicleType());
|
wrapper.eq(TransportRouteVi::getCustomerFullName, vo.getCustomerName());
|
|
List<TransportRouteVi> routes = transportRouteViMapper.selectList(wrapper);
|
|
Map<String, Object> data = new HashMap<>();
|
data.put("matchedRoutes", routes);
|
data.put("routeCount", routes.size());
|
|
if (routes.isEmpty()) {
|
warnings.add("未找到匹配的运输路线");
|
}
|
|
result.setIsValid(routes.size() > 0);
|
result.setErrors(errors);
|
result.setWarnings(warnings);
|
result.setData(data);
|
|
return success(result);
|
}
|
|
/**
|
* 创建调度单接口 (AI优化版, 需要appId/secret认证)
|
*
|
* @param vo AI调度单请求对象
|
* @param request HTTP请求
|
* @return 创建结果
|
*/
|
@PostMapping("/createOrder")
|
public AjaxResult createOrder(@RequestBody TmsDispatchOrder order, HttpServletRequest request)
|
{
|
// appId/secret 认证
|
if (!apiAuthUtil.validateAppAuth(request)) {
|
return apiAuthUtil.getUnauthorizedResult();
|
}
|
|
try {
|
// 验证必填字段
|
if (order.getMainDriverId() == null || order.getLicensePlate() == null) {
|
return error("派车信息不能为空");
|
}
|
// 设置初始状态为待分配 (0)
|
order.setStatus(0);
|
|
// 保存订单
|
int result = tmsDispatchOrderService.insertTmsDispatchOrder2(order);
|
|
if (result > 0) {
|
// 返回新创建的订单信息
|
Map<String, Object> data = new HashMap<>();
|
data.put("orderNo", order.getDispatchNo());
|
data.put("customerName", order.getCustomerName());
|
data.put("originCity", order.getShipperRegionLabel());
|
data.put("destCity", order.getReceiverRegionLabel());
|
data.put("cargoName", order.getCargoName());
|
data.put("status", order.getStatus());
|
return success(data);
|
} else {
|
return error("创建调度单失败");
|
}
|
} catch (Exception e) {
|
logger.error("创建调度单异常: ", e);
|
return error("创建调度单异常: " + e.getMessage());
|
}
|
}
|
|
/**
|
* 获取字典数据接口 (公开接口, 无需认证)
|
* 支持多个字典类型，用逗号分隔
|
*
|
* @param dictTypes 字典类型，逗号分隔
|
* @return 字典数据
|
*/
|
@GetMapping("/getDictData")
|
public AjaxResult getDictData(@RequestParam(value = "dictTypes", required = false) String dictTypes)
|
{
|
Map<String, List<DictDataVO>> dictDataMap = new HashMap<>();
|
|
if (StringUtils.isNotEmpty(dictTypes)) {
|
String[] types = dictTypes.split(",");
|
for (String type : types) {
|
String trimmedType = type.trim();
|
// 调用Mapper按字典类型查询字典数据
|
List<SysDictData> dictDataList = sysDictDataMapper.selectDictDataByType(trimmedType);
|
|
// 转换为VO列表
|
List<DictDataVO> voList = new ArrayList<>();
|
if (dictDataList != null && !dictDataList.isEmpty()) {
|
voList = dictDataList.stream().map(dictData -> {
|
DictDataVO vo = new DictDataVO(
|
dictData.getDictLabel(),
|
dictData.getDictValue(),
|
dictData.getDictType()
|
);
|
return vo;
|
}).collect(Collectors.toList());
|
}
|
|
dictDataMap.put(trimmedType, voList);
|
}
|
}
|
|
return success(dictDataMap);
|
}
|
|
|
|
/**
|
* 批量验证订单数据接口 (需要appId/secret认证)
|
*
|
* @param orders 调度单列表
|
* @param request HTTP请求
|
* @return 验证结果
|
*/
|
@PostMapping("/batchValidateOrders")
|
public AjaxResult batchValidateOrders(@RequestBody List<AiDispatchOrderVO> orders, HttpServletRequest request)
|
{
|
// appId/secret 认证
|
if (!apiAuthUtil.validateAppAuth(request)) {
|
return apiAuthUtil.getUnauthorizedResult();
|
}
|
|
List<Map<String, Object>> validationResults = new ArrayList<>();
|
|
for (int i = 0; i < orders.size(); i++) {
|
AiDispatchOrderVO order = orders.get(i);
|
Map<String, Object> result = new HashMap<>();
|
|
result.put("index", i);
|
result.put("customerName", order.getCustomerName());
|
|
List<String> errors = new ArrayList<>();
|
|
// 验证必填字段
|
if (StringUtils.isEmpty(order.getCustomerName())) {
|
errors.add("客户名称不能为空");
|
}
|
if (StringUtils.isEmpty(order.getOriginCity())) {
|
errors.add("起始城市不能为空");
|
}
|
if (StringUtils.isEmpty(order.getDestCity())) {
|
errors.add("目的地城市不能为空");
|
}
|
if (StringUtils.isEmpty(order.getLoadingDate())) {
|
errors.add("装车日期不能为空");
|
}
|
|
result.put("isValid", errors.isEmpty());
|
result.put("errors", errors);
|
|
validationResults.add(result);
|
}
|
|
Map<String, Object> response = new HashMap<>();
|
response.put("totalCount", orders.size());
|
response.put("validCount", validationResults.stream()
|
.filter(r -> (Boolean) r.get("isValid"))
|
.count());
|
response.put("invalidCount", validationResults.stream()
|
.filter(r -> !(Boolean) r.get("isValid"))
|
.count());
|
response.put("details", validationResults);
|
|
return success(response);
|
}
|
}
|
