#任务增加缓存队列

Junjie

2024-08-20 3fd514d4b802534159518924f3711dc5152732d4

#任务增加缓存队列

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/controller/OpenController.java

@@ -64,6 +64,8 @@
    private BasConveyorService basConveyorService;
    @Autowired
    private BasConveyorStaService basConveyorStaService;
    @Autowired
    private OpenService openService;


    @PostMapping("/agvPickupComplete")
@@ -275,462 +277,22 @@
            log.info("返回mes信息:"+JSONObject.toJSONString(map));
            return map;
        }
        String sta = "06YZ";
        String loc = "0601KW";
        if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,6).equals(loc)){
            if (!param.getFrmPos().equals("06YZ0001")){
                try {
                    AgvTaskCreateParam agvTaskCreateParam = new AgvTaskCreateParam();
                    getInRequestParam(agvTaskCreateParam,param);
                    String httpRequest = doHttpRequest(agvTaskCreateParam, "172.18.16.248:443", "/rcs/rtas/api/robot/controller/task/submit");
                    if (!httpRequest.equals("SUCCESS")){
                        map.put("success", "0");
                        map.put("message", httpRequest);
                        map.put("result", "");
                        map.put("requestPK", param.getRequestPK());
                        log.info("返回mes信息:"+JSONObject.toJSONString(map));
                        return map;
                    }
                }catch (Exception e){
                    map.put("success", "0");
                    map.put("message", "转发AGV任务出错");
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                    log.info("返回mes信息:"+JSONObject.toJSONString(map));
                    return map;
                }
            }

            CreateInTaskParam createInTaskParam = new CreateInTaskParam();
            createInTaskParam.setTaskNo(param.getRequestPK());
            createInTaskParam.setDestLoc(getWMStoWCSLocNo(param.getToPos()));
            createInTaskParam.setOriginSite("100");
            createInTaskParam.setBarcode(param.getContNo());
            createInTaskParam.setPriority(Integer.valueOf(param.getTrkPrty()));
            createInTaskParam.setEndSite(param.getToPos());
            R inTask = null;
            try {
                inTask = createInTask(createInTaskParam);
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }finally {
                int code = (int) inTask.get("code");
                if (code == 200){
                    map.put("success", "1");
                    map.put("message", inTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }else {
                    map.put("success", "0");
                    map.put("message", inTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }
            }
        } else if (param.getFrmPos().substring(0,6).equals(loc) && param.getToPos().substring(0,4).equals(sta)) {
            CreateOutTaskParam createOutTaskParam = new CreateOutTaskParam();
            createOutTaskParam.setTaskNo(param.getRequestPK());
            createOutTaskParam.setOriginLoc(getWMStoWCSLocNo(param.getFrmPos()));
            createOutTaskParam.setOriginSite("101");
            createOutTaskParam.setDestSite("100");
            createOutTaskParam.setPriority(Integer.valueOf(param.getTrkPrty()));
            createOutTaskParam.setEndSite(param.getToPos());
            createOutTaskParam.setZpallet(param.getContNo());
            R outTask = null;
            try {
                outTask = createOutTask(createOutTaskParam);
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }finally {
                int code = (int) outTask.get("code");
                if (code == 200){
                    map.put("success", "1");
                    map.put("message", outTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }else {
                    map.put("success", "0");
                    map.put("message", outTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }
            }

        } else if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,4).equals(sta)) {
            try {
                AgvTaskCreateParam agvTaskCreateParam = new AgvTaskCreateParam();
                getTransmitRequestParam(agvTaskCreateParam,param);
                String httpRequest = doHttpRequest(agvTaskCreateParam, "172.18.16.248:443", "/rcs/rtas/api/robot/controller/task/submit");
                if (!httpRequest.equals("SUCCESS")){
                    map.put("success", "0");
                    map.put("message", httpRequest);
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                    log.info("返回mes信息:"+JSONObject.toJSONString(map));
                    return map;
                }
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "转发AGV任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }

        } else {
            map.put("success", "0");
            map.put("message", "未找到对应任务类型");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
        }
        map = openService.createWcsTaskCache(param);
        log.info("返回mes信息:"+JSONObject.toJSONString(map));
        return map;
    }
    public static String getWMStoWCSLocNo(String loc){
        String locNo = "";
        int row = Integer.parseInt(loc.substring(6,8));
        int bay = Integer.parseInt(loc.substring(8,10));
        int lev = Integer.parseInt(loc.substring(10,12));
        if (row == 2){
            row = 3;
        }
        locNo = row +"-"+bay+"-"+lev;
        return locNo;
    }
    private void getInRequestParam(AgvTaskCreateParam agvTaskCreateParam,CreateWcsTaskParam param){
        List<AgvTaskCreateParam.AgvTaskParam> agvTaskParamList = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getFrmPos(),0,1),
                //目标位
                new AgvTaskCreateParam.AgvTaskParam("SITE","06YZ0001",1,1)
        );
        List<AgvTaskCreateParam.carrierInfoParam> carrierInfoParam = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.carrierInfoParam()

        );
        agvTaskCreateParam.setTaskType("F01");
        agvTaskCreateParam.setInitPriority(param.getTrkPrty());
        agvTaskCreateParam.setRobotTaskCode(param.getRequestPK());
        agvTaskCreateParam.setTargetRoute(agvTaskParamList);
        agvTaskCreateParam.setCarrierInfo(carrierInfoParam);

    }
    private void getTransmitRequestParam(AgvTaskCreateParam agvTaskCreateParam,CreateWcsTaskParam param){
        List<AgvTaskCreateParam.AgvTaskParam> agvTaskParamList = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getFrmPos(),0,1),
                //目标位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getToPos(),1,1)
        );
        List<AgvTaskCreateParam.carrierInfoParam> carrierInfoParam = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.carrierInfoParam()

        );
        agvTaskCreateParam.setTaskType("F01");
        agvTaskCreateParam.setInitPriority(param.getTrkPrty());
        agvTaskCreateParam.setRobotTaskCode(param.getRequestPK());
        agvTaskCreateParam.setTargetRoute(agvTaskParamList);
        agvTaskCreateParam.setCarrierInfo(carrierInfoParam);

    }
    private String doHttpRequest(AgvTaskCreateParam requestParam, String url, String path){
        String response = "";
        String success = "error";
        Map<String, Object> map = new HashMap<>();
        map.put("Content-Type", "application/json;charset=UTF-8");
        map.put("X-lr-request-id", requestParam.getRobotTaskCode());
        map.put("X-lr-version", 4.1);
        map.put("X-lr-trace-id", "{{$guid}}");
        try {
            response = new HttpHandler.Builder()
                    .setHeaders(map)
                    .setUri(url)
                    .setHttps(true)
                    .setPath(path)
                    .setJson(JSONObject.toJSONString(requestParam))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);

            String code = jsonObject.get("code").toString();
            if(code.equals("SUCCESS")){
                success = "SUCCESS";
            }else {
                success = jsonObject.get("message").toString();
            }
            log.info("转发agv任务：请求体:"+JSONObject.toJSONString(requestParam)+",返回值:"+jsonObject);
        }catch (Exception e){

        }
        return success;
    }

    //生成入库任务
    @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("任务类型异常");
        }

        Long hostId = 1L;//默认主仓库

        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("任务已存在");
        }

        String destSite = param.getDestSite();
        if (Cools.isEmpty(param.getDestSite())) {
            //目标站为空则使用WCS系统内置路径
            BasConveyorPath path = basConveyorPathService.getOne(new LambdaQueryWrapper<BasConveyorPath>()
                    .eq(BasConveyorPath::getTypeNo, taskCtg.getId())
                    .eq(BasConveyorPath::getHostId, hostId)
                    .eq(BasConveyorPath::getStnNo, param.getOriginSite()));
            if(path == null) {
                return R.error("内置路径不存在");
            }
            destSite = String.valueOf(path.getDeviceStn());
        }

        //判断出入库模式
        BasConveyorSta basConveyorSta = basConveyorStaService.getOne(new LambdaQueryWrapper<BasConveyorSta>()
                .eq(BasConveyorSta::getSiteNo, destSite));
        if (!basConveyorSta.getWorkMode().equals((int) WorkModeType.PAKIN_MODE.id)) {
            //不是入库模式，检测是否可切换入库
            //获取出库任务类型
            TaskCtg taskInCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                    .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.OUT))
                    .eq(TaskCtg::getStatus, 1));
            if (taskInCtg == null) {
                return R.error("任务类型异常");
            }
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskCtg, taskInCtg.getId()));
            if (!tasks.isEmpty()) {
                return R.error("当前存在出库任务，无法切换入库模式");
            }

            BasConveyor basConveyor = basConveyorService.getOne(new LambdaQueryWrapper<BasConveyor>().eq(BasConveyor::getConveyorNo, basConveyorSta.getConveyorNo()));
            if(basConveyor == null) {
                return R.error("输送线不存在");
            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, basConveyor.getDeviceId().intValue());
            if(devpThread == null) {
                return R.error("输送线线程不存在");
            }

            boolean result = devpThread.switchWorkMode(Integer.parseInt(destSite), WorkModeType.PAKIN_MODE.id);
            if (!result) {
                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(destSite);
        task.setDestLoc(param.getDestLoc());
        task.setZpallet(param.getBarcode());
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("");
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc("Y");//记录库存信息
        task.setHostId(hostId);//临时控制只允许host为1
        task.setMemo(param.getEndSite());

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成入库任务失败！");
        }
        return R.ok();
        return openService.createInTask(param);
    }

    //生成出库任务
    @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("任务类型异常");
        }

        Long hostId = 1L;//默认主仓库

        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("任务已存在");
        }

        String originSite = param.getOriginSite();
        if (Cools.isEmpty(param.getOriginSite())) {
            //使用WCS系统内置路径
            BasConveyorPath path = basConveyorPathService.getOne(new LambdaQueryWrapper<BasConveyorPath>()
                    .eq(BasConveyorPath::getTypeNo, taskCtg.getId())
                    .eq(BasConveyorPath::getHostId, hostId)
                    .eq(BasConveyorPath::getStnNo, param.getDestSite()));
            if(path == null) {
                return R.error("内置路径不存在");
            }
            Integer deviceNo = path.getDeviceNo();//获取提升机号
            BasLift basLift = basLiftService.getOne(new LambdaQueryWrapper<BasLift>().eq(BasLift::getLiftNo, deviceNo).eq(BasLift::getHostId, hostId));
            if(basLift == null) {
                return R.error("提升机对象不存在");
            }
            List<BasLiftStaDto> staList = JSON.parseArray(basLift.getSta(), BasLiftStaDto.class);
            BasLiftStaDto originStaDto = null;
            for (BasLiftStaDto sta : staList) {
                if (sta.getLev() == Utils.getLev(param.getOriginLoc())) {
                    originStaDto = sta;
                    break;
                }
            }

            if (originStaDto == null) {
                return R.error("源站不存在");
            }

            originSite = String.valueOf(originStaDto.getStaNo());
        }

        //判断出入库模式
        BasConveyorSta basConveyorSta = basConveyorStaService.getOne(new LambdaQueryWrapper<BasConveyorSta>()
                .eq(BasConveyorSta::getSiteNo, originSite));
        if (!basConveyorSta.getWorkMode().equals((int) WorkModeType.PAKOUT_MODE.id)) {
            //不是出库模式，检测是否可切换出库
            //获取入库任务类型
            TaskCtg taskInCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                    .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.IN))
                    .eq(TaskCtg::getStatus, 1));
            if (taskInCtg == null) {
                return R.error("任务类型异常");
            }
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskCtg, taskInCtg.getId()));
            if (!tasks.isEmpty()) {
                return R.error("当前存在入库任务，无法切换出库模式");
            }

            BasConveyor basConveyor = basConveyorService.getOne(new LambdaQueryWrapper<BasConveyor>().eq(BasConveyor::getConveyorNo, basConveyorSta.getConveyorNo()));
            if(basConveyor == null) {
                return R.error("输送线不存在");
            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, basConveyor.getDeviceId().intValue());
            if(devpThread == null) {
                return R.error("输送线线程不存在");
            }

            boolean result = devpThread.switchWorkMode(Integer.parseInt(originSite), WorkModeType.PAKOUT_MODE.id);
            if (!result) {
                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(originSite);
        task.setOriginLoc(param.getOriginLoc());
        task.setDestSite(param.getDestSite());
        task.setDestLoc(null);
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo(param.getEndSite());
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc("Y");//记录库存信息
        task.setHostId(hostId);//临时控制只允许host为1
        task.setZpallet(param.getZpallet());

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成出库任务失败！");
        }
        return R.ok();
        return openService.createOutTask(param);
    }

    //生成手动取放货任务
