#

zjj

2025-07-02 d3f3d4b309cfb285fcbbc48b91c4046111c7e9cd

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -4,21 +4,18 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.R;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.TaskOverToWms;
import com.zy.asrs.entity.param.WMSAndAGVInterfaceParam;
import com.zy.asrs.entity.param.taskCreateParam;
import com.zy.asrs.mapper.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.StaDescMapper;
import com.zy.asrs.mapper.TaskWrkMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.PostMesDataUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
@@ -34,7 +31,6 @@
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
@@ -91,6 +87,13 @@

    @Autowired
    private ApiLogService apiLogService;
//
//    // 入库站点号对应的堆垛机
//    private static final Map<Integer,Integer> staNoToCrnMap = new HashMap<Integer,Integer>(){{
//        put(103,1); put(205,1); put(107,2); put(211,2);
//        put(111,3); put(217,3); put(115,4); put(223,4);
//        put(119,5); put(229,5); put(123,6); put(235,6);
//    }};

    @Value("${wms.url}")
    private String wmsUrl;
@@ -194,11 +197,24 @@
                        if (Cools.isEmpty(taskWrk)){
                            continue;
                        }
                        List<Integer> list = new ArrayList<>();
                        list.add(taskWrk.getCrnNo());

                        //StaDesc staDesc1 = staDescService.selectOne(new EntityWrapper<StaDesc>().eq("stn_no",inSta.getBackSta()));
                        if (taskWrk.getTargetPoint() != null && taskWrk.getStartPoint() != null){
                        boolean sign = true;
                        if (inSta.getBarcode() == 7 || inSta.getBarcode() == 8){

                        }else {
                            if (taskWrk.getCrnNo() != inSta.getBarcode()){
                                sign = false;
                            }
                        }
                        if (taskWrk.getTargetPoint() != null && taskWrk.getStartPoint() != null && sign){
                            if ( taskWrk.getWrkNo() != null && taskWrk.getWrkNo().shortValue() == workNo ){
                                continue;
                            }
                            if (taskWrk.getStatus() != 2){
                                continue;
                            }
                            if (!staProtocol.isPakMk()){
                                continue;
                            }
                            //获取堆垛机站点
@@ -210,16 +226,29 @@
                                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                        .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).lt("stn_no", 400).ge("stn_no", 250));
                            }

                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                            staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            Thread.sleep(500);
                        }else {
                            //TaskWrk taskWrk = taskWrkService.selectByTaskNo(param.getTaskNo());
                            toWmsDTO.setWarehouseId("1688469798893297665");
                            toWmsDTO.setContainerCode(barcode);
                            toWmsDTO.setApplyType("TUNNEL_LOCATION");
                            toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
                            List<Integer> list = new ArrayList<>();

                            if (inSta.getBarcode() == 7 || inSta.getBarcode() == 8){
                                toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
                                list.add(taskWrk.getCrnNo());
                            }else {
                                toWmsDTO.setTaskTunnel(inSta.getBarcode());
                                list.add(inSta.getBarcode());
                            }



                            toWmsDTO.setCanInboundTunnels(list);
                            String response = null;
                            try {
@@ -248,9 +277,23 @@
                                taskWrk.setOriginTargetPoint(getWmsDto.getTargetLocationCode());
                                taskWrk.setTargetPoint(Utils.getWcsLocNo(getWmsDto.getTargetLocationCode()));
                                taskWrk.setStartPoint(String.valueOf(inSta.getBackSta()));
                                if (inSta.getBarcode() == 7 || inSta.getBarcode() == 8){

                                }else {
                                    taskWrk.setCrnNo(inSta.getBarcode());
                                }
                                if (!taskWrkService.updateById(taskWrk)){
                                    log.error("保存wms库位号失败");
                                }
//                                try {
//                                    // 更新库位为入库预约
//                                    LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
//                                    locMast.setLocSts("S");
//                                    locMastService.updateById(locMast);
//                                    log.info("-----入库更新库位状态为：S成功----------"+ locMast.getLocNo());
//                                } catch (Exception e){
//                                    log.error("-----入库更新库位状态为：S异常----------"+ e);
//                                }

                            }else {
                                log.error("wms通讯失败,"+jsonObject.get("msg"));
@@ -265,12 +308,17 @@
            }
        }
    }
