package com.zy.asrs.wcs.core.controller;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.zy.asrs.framework.common.R;
|
import com.zy.asrs.framework.common.SnowflakeIdWorker;
|
import com.zy.asrs.wcs.core.domain.param.CreateInTaskParam;
|
import com.zy.asrs.wcs.core.domain.param.CreateManualTakeTaskParam;
|
import com.zy.asrs.wcs.core.domain.param.CreateMoveTaskParam;
|
import com.zy.asrs.wcs.core.domain.param.CreateOutTaskParam;
|
import com.zy.asrs.wcs.core.entity.Loc;
|
import com.zy.asrs.wcs.core.entity.Task;
|
import com.zy.asrs.wcs.core.entity.TaskCtg;
|
import com.zy.asrs.wcs.core.model.enums.DeviceCtgType;
|
import com.zy.asrs.wcs.core.model.enums.TaskCtgType;
|
import com.zy.asrs.wcs.core.model.enums.TaskStsType;
|
import com.zy.asrs.wcs.core.service.LocService;
|
import com.zy.asrs.wcs.core.service.TaskCtgService;
|
import com.zy.asrs.wcs.core.service.TaskService;
|
import com.zy.asrs.wcs.core.utils.Utils;
|
import com.zy.asrs.wcs.rcs.cache.SlaveConnection;
|
import com.zy.asrs.wcs.rcs.entity.Device;
|
import com.zy.asrs.wcs.rcs.model.enums.SlaveType;
|
import com.zy.asrs.wcs.rcs.model.protocol.ShuttleProtocol;
|
import com.zy.asrs.wcs.rcs.service.DeviceService;
|
import com.zy.asrs.wcs.rcs.thread.ShuttleThread;
|
import com.zy.asrs.wcs.system.controller.BaseController;
|
import com.zy.asrs.wcs.system.entity.Dict;
|
import com.zy.asrs.wcs.system.service.DictService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.PostMapping;
|
import org.springframework.web.bind.annotation.RequestBody;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.util.Date;
|
|
/**
|
* 对外暴露接口
|
* 提供任务生成、设备运动等接口
|
*/
|
@RestController
|
@RequestMapping("/openapi")
|
public class OpenController extends BaseController {
|
|
@Autowired
|
private SnowflakeIdWorker snowflakeIdWorker;
|
@Autowired
|
private TaskCtgService taskCtgService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private DeviceService deviceService;
|
@Autowired
|
private LocService locService;
|
@Autowired
|
private DictService dictService;
|
|
//生成入库任务
|
@PostMapping("/createInTask")
|
public R createInTask(@RequestBody CreateInTaskParam param) {
|
//获取入库任务类型
|
TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
|
.eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.IN))
|
.eq(TaskCtg::getStatus, 1));
|
if (taskCtg == null) {
|
return R.error("任务类型异常");
|
}
|
|
Loc loc = locService.selectByLocNo(param.getDestLoc());
|
if (loc == null) {
|
return R.error("库位号不存在");
|
}
|
|
//获取严格模式参数
|
boolean mapStrict = true;//默认严格模式
|
Dict dict = dictService.getOne(new LambdaQueryWrapper<Dict>().eq(Dict::getFlag, "shuttleMapStrict"));
|
if (dict != null) {
|
mapStrict = Boolean.parseBoolean(dict.getValue());
|
}
|
|
if (mapStrict && !loc.getLocStsFlag().equals("O")) {
|
return R.error("库位状态不满足入库条件");
|
}
|
|
Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
|
.eq(Task::getTaskCtg, taskCtg.getId())
|
.eq(Task::getOriginSite, param.getOriginSite())
|
.eq(Task::getDestSite, param.getDestSite())
|
.eq(Task::getDestLoc, param.getDestLoc()));
|
if (one != null) {
|
return R.error("任务已存在");
|
}
|
|
//优先级
|
Integer priority = 10;
|
if (param.getPriority() != null) {
|
priority = param.getPriority();
|
}
|
|
Task task = new Task();
|
task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
task.setTaskNo(String.valueOf(Utils.getTaskNo("IN")));
|
task.setWmsTaskNo(param.getTaskNo());
|
task.setTaskSts(TaskStsType.NEW_INBOUND.sts);
|
task.setTaskCtg(taskCtg.getId());
|
task.setPriority(priority);
|
task.setOriginSite(param.getOriginSite());
|
task.setOriginLoc(null);
|
task.setDestSite(param.getDestSite());
|
task.setDestLoc(param.getDestLoc());
|
task.setIoTime(new Date());
|
task.setStartTime(new Date());
|
task.setStatus(1);
|
task.setMemo("");
|
task.setShuttleNo(null);//等待主线程分配小车
|
task.setRecordLoc("Y");//记录库存信息
|
task.setHostId(1L);//临时控制只允许host为1
|
|
boolean result = taskService.save(task);
|
if (!result) {
|
return R.error("生成入库任务失败！");
|
}
|
return R.ok();
|
}
|
|
//生成出库任务
|
@PostMapping("/createOutTask")
|
public R createOutTask(@RequestBody CreateOutTaskParam param) {
|
//获取出库任务类型
|
TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
|
.eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.OUT))
|
.eq(TaskCtg::getStatus, 1));
|
if (taskCtg == null) {
|
return R.error("任务类型异常");
|
}
|
|
Loc loc = locService.selectByLocNo(param.getOriginLoc());
|
if (loc == null) {
|
return R.error("库位号不存在");
|
}
|
|
//获取严格模式参数
|
boolean mapStrict = true;//默认严格模式
|
Dict dict = dictService.getOne(new LambdaQueryWrapper<Dict>().eq(Dict::getFlag, "shuttleMapStrict"));
|
if (dict != null) {
|
mapStrict = Boolean.parseBoolean(dict.getValue());
|
}
|
|
if (mapStrict && !loc.getLocStsFlag().equals("F")) {
|
return R.error("库位状态不满足出库条件");
|
}
|
|
Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
|
.eq(Task::getTaskCtg, taskCtg.getId())
|
.eq(Task::getOriginSite, param.getOriginSite())
|
.eq(Task::getOriginLoc, param.getOriginLoc())
|
.eq(Task::getDestSite, param.getDestSite()));
|
if (one != null) {
|
return R.error("任务已存在");
|
}
|
|
//优先级
|
Integer priority = 10;
|
if (param.getPriority() != null) {
|
priority = param.getPriority();
|
}
|
|
Task task = new Task();
|
task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
|
task.setWmsTaskNo(param.getTaskNo());
|
task.setTaskSts(TaskStsType.NEW_OUTBOUND.sts);
|
task.setTaskCtg(taskCtg.getId());
|
task.setPriority(priority);
|
task.setOriginSite(param.getOriginSite());
|
task.setOriginLoc(param.getOriginLoc());
|
task.setDestSite(param.getDestSite());
|
task.setDestLoc(null);
|
task.setIoTime(new Date());
|
task.setStartTime(new Date());
|
task.setStatus(1);
|
task.setMemo("");
|
task.setShuttleNo(null);//等待主线程分配小车
|
task.setRecordLoc("Y");//记录库存信息
|
task.setHostId(1L);//临时控制只允许host为1
|
|
boolean result = taskService.save(task);
|
if (!result) {
|
return R.error("生成出库任务失败！");
|
}
|
return R.ok();
|
}
|
|
//生成手动取放货任务
|
@PostMapping("/createManualTakeTask")
|
public R createManualTakeTask(@RequestBody CreateManualTakeTaskParam param) {
|
//获取手动任务类型
|
TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
|
.eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MANUAL))
|
.eq(TaskCtg::getStatus, 1));
|
if (taskCtg == null) {
|
return R.error("任务类型异常");
|
}
|
|
Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
|
.eq(Task::getTaskCtg, taskCtg.getId())
|
.eq(Task::getOriginLoc, param.getOriginLoc())
|
.eq(Task::getDestLoc, param.getDestLoc()));
|
if (one != null) {
|
return R.error("任务已存在");
|
}
|
|
//优先级
|
Integer priority = 10;
|
if (param.getPriority() != null) {
|
priority = param.getPriority();
|
}
|
|
Task task = new Task();
|
task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
|
task.setWmsTaskNo(param.getTaskNo());
|
task.setTaskSts(TaskStsType.NEW_MANUAL.sts);
|
task.setTaskCtg(taskCtg.getId());
|
task.setPriority(priority);
|
task.setOriginSite(null);
|
task.setOriginLoc(param.getOriginLoc());//源库位
|
task.setDestSite(null);
|
task.setDestLoc(param.getDestLoc());//目标库位
|
task.setIoTime(new Date());
|
task.setStartTime(new Date());
|
task.setStatus(1);
|
task.setMemo("");
|
task.setShuttleNo(null);//等待主线程分配小车
|
task.setRecordLoc(param.getRecord() ? "Y" : "N");//记录库存信息
|
task.setHostId(1L);//临时控制只允许host为1
|
|
boolean result = taskService.save(task);
|
if (!result) {
|
return R.error("生成手动取放货任务失败！");
|
}
|
return R.ok();
|
}
|
|
//生成小车移动任务
|
@PostMapping("/createMoveTask")
|
public R createMoveTask(@RequestBody CreateMoveTaskParam param) {
|
//获取出库任务类型
|
TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
|
.eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MOVE))
|
.eq(TaskCtg::getStatus, 1));
|
if (taskCtg == null) {
|
return R.error("任务类型异常");
|
}
|
|
Device device = deviceService.getOne(new LambdaQueryWrapper<Device>()
|
.eq(Device::getDeviceType, DeviceCtgType.SHUTTLE.val())
|
.eq(Device::getDeviceNo, param.getShuttleNo())
|
.eq(Device::getHostId, 1)
|
.eq(Device::getStatus, 1));
|
if (device == null) {
|
return R.error("穿梭车不存在");
|
}
|
ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
|
if (shuttleThread == null) {
|
return R.error("穿梭车不在线");
|
}
|
ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
|
if (shuttleProtocol == null) {
|
return R.error("穿梭车不在线");
|
}
|
if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(param.getDestLoc())) {
|
return R.error("穿梭车和目标位置不在同一楼层");
|
}
|
|
Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
|
.eq(Task::getTaskCtg, taskCtg.getId())
|
.eq(Task::getDestLoc, param.getDestLoc()));
|
if (one != null) {
|
return R.error("任务已存在");
|
}
|
|
//优先级
|
Integer priority = 10;
|
if (param.getPriority() != null) {
|
priority = param.getPriority();
|
}
|
|
Task task = new Task();
|
task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
|
task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
|
task.setWmsTaskNo(param.getTaskNo());
|
task.setTaskSts(TaskStsType.NEW_MOVE.sts);
|
task.setTaskCtg(taskCtg.getId());
|
task.setPriority(priority);
|
task.setOriginSite(null);
|
task.setOriginLoc(null);
|
task.setDestSite(null);
|
task.setDestLoc(param.getDestLoc());
|
task.setIoTime(new Date());
|
task.setStartTime(new Date());
|
task.setStatus(1);
|
task.setMemo("");
|
task.setShuttleNo(param.getShuttleNo());
|
task.setRecordLoc("N");//不记录库存信息
|
task.setHostId(1L);//临时控制只允许host为1
|
|
boolean result = taskService.save(task);
|
if (!result) {
|
return R.error("生成小车移动任务失败！");
|
}
|
return R.ok();
|
}
|
|
}
|