@@ -923,11 +485,6 @@
            return R.error("模式切换失败");
        }
        return R.ok();
    }

    public static void main(String[] args) {
        String wmStoWCSLocNo = getWMStoWCSLocNo("0601KW010101");
        System.out.println(wmStoWCSLocNo);
    }

}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/entity/TaskCache.java

New file
@@ -0,0 +1,209 @@
package com.zy.asrs.wcs.core.entity;

import com.baomidou.mybatisplus.annotation.TableLogic;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.zy.asrs.wcs.system.entity.Host;
import com.zy.asrs.wcs.system.entity.User;
import org.springframework.format.annotation.DateTimeFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.SpringUtils;
import com.zy.asrs.wcs.system.service.UserService;
import com.zy.asrs.wcs.system.service.HostService;

import java.io.Serializable;
import java.util.Date;

@Data
@TableName("wcs_task_cache")
public class TaskCache implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * ID
     */
    @ApiModelProperty(value= "ID")
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 任务类型 1: 入库  2: 出库  
     */
    @ApiModelProperty(value= "任务类型 1: 入库  2: 出库  ")
    private Integer taskType;

    /**
     * 任务参数
     */
    @ApiModelProperty(value= "任务参数")
    private String taskParam;

    /**
     * 所属机构
     */
    @ApiModelProperty(value= "所属机构")
    private Long hostId;

    /**
     * 状态 1: 正常  0: 禁用  
     */
    @ApiModelProperty(value= "状态 1: 正常  0: 禁用  ")
    private Integer status;

    /**
     * 是否删除 1: 是  0: 否  
     */
    @ApiModelProperty(value= "是否删除 1: 是  0: 否  ")
    private Integer deleted;

    /**
     * 添加时间
     */
    @ApiModelProperty(value= "添加时间")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    /**
     * 添加人员
     */
    @ApiModelProperty(value= "添加人员")
    private Long createBy;

    /**
     * 修改时间
     */
    @ApiModelProperty(value= "修改时间")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    /**
     * 修改人员
     */
    @ApiModelProperty(value= "修改人员")
    private Long updateBy;

    /**
     * 备注
     */
    @ApiModelProperty(value= "备注")
    private String memo;

    public TaskCache() {}

    public TaskCache(Integer taskType,String taskParam,Long hostId,Integer status,Integer deleted,Date createTime,Long createBy,Date updateTime,Long updateBy,String memo) {
        this.taskType = taskType;
        this.taskParam = taskParam;
        this.hostId = hostId;
        this.status = status;
        this.deleted = deleted;
        this.createTime = createTime;
        this.createBy = createBy;
        this.updateTime = updateTime;
        this.updateBy = updateBy;
        this.memo = memo;
    }