//
//    private boolean getCrnByStaNo(Integer staNo) {
//        int crn = staNoToCrnMap.get(staNo);
//        BasCrnp crnp = basCrnpService.selectOne(new EntityWrapper<BasCrnp>().eq("crn_no", crn));
//        return crnp.getCrnSts() == 0;
//    }


    /**
     * 堆垛机站出库到出库站
     */
    @Async
    public void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
@@ -306,26 +354,42 @@
                                    && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                                // 命令下发区 --------------------------------------------------------------------------

                                //取出输送线命令
                                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                                if (commandInfos.isEmpty()) {
                                    continue;//命令空
                                }
                                try {
                                    //取出输送线命令
                                    List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                                    if (commandInfos.isEmpty()) {
                                        continue;//命令空
                                    }

//                                CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
//                                CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
                                Integer commandStep = taskWrk.getCommandStep();
                                CommandInfo commandInfo = commandInfos.get(commandStep);
                                CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                                //StaProtocol staProtocol1 = JSON.parseObject(commandInfo.getCommand(), StaProtocol.class);
                                StaProtocol staProtocol1 = JSON.parseObject(commandPackage.getCommand().toString(), StaProtocol.class);
                                if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol1))) {
                                    log.error("输送线命令下方失败！！！ [工作号:{}]", taskWrk.getWrkNo());
                                    continue;//命令下发失败
                                    Integer commandStep = taskWrk.getCommandStep();
                                    CommandInfo commandInfo = commandInfos.get(commandStep);
                                    CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                                    //StaProtocol staProtocol1 = JSON.parseObject(commandInfo.getCommand(), StaProtocol.class);
                                    StaProtocol staProtocol1 = JSON.parseObject(commandPackage.getCommand().toString(), StaProtocol.class);
                                    if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol1))) {
                                        log.error("输送线命令下方失败！！！ [工作号:{}]", taskWrk.getWrkNo());
                                        continue;//命令下发失败
                                    }
                                }catch (Exception e){
                                    throw new CoolException("取出输送线命令失败");
                                }

                                // 复位堆垛机
                                crnThread.setResetFlag(true);

                                if (taskWrk.getIoType() == 1 || taskWrk.getIoType() == 3){
                                    taskWrk.setWrkSts(4);
                                } else if (taskWrk.getIoType() == 2) {
                                    taskWrk.setWrkSts(14);
                                }
                                Date now = new Date();
                                taskWrk.setCompleteTime(now);
                                if (!taskWrkService.updateById(taskWrk)){
                                    log.error(taskWrk.getTaskNo()+ " 堆垛机任务完成，改变任务状态失败");
                                }


                            }
                        }
@@ -425,6 +489,21 @@
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }
                // 修改工作档状态 2.设备上走 => 3.吊车入库中
                log.error("进入修改工作档流程");
                Date now = new Date();
                taskWrk.setWrkSts(3);
                taskWrk.setExecuteTime(now);
                taskWrk.setModiTime(now);
                if (taskWrkMapper.updateById(taskWrk) == 0) {
                    log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                }
                TaskWrk taskWrk2 = taskWrkService.selectByWrkNo(taskWrk.getWrkNo());
                if (taskWrk2.getWrkSts() != 3){
                    continue;
                }
                log.error("进入修改工作档流程完成,taskWrk="+ taskWrk.getWrkNo());


                //取出命令
                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
@@ -439,22 +518,20 @@
                if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 2.设备上走 => 3.吊车入库中
                    Date now = new Date();
                    taskWrk.setWrkSts(3);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                    //开始运行
                    String response = CrnStartRunning(taskWrk);
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                    try {
                        //开始运行
                        String response = CrnStartRunning(taskWrk);
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {

                    }else {
                        log.error("入库开始运行通讯失败,"+jsonObject.get("msg"));
                        }else {
                            log.error("入库开始运行wms报错,"+jsonObject.get("msg"));

                        }
                    }catch (Exception e) {
                        log.error("入库开始运行wms报错");
                    }

                }

