package com.ruoyi.buss.controller;
|
|
|
import com.ruoyi.buss.common.DateUtils;
|
import com.ruoyi.buss.common.RfidUtil;
|
import com.ruoyi.buss.domain.*;
|
import com.ruoyi.buss.domain.dto.AllocBerthReqDTO;
|
import com.ruoyi.buss.domain.dto.AllocBerthTimeReqDTO;
|
import com.ruoyi.buss.domain.dto.DsTaskQueryParam;
|
import com.ruoyi.buss.domain.dto.TaskQueryParam;
|
import com.ruoyi.buss.domain.vo.RfIdVo;
|
import com.ruoyi.buss.service.*;
|
import com.ruoyi.common.annotation.Log;
|
import com.ruoyi.common.core.controller.BaseController;
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import com.ruoyi.common.enums.BusinessType;
|
import com.ruoyi.common.utils.StringUtils;
|
import io.swagger.v3.oas.annotations.Operation;
|
import io.swagger.v3.oas.annotations.Parameter;
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.web.bind.annotation.*;
|
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
@Tag(name = "支队任务接口")
|
@RestController
|
@RequestMapping("/buss/tasklist/ex")
|
public class DMTaskTimeController extends BaseController {
|
|
@Autowired
|
private IDsTaskService iDsTaskService;
|
@Autowired
|
private IDsTaskList2Service iDsTaskListService;
|
@Autowired
|
private IDmBerth2Service dmBerthService;
|
@Autowired
|
private IDmHarbor2Service dmHarborService;
|
@Autowired
|
private IDmDdConfigService iDmDdConfigService;
|
@Autowired
|
private IDsTaskDetailService iDsTaskDetailService;
|
|
@Value("${ruoyi.buss.rfid.url:http://192.168.0.2:10800/open/goods/task}")
|
private String rfidUrl;
|
|
private static String WATER_FLAG = "water";
|
private static String MATER_FLAG = "mater";
|
private static String OIL_FLAG = "oil";
|
private static String AMMO_FLAG = "ammo";
|
private static String AMMO_O_FLAG = "ammo_o";
|
|
|
@Operation(summary = "获取本支队所有任务列表")
|
@PostMapping("/histask/list")
|
@ResponseBody
|
public AjaxResult getTaskList(@RequestBody DsTaskQueryParam param) {
|
if(null != param.getEtime()){
|
param.setEtime(DateUtils.setToNextDayZero(param.getEtime()));
|
}
|
List<DsTask> dsTaskList = iDsTaskService.selectDsTaskListByParam(param);
|
return success(dsTaskList);
|
}
|
|
@Operation(summary = "支队任务下发")
|
@Log(title = "支队任务下发", businessType = BusinessType.UPDATE)
|
@PostMapping("/apply/{taskid}/{deptid}")
|
@ResponseBody
|
public AjaxResult apply(@Parameter(name = "taskid", required = true, description = "任务编号") @PathVariable("taskid") Long taskid,
|
@Parameter(name = "deptid", required = true, description = "部门ID") @PathVariable("deptid") Long deptid,
|
@Parameter(name = "ids", required = false, description = "任务Ids") @RequestParam(value = "ids", required = false) String ids) {
|
TaskQueryParam queryParam = new TaskQueryParam();
|
if(null != taskid){
|
queryParam.setTaskId(taskid);
|
}
|
queryParam.setDeptId(deptid);
|
queryParam.setStatus("1");
|
|
if(StringUtils.isNotBlank(ids)){
|
List<Long> idList = Arrays.stream(ids.split(","))
|
.map(Long::valueOf)
|
.collect(Collectors.toList());
|
if(null != idList && idList.size() > 0){
|
queryParam.setIds(idList);
|
}
|
}
|
|
List<DsTaskList2> dsTaskList = iDsTaskListService.selectDsTaskListByParam(queryParam);
|
if(null == dsTaskList || dsTaskList.size() == 0){
|
return error("未获取到对应的任务");
|
}
|
|
|
// 获取所有的泊位信息
|
List<DmBerth2> berth2List = dmBerthService.selectDmBerthList(new DmBerth2());
|
|
Map<Long, DmBerth2> berth2Map = berth2List.stream().collect(Collectors.toMap(DmBerth2::getPKID, berth -> berth));
|
|
|
List<DsTaskList2> taskToUpdate = dsTaskList.stream().map(tmp -> {
|
tmp.setStatus("2");
|
DmBerth2 berth2 = berth2Map.get(tmp.getPKID());
|
if(null != berth2){
|
tmp.setPath(berth2.getPath());
|
}
|
return tmp;
|
}).collect(Collectors.toList());
|
|
if(!taskToUpdate.isEmpty()){
|
iDsTaskListService.batchUpdateDsTaskList(taskToUpdate);
|
}
|
|
List<RfIdVo> rfIdVoList = new ArrayList<>();
|
//rfIdVoList.add(new RfIdVo(Integer.valueOf(task.getShipNo()), task.getShipNo()+"舰艇补给任务", task.getPath()));
|
|
// 推送数据到 RFID
|
// try{
|
// RfidUtil.asyncSendJsonPost(rfidUrl, rfIdVoList);
|
// }catch (Exception e){e.printStackTrace();}
|
|
// 更新Detail 路径规划
|
this.updateDetailPath(taskid, deptid, berth2List);
|
|
DsTaskList2 tmpTaskList = new DsTaskList2();
|
tmpTaskList.setStatus("1");
|
tmpTaskList.setTaskId(taskid);
|
List<DsTaskList2> taskList2List = iDsTaskListService.selectDsTaskListList(tmpTaskList);
|
|
if(null != taskList2List && taskList2List.size() > 0){
|
DsTask dsTask = iDsTaskService.selectDsTaskByPKID(taskid);
|
dsTask.setStatus("2");
|
iDsTaskService.updateDsTask(dsTask);
|
return success("下发成功");
|
}
|
|
|
return error("下发失败，请重试");
|
}
|
|
|
@Operation(summary = "支队任务下发")
|
@Log(title = "支队任务下发", businessType = BusinessType.UPDATE)
|
@PostMapping("/apply/{deptid}")
|
@ResponseBody
|
public AjaxResult applyV2(@Parameter(name = "taskid", required = true, description = "任务编号") @RequestParam("taskid") Long taskid,
|
@Parameter(name = "deptid", required = true, description = "部门ID") @PathVariable("deptid") Long deptid,
|
@Parameter(name = "ids", required = true, description = "任务Ids") @RequestParam("ids") String ids) {
|
TaskQueryParam queryParam = new TaskQueryParam();
|
if(null != taskid){
|
queryParam.setTaskId(taskid);
|
}
|
queryParam.setDeptId(deptid);
|
queryParam.setStatus("1");
|
|
if(StringUtils.isNotBlank(ids)){
|
List<Long> idList = Arrays.stream(ids.split(","))
|
.map(Long::valueOf)
|
.collect(Collectors.toList());
|
if(null != idList && idList.size() > 0){
|
queryParam.setIds(idList);
|
}
|
}
|
|
List<DsTaskList2> dsTaskList = iDsTaskListService.selectDsTaskListByParam(queryParam);
|
|
if(null == dsTaskList || dsTaskList.size() == 0){
|
return error("未获取到对应的任务");
|
}
|
|
int flag = 1;
|
for (DsTaskList2 task : dsTaskList) {
|
task.setStatus("2");
|
int updateResult = iDsTaskListService.updateDsTaskList(task);
|
if (updateResult != 1) {
|
flag = 0;
|
break;
|
}
|
}
|
DsTaskList2 tmpTaskList = new DsTaskList2();
|
tmpTaskList.setStatus("1");
|
tmpTaskList.setTaskId(taskid);
|
List<DsTaskList2> taskList2List = iDsTaskListService.selectDsTaskListList(tmpTaskList);
|
if(null != taskList2List && taskList2List.size() == 0){
|
DsTask dsTask = iDsTaskService.selectDsTaskByPKID(taskid);
|
dsTask.setStatus("2");
|
iDsTaskService.updateDsTask(dsTask);
|
}
|
|
if(flag == 1){
|
return success("下发成功");
|
}
|
return error("下发失败，请重试");
|
}
|
|
|
@Operation(summary = "获取最新下发的任务列表")
|
@GetMapping("/task")
|
@ResponseBody
|
public AjaxResult getByTaskId(@Parameter(name = "deptId", description = "部门编码") Long deptId) {
|
if(null == deptId)deptId = getDeptId();
|
// 获取支队正在进行的任务
|
// DsTask taskEntity = new DsTask();
|
// taskEntity.setStatus("1"); // 1 状态为 支队 2 状态为 完成状态。
|
// List<DsTask> tasks = iDsTaskService.selectDsTaskList(taskEntity);
|
// if(null != tasks && tasks.size() > 0){
|
// DsTask curTask = tasks.get(0);
|
DsTaskList2 taskListEntity = new DsTaskList2();
|
// taskListEntity.setTaskId(curTask.getPKID());
|
taskListEntity.setDeptId(deptId);
|
taskListEntity.setStatus("1");
|
List<DsTaskList2> dsTaskList2s = iDsTaskListService.selectDsTaskListList(taskListEntity);
|
return success(dsTaskList2s);
|
// }
|
// return success();
|
}
|
|
/**
|
* 查询泊位信息列表
|
*/
|
@Operation(summary = "查询泊位信息列表")
|
@GetMapping("/berth/list")
|
@ResponseBody
|
public AjaxResult dmBerthList(@Parameter(name = "deptId", description = "部门编码") Long deptId) {
|
if(null == deptId)deptId = getDeptId();
|
if(null == deptId){
|
return error("获取当前用户信息失败，请重新登录后尝试。");
|
}
|
DmHarbor2 harbor = new DmHarbor2();
|
harbor.setDeptId(deptId);
|
List<DmHarbor2> harborList = dmHarborService.selectDmHarborList(harbor);
|
List<Long> tmpHarborIds = new ArrayList<>();
|
harborList.stream().forEach(item -> {
|
tmpHarborIds.add(item.getPKID());
|
});
|
List<DmBerth2> list = dmBerthService.selectDmBerthByHarborIdsAndStatus(tmpHarborIds);
|
|
list = list.stream()
|
.filter(task -> task.getDEPTH() != null)
|
.sorted(Comparator.comparing(DmBerth2::getHarborId).thenComparing(DmBerth2::getOrderNum))
|
.collect(Collectors.toList());
|
|
return success(list);
|
}
|
|
@Operation(summary = "查询码头信息详情")
|
@GetMapping("/harbor/id/{harborid}")
|
@ResponseBody
|
public AjaxResult dmBerthById(@Parameter(name = "harborid", description = "码头编码") @PathVariable("harborid") Long harborid) {
|
return success(dmHarborService.selectDmHarborByPKID(harborid));
|
}
|
|
/**
|
* 码头调度分配接口
|
*
|
*/
|
@Operation(summary = "码头调度分配")
|
@PostMapping("/allocation")
|
@ResponseBody
|
public AjaxResult allocation(@RequestBody AllocBerthReqDTO reqDTO) {
|
Long deptId = getDeptId();
|
if(null != reqDTO.getDeptId()){
|
deptId =reqDTO.getDeptId();
|
}
|
|
if(null == reqDTO.getTaskId()){
|
return error("任务编码不能为空");
|
}
|
|
if(StringUtils.isBlank(reqDTO.getBerthids())){
|
return error("泊位编号不能为空");
|
}
|
DsTaskList2 dsTaskList2Entity = new DsTaskList2();
|
dsTaskList2Entity.setTaskId(reqDTO.getTaskId());
|
dsTaskList2Entity.setDeptId(deptId);
|
List<DsTaskList2> taskLists = iDsTaskListService.selectDsTaskListList(dsTaskList2Entity);
|
if(taskLists.size() == 0){
|
return error("所选舰艇为空，请重新检查参数");
|
}
|
|
return success(allocationBerth(taskLists, reqDTO.getRule(), reqDTO.getBerthids()));
|
}
|
|
/**
|
* 新增保存任务列表信息
|
*/
|
@Operation(summary = "泊位调配信息更新接口")
|
@Log(title = "泊位调配信息更新接口", businessType = BusinessType.UPDATE)
|
@PostMapping("/tasklist/update")
|
@ResponseBody
|
public AjaxResult addTaskListSave(@RequestBody List<DsTaskList2> taskList) {
|
// 缺少数据非空以及合法性校验
|
|
List<Long> pkidList = taskList.stream()
|
.map(DsTaskList2::getPKID)
|
.collect(Collectors.toList());
|
|
List<DsTaskList2> existingTaskLists = iDsTaskListService.selectDsTaskListByPkids(pkidList);
|
|
for (DsTaskList2 existingTask : existingTaskLists) {
|
for (DsTaskList2 newTask : taskList) {
|
if (existingTask.getPKID().equals(newTask.getPKID())) {
|
existingTask.setBerthId(newTask.getBerthId());
|
existingTask.setBerthName(newTask.getBerthName());
|
existingTask.setUpdateBy(getUsername());
|
iDsTaskListService.updateDsTaskList(existingTask);
|
}
|
}
|
}
|
return success("更新成功");
|
}
|
|
/**
|
* 码头调度分配接口
|
*
|
*/
|
@Operation(summary = "泊位补给计划分配")
|
@PostMapping("/berth/alloc")
|
@ResponseBody
|
public AjaxResult berthAllocation(@RequestBody AllocBerthTimeReqDTO reqDTO) {
|
//获取当前用户部门编号
|
Long deptId = getDeptId();
|
if(null != reqDTO.getDeptId()){
|
deptId = reqDTO.getDeptId();
|
}
|
if(null == reqDTO.getTaskId()){
|
return error("任务编号不能为空");
|
}
|
|
DsTaskList2 dsTaskList2Entity = new DsTaskList2();
|
dsTaskList2Entity.setTaskId(reqDTO.getTaskId());
|
dsTaskList2Entity.setDeptId(deptId);
|
List<DsTaskList2> taskLists = iDsTaskListService.selectDsTaskListList(dsTaskList2Entity);
|
if(taskLists.size() == 0){
|
return error("当前无任务，请重新检查参数");
|
}
|
// 重新组织数据结构，然后发送
|
return success(allocationBerthTime(taskLists, reqDTO.getRule()));
|
}
|
|
|
/**
|
* 舰艇分组
|
* @param list
|
* @param rule
|
* @param berthids
|
* @return
|
*/
|
private List<DsTaskList2> allocationBerth(List<DsTaskList2> list, String rule, String berthids){
|
List<DsTaskList2> resultTask = new ArrayList<>();
|
String[] berthArr = berthids.split(",");
|
|
if(null != list && list.size() > 0){
|
switch (rule){
|
case "JTXH": //按舰艇型号
|
case "DYYX": //按弹药优先
|
case "YXSX": //按优先顺序
|
case "RGFZ": //按人工分组
|
default:
|
if(null != berthArr && berthArr.length > 0){
|
|
Map<Long, List<DmBerth2>> harborBerthMap = new HashMap<>();
|
|
List<Long> berthIdList = Arrays.stream(berthArr)
|
.map(Long::valueOf)
|
.collect(Collectors.toList());
|
List<DmBerth2> berthList = dmBerthService.selectDmBerthByHarborIds(berthIdList);
|
|
for (DmBerth2 dmBerth2 : berthList) {
|
if (dmBerth2 != null) {
|
harborBerthMap.computeIfAbsent(dmBerth2.getHarborId(), k -> new ArrayList<>()).add(dmBerth2);
|
}
|
}
|
|
for (DsTaskList2 task : list) {
|
Long harborId = task.getHarborId();
|
List<DmBerth2> availableBerths = harborBerthMap.get(harborId);
|
if (availableBerths != null && !availableBerths.isEmpty()) {
|
DmBerth2 assignedBerth = availableBerths.remove(0);
|
task.setBerthId(assignedBerth.getPKID());
|
task.setBerthName(assignedBerth.getNAME());
|
resultTask.add(task);
|
} else {
|
// 如果没有可用的泊位则继续按照原来的逻辑重复分配
|
for (Map.Entry<Long, List<DmBerth2>> entry : harborBerthMap.entrySet()) {
|
if (!entry.getValue().isEmpty()) {
|
DmBerth2 assignedBerth = entry.getValue().remove(0);
|
task.setBerthId(assignedBerth.getPKID());
|
task.setBerthName(assignedBerth.getNAME());
|
resultTask.add(task);
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
return resultTask;
|
}
|
|
/**
|
* 舰艇时间分配
|
* @param list
|
* @param rule
|
* @return
|
*/
|
private List<DsTaskDetail> allocationBerthTime(List<DsTaskList2> list, String rule){
|
List<DsTaskDetail> result = new ArrayList<>();
|
|
// 获取时间计算配置信息
|
List<DmDdConfig> configList = iDmDdConfigService.selectDmDdConfigList(new DmDdConfig());
|
|
// 遍历所有需要计算的船信息
|
for (DsTaskList2 task : list) {
|
Long berthId = task.getBerthId();
|
List<DsTaskDetail> taskDetails = new ArrayList<>();
|
|
// 获取当前泊位的所有船只
|
List<DsTaskList2> berthTasks = list.stream()
|
.filter(t -> t.getBerthId().equals(berthId))
|
.sorted(Comparator.comparing(DsTaskList2::getLEVEL))
|
.collect(Collectors.toList());
|
|
// 遍历泊位的所有船只，计算每艘船的工作时间
|
for (DsTaskList2 berthTask : berthTasks) {
|
DsTaskDetail taskDetail = new DsTaskDetail();
|
taskDetail.setTaskId(berthTask.getTaskId());
|
taskDetail.setBerthId(berthTask.getBerthId());
|
taskDetail.setShipNo(berthTask.getShipNo());
|
taskDetail.setBerthName(berthTask.getBerthName());
|
taskDetail.setHarborId(berthTask.getHarborId());
|
taskDetail.setHarborName(berthTask.getHarborName());
|
taskDetail.setParkingType(berthTask.getParkingType());
|
taskDetail.setShipType(berthTask.getShipType());
|
|
// 根据configList计算每一个类型物资工作需要的时间
|
double totalOil = 0.0;
|
double totalWater = 0.0;
|
double totalMater = 0.0;
|
double totalAmmo = 0.0;
|
|
// 油
|
if (berthTask.getOilA() != null && berthTask.getOilA() > 0) {
|
totalOil += berthTask.getOilA();
|
}
|
if (berthTask.getOilB() != null && berthTask.getOilB() > 0) {
|
totalOil += berthTask.getOilB();
|
}
|
if (berthTask.getOilG() != null && berthTask.getOilG() > 0) {
|
totalOil += berthTask.getOilG();
|
}
|
// 水
|
if (berthTask.getWATER() != null && berthTask.getWATER() > 0) {
|
totalWater += berthTask.getWATER();
|
}
|
if (berthTask.getWaterP() != null && berthTask.getWaterP() > 0) {
|
totalWater += berthTask.getWaterP();
|
}
|
// 物资
|
if (berthTask.getFOOD() != null && berthTask.getFOOD() > 0) {
|
totalMater += berthTask.getFOOD();
|
}
|
if (berthTask.getFoodO() != null && berthTask.getFoodO() > 0) {
|
totalMater += berthTask.getFoodO();
|
}
|
if (berthTask.getFoodW() != null && berthTask.getFoodW() > 0) {
|
totalMater += berthTask.getFoodW();
|
}
|
|
// 炮弹
|
if (berthTask.getAmmoD() != null && berthTask.getAmmoD() > 0) {
|
totalAmmo += berthTask.getAmmoD();
|
}
|
if (berthTask.getAmmoP() != null && berthTask.getAmmoP() > 0) {
|
totalAmmo += berthTask.getAmmoP();
|
}
|
if (berthTask.getAmmoS() != null && berthTask.getAmmoS() > 0) {
|
totalAmmo += berthTask.getAmmoS();
|
}
|
|
// taskDetail.setWaterTime(getTimeByType(configList, totalWater, WATER_FLAG));
|
// taskDetail.setOilTime(getTimeByType(configList, totalOil, OIL_FLAG));
|
// taskDetail.setMatTime(getTimeByType(configList, totalMater, MATER_FLAG));
|
// 弹药时间需要根据弹药种类进行分别计算
|
Double totalAmmoTime = getTimeByType(configList, null == berthTask.getAmmoO() ? 0.0 : (double)(berthTask.getAmmoO()), AMMO_O_FLAG);
|
totalAmmoTime += getTimeByType(configList, totalAmmo, AMMO_FLAG);
|
|
// taskDetail.setAmmoTime(totalAmmoTime);
|
|
double totalTime = 0.0;
|
if ("TS".equals(rule)) {
|
totalTime = Math.max(taskDetail.getWaterTime(), Math.max(taskDetail.getOilTime(), Math.max(taskDetail.getMatTime(), taskDetail.getAmmoTime())));
|
} else if ("XYHD".equals(rule)) {
|
totalTime = Math.max(taskDetail.getWaterTime(), Math.max(taskDetail.getMatTime(), taskDetail.getAmmoTime())) + taskDetail.getOilTime();
|
}
|
// taskDetail.setTotalTime(totalTime);
|
|
// 将计算结果添加到结果列表中
|
taskDetails.add(taskDetail);
|
}
|
|
// 将当前泊位的所有船只的计算结果添加到最终结果中
|
result.addAll(taskDetails);
|
}
|
return result;
|
}
|
|
/**
|
* 根据类型获取消耗时间
|
* @param list
|
* @param val
|
* @param type
|
* @return
|
*/
|
private Double getTimeByType(List<DmDdConfig> list, Double val, String type){
|
AtomicReference<Double> totalTime = new AtomicReference<>(0.0);
|
// 参数为空 则返回0
|
if(null != val && StringUtils.isNotBlank(type)){
|
list.stream().forEach(item -> {
|
if(item.getTYPE().equals(type) && null != item.getTIME()){
|
totalTime.set(item.getTIME() * val);
|
}
|
});
|
}
|
return totalTime.get();
|
}
|
|
// 根据ID获取泊位路径信息详情
|
private String getBerthPathById(List<DmBerth2> list, Long id){
|
for(DmBerth2 berth2 : list){
|
if(berth2.getPKID() == id){
|
return berth2.getPath();
|
}
|
}
|
return "";
|
}
|
|
private void updateDetailPath(Long taskId, Long deptId, List<DmBerth2> berth2List){
|
// 获取任务详情列表
|
List<DsTaskDetail> taskDetails = iDsTaskDetailService.selectDsTaskDetailByTaskId(taskId, null);
|
|
// 创建泊位ID到路径的映射
|
Map<Long, DmBerth2> berth2Map = berth2List.stream().collect(Collectors.toMap(DmBerth2::getPKID, berth -> berth));
|
|
|
// 批量更新任务详情
|
List<DsTaskDetail> updatedDetails = taskDetails.stream()
|
.filter(detail -> detail.getBerthId() != null)
|
.peek(detail -> detail.setPath(berth2Map.get(detail.getBerthId()).getPath()))
|
.collect(Collectors.toList());
|
|
// 批量保存更新
|
if (!updatedDetails.isEmpty()) {
|
iDsTaskDetailService.batchUpdateDsTaskDetail(updatedDetails);
|
}
|
}
|
}
|