//    TaskCache taskCache = new TaskCache(
//            null,    // 任务类型
//            null,    // 任务参数
//            null,    // 所属机构
//            null,    // 状态
//            null,    // 是否删除
//            null,    // 添加时间
//            null,    // 添加人员
//            null,    // 修改时间
//            null,    // 修改人员
//            null    // 备注
//    );

    public String getTaskType$(){
        if (null == this.taskType){ return null; }
        switch (this.taskType){
            case 1:
                return "入库";
            case 2:
                return "出库";
            default:
                return String.valueOf(this.taskType);
        }
    }

    public String getHostId$(){
        HostService service = SpringUtils.getBean(HostService.class);
        Host host = service.getById(this.hostId);
        if (!Cools.isEmpty(host)){
            return String.valueOf(host.getName());
        }
        return null;
    }

    public String getStatus$(){
        if (null == this.status){ return null; }
        switch (this.status){
            case 1:
                return "正常";
            case 0:
                return "禁用";
            default:
                return String.valueOf(this.status);
        }
    }

    public String getDeleted$(){
        if (null == this.deleted){ return null; }
        switch (this.deleted){
            case 1:
                return "是";
            case 0:
                return "否";
            default:
                return String.valueOf(this.deleted);
        }
    }

    public String getCreateTime$(){
        if (Cools.isEmpty(this.createTime)){
            return "";
        }
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.createTime);
    }

    public String getCreateBy$(){
        UserService service = SpringUtils.getBean(UserService.class);
        User user = service.getById(this.createBy);
        if (!Cools.isEmpty(user)){
            return String.valueOf(user.getNickname());
        }
        return null;
    }

    public String getUpdateTime$(){
        if (Cools.isEmpty(this.updateTime)){
            return "";
        }
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.updateTime);
    }

    public String getUpdateBy$(){
        UserService service = SpringUtils.getBean(UserService.class);
        User user = service.getById(this.updateBy);
        if (!Cools.isEmpty(user)){
            return String.valueOf(user.getNickname());
        }
        return null;
    }


}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/mapper/TaskCacheMapper.java