//                // 命令下发区 --------------------------------------------------------------------------
@@ -543,6 +620,21 @@

                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                        if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
                            // 获取浅库位，状态为S直接出，状态为R，则找到这个库位的工作档，提升优先级先出
                            String shallowLoc = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
                            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", shallowLoc));
                            if (locMast.getLocSts().equals("Z")) {
                                List<TaskWrk> wrkMastList = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>().eq("start_point", locMast.getLocNo()));
                                if (!wrkMastList.isEmpty()) {
                                    TaskWrk wrkMast = wrkMastList.get(0);
                                    wrkMast.setIoPri(99);
                                    taskWrkMapper.updateById(wrkMast);
                                    log.warn("{}对应浅库位有货，提升{}库位优先级",taskWrk.getStartPoint(),wrkMast.getStartPoint());
                                    continue;
                                } else {
                                    log.error("{}对应浅库位有货，但没有移库任务",taskWrk.getStartPoint());
                                }
                            }

                            taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());

@@ -599,19 +691,27 @@
                            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                            Date now = new Date();
                            taskWrk.setWrkSts(12);
                            taskWrk.setExecuteTime(now);
                            taskWrk.setModiTime(now);
                            if (taskWrkMapper.updateById(taskWrk) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                            }
                            //开始运行
                            String response = CrnStartRunning(taskWrk);
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {

                            }else {
                                log.error("出库开始运行通讯失败,"+jsonObject.get("msg"));

                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中！！，工作号={}", taskWrk.getWrkNo());
                            }
                            try {
                                //开始运行
                                String response = CrnStartRunning(taskWrk);
                                JSONObject jsonObject = JSON.parseObject(response);
                                if (jsonObject.getInteger("code").equals(200)) {

                                }else {
                                    log.error("出库开始运行wms失败,"+jsonObject.get("msg"));

                                }
                            }catch (Exception e){
                                log.error("出库开始运行wms失败,");
                            }

                        }

                    }
@@ -631,7 +731,6 @@
                    .eq("wrk_sts",11)
                    .eq("io_type",3));
            for (TaskWrk taskWrk : taskWrks){

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
                    String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
@@ -641,7 +740,7 @@
                    }
                }
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                if (!crnProtocol.getModeType().equals(CrnModeType.AUTO) || !crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

@@ -723,16 +822,23 @@
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }else{
                        log.info("移库任务下发任务成功，修改工作档状态 11.生成出库ID => 12.吊车出库中 ，工作号={}", taskWrk.getWrkNo());
                    }
                    //开始运行
                    String response = CrnStartRunning(taskWrk);
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                    try{
                        String response = CrnStartRunning(taskWrk);
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {

                    }else {
                        log.error("移库任务开始运行通讯失败,"+jsonObject.get("msg"));
                        continue;
                        }else {
                            log.error("移库任务开始运行wms返回失败,"+jsonObject.get("msg"));
                            continue;
                        }
                    }catch (Exception e){
                        log.error("移库任务开始运行请求wms报错,"+e.getMessage());
                    }

                    break;
                }
                return;
@@ -744,7 +850,7 @@
    /**
     * 执行对工作档的完成操作
     */
    @Async

    public void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -756,36 +862,47 @@
            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
                //获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());

                if (Cools.isEmpty(taskWrk)) {
//                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    continue;
                }

                log.info("收到申请完成请求：" + taskWrk);
                //获取指令ID
                Integer commandId = crnProtocol.getCommandId();
                CommandInfo commandInfo = new CommandInfo();
                if (Cools.isEmpty(commandId)){
                    commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
                            .eq("wrk_no",crnProtocol.getTaskNo())
                            .eq("device","Crn"));
                }else {
                    commandInfo = commandInfoService.selectById(commandId);
                }
//                Integer commandId = crnProtocol.getCommandId();
//                CommandInfo commandInfo = new CommandInfo();
//                if (Cools.isEmpty(commandId)){
//                    commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
//                            .eq("wrk_no",crnProtocol.getTaskNo())
//                            .eq("device","Crn"));
//                }else {
//                    commandInfo = commandInfoService.selectById(commandId);
//                }


                if (commandInfo == null) {
                    //指令不存在
                    continue;
                }
                if (commandInfo.getCommandStatus() == 3){
                    continue;
                }
                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
                commandInfo.setCompleteTime(new Date());//指令完成时间
                if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