New file
@@ -0,0 +1,12 @@
package com.zy.asrs.wcs.core.mapper;

import com.zy.asrs.wcs.core.entity.TaskCache;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface TaskCacheMapper extends BaseMapper<TaskCache> {

}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/service/OpenService.java

New file
@@ -0,0 +1,20 @@
package com.zy.asrs.wcs.core.service;

import com.zy.asrs.framework.common.R;
import com.zy.asrs.wcs.core.domain.param.CreateInTaskParam;
import com.zy.asrs.wcs.core.domain.param.CreateOutTaskParam;
import com.zy.asrs.wcs.core.domain.param.CreateWcsTaskParam;

import java.util.HashMap;

public interface OpenService {

    R createInTask(CreateInTaskParam param);

    R createOutTask(CreateOutTaskParam param);

    HashMap<String, Object> executeWcsTaskCache(CreateWcsTaskParam param);

    HashMap<String, Object> createWcsTaskCache(CreateWcsTaskParam param);

}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/service/TaskCacheService.java

New file
@@ -0,0 +1,8 @@
package com.zy.asrs.wcs.core.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.zy.asrs.wcs.core.entity.TaskCache;

public interface TaskCacheService extends IService<TaskCache> {

}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/service/impl/OpenServiceImpl.java

New file
@@ -0,0 +1,592 @@
package com.zy.asrs.wcs.core.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.common.utils.HttpHandler;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.R;
import com.zy.asrs.framework.common.SnowflakeIdWorker;
import com.zy.asrs.wcs.core.domain.dto.BasLiftStaDto;
import com.zy.asrs.wcs.core.domain.param.AgvTaskCreateParam;
import com.zy.asrs.wcs.core.domain.param.CreateInTaskParam;
import com.zy.asrs.wcs.core.domain.param.CreateOutTaskParam;
import com.zy.asrs.wcs.core.domain.param.CreateWcsTaskParam;
import com.zy.asrs.wcs.core.entity.*;
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.*;
import com.zy.asrs.wcs.core.utils.Utils;
import com.zy.asrs.wcs.rcs.cache.SlaveConnection;
import com.zy.asrs.wcs.rcs.model.enums.SlaveType;
import com.zy.asrs.wcs.rcs.model.enums.WorkModeType;
import com.zy.asrs.wcs.rcs.thread.DevpThread;
import com.zy.asrs.wcs.system.entity.Dict;
import com.zy.asrs.wcs.system.service.DictService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service("openService")
@Slf4j
public class OpenServiceImpl implements OpenService {

    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskCtgService taskCtgService;
    @Autowired
    private LocService locService;
    @Autowired
    private DictService dictService;
    @Autowired
    private BasConveyorPathService basConveyorPathService;
    @Autowired
    private BasConveyorStaService basConveyorStaService;
    @Autowired
    private BasConveyorService basConveyorService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private BasLiftService basLiftService;
    @Autowired
    private TaskCacheService taskCacheService;


    @Override
    public R createInTask(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("任务类型异常");
        }

        Long hostId = 1L;//默认主仓库

        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("任务已存在");
        }

        String destSite = param.getDestSite();
        if (Cools.isEmpty(param.getDestSite())) {
            //目标站为空则使用WCS系统内置路径
            BasConveyorPath path = basConveyorPathService.getOne(new LambdaQueryWrapper<BasConveyorPath>()
                    .eq(BasConveyorPath::getTypeNo, taskCtg.getId())
                    .eq(BasConveyorPath::getHostId, hostId)
                    .eq(BasConveyorPath::getStnNo, param.getOriginSite()));
            if(path == null) {
                return R.error("内置路径不存在");
            }
            destSite = String.valueOf(path.getDeviceStn());
        }

        //判断出入库模式
        BasConveyorSta basConveyorSta = basConveyorStaService.getOne(new LambdaQueryWrapper<BasConveyorSta>()
                .eq(BasConveyorSta::getSiteNo, destSite));
        if (!basConveyorSta.getWorkMode().equals((int) WorkModeType.PAKIN_MODE.id)) {
            //不是入库模式，检测是否可切换入库
            //获取出库任务类型
            TaskCtg taskInCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                    .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.OUT))
                    .eq(TaskCtg::getStatus, 1));
            if (taskInCtg == null) {
                return R.error("任务类型异常");
            }
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskCtg, taskInCtg.getId()));
            if (!tasks.isEmpty()) {
                return R.error("当前存在出库任务，无法切换入库模式");
            }

            BasConveyor basConveyor = basConveyorService.getOne(new LambdaQueryWrapper<BasConveyor>().eq(BasConveyor::getConveyorNo, basConveyorSta.getConveyorNo()));
            if(basConveyor == null) {
                return R.error("输送线不存在");
            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, basConveyor.getDeviceId().intValue());
            if(devpThread == null) {
                return R.error("输送线线程不存在");
            }

            boolean result = devpThread.switchWorkMode(Integer.parseInt(destSite), WorkModeType.PAKIN_MODE.id);
            if (!result) {
                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(destSite);
        task.setDestLoc(param.getDestLoc());
        task.setZpallet(param.getBarcode());
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("");
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc("Y");//记录库存信息
        task.setHostId(hostId);//临时控制只允许host为1
        task.setMemo(param.getEndSite());

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成入库任务失败！");
        }
        return R.ok();
    }

    @Override
    public R createOutTask(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("任务类型异常");
        }

        Long hostId = 1L;//默认主仓库

        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("任务已存在");
        }

        String originSite = param.getOriginSite();
        if (Cools.isEmpty(param.getOriginSite())) {
            //使用WCS系统内置路径
            BasConveyorPath path = basConveyorPathService.getOne(new LambdaQueryWrapper<BasConveyorPath>()
                    .eq(BasConveyorPath::getTypeNo, taskCtg.getId())
                    .eq(BasConveyorPath::getHostId, hostId)
                    .eq(BasConveyorPath::getStnNo, param.getDestSite()));
            if(path == null) {
                return R.error("内置路径不存在");
            }
            Integer deviceNo = path.getDeviceNo();//获取提升机号
            BasLift basLift = basLiftService.getOne(new LambdaQueryWrapper<BasLift>().eq(BasLift::getLiftNo, deviceNo).eq(BasLift::getHostId, hostId));
            if(basLift == null) {
                return R.error("提升机对象不存在");
            }
            List<BasLiftStaDto> staList = JSON.parseArray(basLift.getSta(), BasLiftStaDto.class);
            BasLiftStaDto originStaDto = null;
            for (BasLiftStaDto sta : staList) {
                if (sta.getLev() == Utils.getLev(param.getOriginLoc())) {
                    originStaDto = sta;
                    break;
                }
            }

            if (originStaDto == null) {
                return R.error("源站不存在");
            }

            originSite = String.valueOf(originStaDto.getStaNo());
        }

        //判断出入库模式
        BasConveyorSta basConveyorSta = basConveyorStaService.getOne(new LambdaQueryWrapper<BasConveyorSta>()
                .eq(BasConveyorSta::getSiteNo, originSite));
        if (!basConveyorSta.getWorkMode().equals((int) WorkModeType.PAKOUT_MODE.id)) {
            //不是出库模式，检测是否可切换出库
            //获取入库任务类型
            TaskCtg taskInCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                    .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.IN))
                    .eq(TaskCtg::getStatus, 1));
            if (taskInCtg == null) {
                return R.error("任务类型异常");
            }
            List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                    .eq(Task::getTaskCtg, taskInCtg.getId()));
            if (!tasks.isEmpty()) {
                return R.error("当前存在入库任务，无法切换出库模式");
            }

            BasConveyor basConveyor = basConveyorService.getOne(new LambdaQueryWrapper<BasConveyor>().eq(BasConveyor::getConveyorNo, basConveyorSta.getConveyorNo()));
            if(basConveyor == null) {
                return R.error("输送线不存在");
            }

            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, basConveyor.getDeviceId().intValue());
            if(devpThread == null) {
                return R.error("输送线线程不存在");
            }

            boolean result = devpThread.switchWorkMode(Integer.parseInt(originSite), WorkModeType.PAKOUT_MODE.id);
            if (!result) {
                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(originSite);
        task.setOriginLoc(param.getOriginLoc());
        task.setDestSite(param.getDestSite());
        task.setDestLoc(null);
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo(param.getEndSite());
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc("Y");//记录库存信息
        task.setHostId(hostId);//临时控制只允许host为1
        task.setZpallet(param.getZpallet());

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成出库任务失败！");
        }
        return R.ok();
    }

    @Override
    public HashMap<String, Object> executeWcsTaskCache(CreateWcsTaskParam param) {
        HashMap<String, Object> map = new HashMap<>();
        String sta = "06YZ";
        String loc = "0601KW";
        if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,6).equals(loc)){
            if (!param.getFrmPos().equals("06YZ0001")){
                try {
                    AgvTaskCreateParam agvTaskCreateParam = new AgvTaskCreateParam();
                    getInRequestParam(agvTaskCreateParam,param);
                    String httpRequest = doHttpRequest(agvTaskCreateParam, "172.18.16.248:443", "/rcs/rtas/api/robot/controller/task/submit");
                    if (!httpRequest.equals("SUCCESS")){
                        map.put("success", "0");
                        map.put("message", httpRequest);
                        map.put("result", "");
                        map.put("requestPK", param.getRequestPK());
                        log.info("返回mes信息:"+ JSONObject.toJSONString(map));
                        return map;
                    }
                }catch (Exception e){
                    map.put("success", "0");
                    map.put("message", "转发AGV任务出错");
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                    log.info("返回mes信息:"+JSONObject.toJSONString(map));
                    return map;
                }
            }

            CreateInTaskParam createInTaskParam = new CreateInTaskParam();
            createInTaskParam.setTaskNo(param.getRequestPK());
            createInTaskParam.setDestLoc(getWMStoWCSLocNo(param.getToPos()));
            createInTaskParam.setOriginSite("100");
            createInTaskParam.setBarcode(param.getContNo());
            createInTaskParam.setPriority(Integer.valueOf(param.getTrkPrty()));
            createInTaskParam.setEndSite(param.getToPos());
            R inTask = null;
            try {
                inTask = this.createInTask(createInTaskParam);
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }finally {
                int code = (int) inTask.get("code");
                if (code == 200){
                    map.put("success", "1");
                    map.put("message", inTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }else {
                    map.put("success", "0");
                    map.put("message", inTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }
            }
        } else if (param.getFrmPos().substring(0,6).equals(loc) && param.getToPos().substring(0,4).equals(sta)) {
            CreateOutTaskParam createOutTaskParam = new CreateOutTaskParam();
            createOutTaskParam.setTaskNo(param.getRequestPK());
            createOutTaskParam.setOriginLoc(getWMStoWCSLocNo(param.getFrmPos()));
            createOutTaskParam.setOriginSite("101");
            createOutTaskParam.setDestSite("100");
            createOutTaskParam.setPriority(Integer.valueOf(param.getTrkPrty()));
            createOutTaskParam.setEndSite(param.getToPos());
            createOutTaskParam.setZpallet(param.getContNo());
            R outTask = null;
            try {
                outTask = this.createOutTask(createOutTaskParam);
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }finally {
                int code = (int) outTask.get("code");
                if (code == 200){
                    map.put("success", "1");
                    map.put("message", outTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }else {
                    map.put("success", "0");
                    map.put("message", outTask.get("msg"));
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }
            }

        } else if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,4).equals(sta)) {
            try {
                AgvTaskCreateParam agvTaskCreateParam = new AgvTaskCreateParam();
                getTransmitRequestParam(agvTaskCreateParam,param);
                String httpRequest = doHttpRequest(agvTaskCreateParam, "172.18.16.248:443", "/rcs/rtas/api/robot/controller/task/submit");
                if (!httpRequest.equals("SUCCESS")){
                    map.put("success", "0");
                    map.put("message", httpRequest);
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                    log.info("返回mes信息:"+JSONObject.toJSONString(map));
                    return map;
                }
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "转发AGV任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }

        } else {
            map.put("success", "0");
            map.put("message", "未找到对应任务类型");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
        }

        return map;
    }

    @Override
    public HashMap<String, Object> createWcsTaskCache(CreateWcsTaskParam param) {
        HashMap<String, Object> map = new HashMap<>();
        String sta = "06YZ";
        String loc = "0601KW";
        if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,6).equals(loc)){
            //入库
            TaskCache taskCache = new TaskCache();
            taskCache.setTaskType(1);
            taskCache.setTaskParam(JSON.toJSONString(param));
            boolean save = taskCacheService.save(taskCache);
            if (!save) {
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }
            map.put("success", "1");
            map.put("message", "success");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            return map;
        } else if (param.getFrmPos().substring(0,6).equals(loc) && param.getToPos().substring(0,4).equals(sta)) {
            //出库
            TaskCache taskCache = new TaskCache();
            taskCache.setTaskType(2);
            taskCache.setTaskParam(JSON.toJSONString(param));
            boolean save = taskCacheService.save(taskCache);
            if (!save) {
                map.put("success", "0");
                map.put("message", "生成任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }
            map.put("success", "1");
            map.put("message", "success");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
        } else if (param.getFrmPos().substring(0,4).equals(sta) && param.getToPos().substring(0,4).equals(sta)) {
            try {
                AgvTaskCreateParam agvTaskCreateParam = new AgvTaskCreateParam();
                getTransmitRequestParam(agvTaskCreateParam,param);
                String httpRequest = doHttpRequest(agvTaskCreateParam, "172.18.16.248:443", "/rcs/rtas/api/robot/controller/task/submit");
                if (!httpRequest.equals("SUCCESS")){
                    map.put("success", "0");
                    map.put("message", httpRequest);
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                    log.info("返回mes信息:"+JSONObject.toJSONString(map));
                    return map;
                }
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "转发AGV任务出错");
                map.put("result", "");
                map.put("requestPK", param.getRequestPK());
                log.info("返回mes信息:"+JSONObject.toJSONString(map));
                return map;
            }

        } else {
            map.put("success", "0");
            map.put("message", "未找到对应任务类型");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
        }

        return map;
    }

    private void getInRequestParam(AgvTaskCreateParam agvTaskCreateParam,CreateWcsTaskParam param){
        List<AgvTaskCreateParam.AgvTaskParam> agvTaskParamList = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getFrmPos(),0,1),
                //目标位
                new AgvTaskCreateParam.AgvTaskParam("SITE","06YZ0001",1,1)
        );
        List<AgvTaskCreateParam.carrierInfoParam> carrierInfoParam = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.carrierInfoParam()

        );
        agvTaskCreateParam.setTaskType("F01");
        agvTaskCreateParam.setInitPriority(param.getTrkPrty());
        agvTaskCreateParam.setRobotTaskCode(param.getRequestPK());
        agvTaskCreateParam.setTargetRoute(agvTaskParamList);
        agvTaskCreateParam.setCarrierInfo(carrierInfoParam);

    }
    private void getTransmitRequestParam(AgvTaskCreateParam agvTaskCreateParam,CreateWcsTaskParam param){
        List<AgvTaskCreateParam.AgvTaskParam> agvTaskParamList = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getFrmPos(),0,1),
                //目标位
                new AgvTaskCreateParam.AgvTaskParam("SITE",param.getToPos(),1,1)
        );
        List<AgvTaskCreateParam.carrierInfoParam> carrierInfoParam = Arrays.asList(
                //起始位
                new AgvTaskCreateParam.carrierInfoParam()

        );
        agvTaskCreateParam.setTaskType("F01");
        agvTaskCreateParam.setInitPriority(param.getTrkPrty());
        agvTaskCreateParam.setRobotTaskCode(param.getRequestPK());
        agvTaskCreateParam.setTargetRoute(agvTaskParamList);
        agvTaskCreateParam.setCarrierInfo(carrierInfoParam);

    }
    private String doHttpRequest(AgvTaskCreateParam requestParam, String url, String path){
        String response = "";
        String success = "error";
        Map<String, Object> map = new HashMap<>();
        map.put("Content-Type", "application/json;charset=UTF-8");
        map.put("X-lr-request-id", requestParam.getRobotTaskCode());
        map.put("X-lr-version", 4.1);
        map.put("X-lr-trace-id", "{{$guid}}");
        try {
            response = new HttpHandler.Builder()
                    .setHeaders(map)
                    .setUri(url)
                    .setHttps(true)
                    .setPath(path)
                    .setJson(JSONObject.toJSONString(requestParam))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);

            String code = jsonObject.get("code").toString();
            if(code.equals("SUCCESS")){
                success = "SUCCESS";
            }else {
                success = jsonObject.get("message").toString();
            }
            log.info("转发agv任务：请求体:"+JSONObject.toJSONString(requestParam)+",返回值:"+jsonObject);
        }catch (Exception e){

        }
        return success;
    }

    public static String getWMStoWCSLocNo(String loc){
        String locNo = "";
        int row = Integer.parseInt(loc.substring(6,8));
        int bay = Integer.parseInt(loc.substring(8,10));
        int lev = Integer.parseInt(loc.substring(10,12));
        if (row == 2){
            row = 3;
        }
        locNo = row +"-"+bay+"-"+lev;
        return locNo;
    }
}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/service/impl/TaskCacheServiceImpl.java