//                if (commandInfo == null) {
//                    //指令不存在
//                    continue;
//                }
//                if (commandInfo.getCommandStatus() == 3){
//                    continue;
//                }
//                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
//                commandInfo.setCompleteTime(new Date());//指令完成时间
//                if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                }
                    if (taskWrk.getIoType() == 1 || taskWrk.getIoType() == 3){
                        taskWrk.setWrkSts(4);
                    } else if (taskWrk.getIoType() == 2) {
                        taskWrk.setWrkSts(14);
                    }
                    Date now = new Date();
                    taskWrk.setCompleteTime(now);
                    if (!taskWrkService.updateById(taskWrk)){
                        log.error(taskWrk.getTaskNo()+ " 堆垛机任务完成，改变任务状态失败");
                    }
//                }
            }
        }
    }
@@ -837,7 +954,7 @@
    /**
     * 堆垛机异常信息记录
     */
    @Async

    public void recCrnErr(){
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
@@ -967,8 +1084,8 @@
        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {
            try {
                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
            } catch (CoolException e) {
                log.info(e.getMessage());
            } catch (Exception e) {
//                log.error("自动派发任务异常："+e.getMessage()+"{" + taskWrk.toString());
            }
        }
    }
@@ -977,48 +1094,74 @@
    public synchronized void autoCompleteTask() {
        List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
        for (TaskWrk taskWrk : taskWrks) {
            //获取命令集合
            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
            if (taskWrk.getCommandStep() < commandInfos.size()) {
                continue;//当前步序没有到达最后一条命令
            }
//            //获取命令集合
//            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
//            if (taskWrk.getCommandStep() < commandInfos.size()) {
//                continue;//当前步序没有到达最后一条命令
//            }
//
//            //判断末端命令是否执行完成
//            if (!commandInfos.isEmpty()){
//                CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
//                if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
//                    continue;//指令未完成
//                }
//            }

            //判断末端命令是否执行完成
            CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
            if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
                continue;//指令未完成
            }

            Date now = new Date();
            //指令已完成，更新任务
            if (taskWrk.getIoType() == 1) {
            if (taskWrk.getIoType() == 1 && taskWrk.getWrkSts() == 5) {
                //入库任务
                taskWrk.setWrkSts(4);//3.吊车入库中 => 4.入库完成
                //taskWrk.setStatus(TaskStatusType.COMPLETE.id);
//                taskWrk.setWrkSts(4);//3.吊车入库中 => 4.入库完成
                taskWrk.setStatus(TaskStatusType.OVER.id);
                taskWrk.setModiTime(now);
                taskWrkService.updateById(taskWrk);

                //更新库位状态
                LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                locMast.setLocSts("F");//F.在库
                locMast.setLocSts("Z");//F.在库
                locMast.setBarcode(taskWrk.getBarcode());//托盘码
                locMast.setModiTime(now);
                locMast.setModiUser(9999L);
                locMastService.updateById(locMast);
            } else if (taskWrk.getIoType() == 2) {
            } else if (taskWrk.getIoType() == 2 && taskWrk.getWrkSts() == 15) {
                //出库任务
                taskWrk.setWrkSts(14);//12.吊车出库中 => 14.出库完成
//                taskWrk.setStatus(TaskStatusType.COMPLETE.id);
//                taskWrk.setWrkSts(14);//12.吊车出库中 => 14.出库完成
                taskWrk.setStatus(TaskStatusType.OVER.id);
                taskWrk.setModiTime(now);
                taskWrkService.updateById(taskWrk);

                //更新库位状态
                LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
                locMast.setLocSts("O");//O.空库位
                locMast.setLocSts("K");//O.空库位
                locMast.setBarcode("");//托盘码
                locMast.setModiTime(now);
                locMast.setModiUser(9999L);
                locMastService.updateById(locMast);
            } else if (taskWrk.getIoType() == 3 && taskWrk.getWrkSts() == 5) {

                //更新起始库位状态
                LocMast locMastStart = locMastService.selectByLocNo(taskWrk.getStartPoint());
                locMastStart.setLocSts("K");//O.空库位
                locMastStart.setBarcode("");//托盘码
                locMastStart.setModiTime(now);
                locMastStart.setModiUser(9999L);
                locMastService.updateById(locMastStart);

                //更新目标库位状态
                LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                locMast.setLocSts("Z");//F.在库
                locMast.setBarcode(taskWrk.getBarcode());//托盘码
                locMast.setModiTime(now);
                locMast.setModiUser(9999L);
                locMastService.updateById(locMast);

                taskWrk.setStatus(TaskStatusType.OVER.id);
                taskWrk.setModiTime(now);
                taskWrkService.updateById(taskWrk);


            }
        }
    }