New file
@@ -0,0 +1,12 @@
package com.zy.asrs.wcs.core.service.impl;

import com.zy.asrs.wcs.core.mapper.TaskCacheMapper;
import com.zy.asrs.wcs.core.entity.TaskCache;
import com.zy.asrs.wcs.core.service.TaskCacheService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service("taskCacheService")
public class TaskCacheServiceImpl extends ServiceImpl<TaskCacheMapper, TaskCache> implements TaskCacheService {

}

 zy-asrs-wcs/src/main/java/com/zy/asrs/wcs/core/timer/TaskCacheTimer.java

New file
@@ -0,0 +1,85 @@
package com.zy.asrs.wcs.core.timer;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wcs.core.domain.param.CreateWcsTaskParam;
import com.zy.asrs.wcs.core.entity.BasConveyorSta;
import com.zy.asrs.wcs.core.entity.TaskCache;
import com.zy.asrs.wcs.core.service.BasConveyorStaService;
import com.zy.asrs.wcs.core.service.OpenService;
import com.zy.asrs.wcs.core.service.TaskCacheService;
import com.zy.asrs.wcs.rcs.model.enums.WorkModeType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;

@Slf4j
@Component
public class TaskCacheTimer {

    @Autowired
    private TaskCacheService taskCacheService;
    @Autowired
    private BasConveyorStaService basConveyorStaService;
    @Autowired
    private OpenService openService;

    @Scheduled(cron = "0/1 * * * * ? ")
    @Transactional
    public synchronized void executeTaskCache() {
        //判断出入库模式
        BasConveyorSta basConveyorSta = basConveyorStaService.getOne(new LambdaQueryWrapper<BasConveyorSta>()
                .eq(BasConveyorSta::getSiteNo, 101));
        if (basConveyorSta == null) {
            return;
        }

        List<TaskCache> taskInCaches = taskCacheService.list(new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, 1));//入库缓存
        List<TaskCache> taskOutCaches = taskCacheService.list(new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, 2));//出库缓存

        if (basConveyorSta.getWorkMode().equals((int) WorkModeType.PAKIN_MODE.id)) {
            //入库模式
            if (!taskInCaches.isEmpty()) {
                //存在入库缓存
                executeTaskCache(taskInCaches);
            }else {
                //不存在入库缓存，且处于入库模式，尝试执行出库缓存
                executeTaskCache(taskOutCaches);
            }
        }else {
            //出库模式
            if (!taskOutCaches.isEmpty()) {
                //存在出库缓存
                executeTaskCache(taskOutCaches);
            }else {
                //不存在出库缓存，且处于出库模式，尝试执行入库缓存
                executeTaskCache(taskInCaches);
            }
        }
    }

    private synchronized void executeTaskCache(List<TaskCache> taskCaches) {
        if(taskCaches.isEmpty()){
            return;
        }

        for (TaskCache taskCache : taskCaches) {
            CreateWcsTaskParam param = JSON.parseObject(taskCache.getTaskParam(), CreateWcsTaskParam.class);
            HashMap<String, Object> result = openService.executeWcsTaskCache(param);
            log.info("缓存执行结果：{}", JSON.toJSONString(result));
            if (result.get("success").toString().equals("1")) {
                //执行成功，删除缓存
                if (!taskCacheService.removeById(taskCache.getId())) {
                    throw new CoolException("缓存删除失败");
                }
            }
        }
    }

}

 zy-asrs-wcs/src/main/resources/mapper/core/TaskCacheMapper.xml

New file
@@ -0,0 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zy.asrs.wcs.core.mapper.TaskCacheMapper">

</mapper>