no message

skyouc

2025-08-07 d52bab61f91056e75e60ddeda76a72cd1bd63615

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/services/Impl/WcsApiServiceImpl.java

@@ -1,28 +1,42 @@
package com.zy.asrs.wms.apis.wcs.services.Impl;



import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;

import com.zy.asrs.framework.common.Cools;

import com.zy.asrs.framework.common.R;

import com.zy.asrs.wms.apis.wcs.entity.domain.EssTaskStatus;

import com.zy.asrs.framework.exception.CoolException;

import com.zy.asrs.wms.apis.wcs.entity.domain.SystemProperties;

import com.zy.asrs.wms.apis.wcs.entity.enums.EssTaskStatus;

import com.zy.asrs.wms.apis.wcs.entity.request.*;

import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;

import com.zy.asrs.wms.apis.wcs.services.WcsApiService;

import com.zy.asrs.wms.asrs.entity.Task;

import com.zy.asrs.wms.asrs.entity.WaitPakin;

import com.zy.asrs.wms.apis.wcs.utils.HttpEssUtils;

import com.zy.asrs.wms.asrs.entity.*;

import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;

import com.zy.asrs.wms.asrs.entity.enums.OrderPickStatus;

import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;

import com.zy.asrs.wms.asrs.service.TaskService;

import com.zy.asrs.wms.asrs.service.WaitPakinService;

import com.zy.asrs.wms.asrs.service.WorkService;

import com.zy.asrs.wms.asrs.service.*;

import io.jsonwebtoken.lang.Collections;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpEntity;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpMethod;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.util.LinkedMultiValueMap;

import org.springframework.util.MultiValueMap;

import org.springframework.web.client.RestTemplate;



import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import javax.annotation.Resource;

import java.util.*;

import java.util.stream.Collectors;

import java.util.stream.DoubleStream;



@Slf4j

@Service

public class WcsApiServiceImpl implements WcsApiService {



@@ -32,105 +46,404 @@
    private WorkService workService;

    @Autowired

    private TaskService taskService;

    @Autowired

    private TaskDetlService taskDetlService;

    @Autowired

    private CacheSiteService cacheSiteService;

    @Autowired

    private OrderService orderService;

    @Autowired

    private OrderDetlService orderDetlService;

    @Autowired

    private WaveSeedService waveSeedService;



    @Override

    public CommonReponse publishTaskOfCarry() {

        //获取组拖通知档中，状态为正常，组托状态为待入库且未删除的WaitPakins

        List<WaitPakin> list = waitPakinService.list(new LambdaQueryWrapper<WaitPakin>()

                .eq(WaitPakin::getStatus, 1)

                .eq(WaitPakin::getIoStatus, 0)

                .eq(WaitPakin::getDeleted, 0));

        if (!list.isEmpty()) {

            return publishTaskOfCarry(list);

        }

        return new CommonReponse();

    }

    @Autowired

    private RestTemplate restTemplate;



    /**

     * 下发料箱（容器）滚动至扫码区

     * //TODO 已费弃

     *

     * @param pakins

     * @return

     */

    @Override

    public CommonReponse publishTaskOfCarry(List<WaitPakin> pakins) {

        PublishTasksParam tasksParam = new PublishTasksParam();

        tasksParam.setTaskType("carry");

        List<TaskParam> tasks = new ArrayList<>();

        Map<String, List<WaitPakin>> barcodes = pakins.stream().collect(Collectors.groupingBy(WaitPakin::getBarcode));

        /**

         * 当前问题：

         * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置

         * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能

         * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区

         * */

        barcodes.keySet().forEach(actionKey -> {

            List<TaskDescribe> taskDescribes = new ArrayList<>();

            barcodes.get(actionKey).forEach(action -> {

                TaskDescribe taskDescribe = new TaskDescribe();

                taskDescribe.setContainerCode(action.getBarcode());

                taskDescribes.add(taskDescribe);

            });

        });



        if (!pakins.isEmpty()) {

            pakins.forEach(waitPakin -> {



            });

        }

        tasksParam.setTasks(tasks);



        return null;

    }

    @Autowired

    private PlatformService platformService;

    @Resource

    private SystemProperties systemProperties;

    @Autowired

    private MobileService mobileService;





    /**

     * 容器到达接收

     * 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档执行状态

     * * 当前问题：

     * * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置

     * * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能

     * * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区

     *

     * @param arrivedParam

     * @param hostId

     * @return

     */

    @Override

    @Transactional

    public R containerArrivedNotify(ContainerArrivedParam arrivedParam) {

        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));

        if (!Collections.isEmpty(tasks)) {

    @Transactional(rollbackFor = Exception.class)

    public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType, Long hostId) {

        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));

        if (task == null) {

            return R.error("任务不存在！！");

//            throw new CoolException("任务不存在！！");

        }

        log.info("容器到达接收，任务号：{}，当前状态：{}，上报状态：{}, 接收参数：{}", task.getTaskNo(), task.getTaskSts$(), TaskStsType.WCS_CONTAINER_RECEIVE.desc, JSONObject.toJSONString(arrivedParam));



        //DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态

        taskService.update(new LambdaUpdateWrapper<Task>()

                .set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)

                .set(Task::getOriginLoc, arrivedParam.getSlotCode())

                .eq(Task::getBarcode, arrivedParam.getContainerCode()));

        taskType = task.getTaskType() > 100 ? "outStock" : "inStock";



        if (taskType.equals("inStock")) {

            if (task.getTaskSts() == 198) {

                return R.error("播种中！！");

            }

            if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_IN.id) {

                //DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态

                taskService.update(new LambdaUpdateWrapper<Task>()

                        .set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)

                        //输送线节点编码，不是源库位

                        .set(Task::getOriginSite, arrivedParam.getSlotCode())

                        .eq(Task::getBarcode, arrivedParam.getContainerCode()));

            } else {

                log.warn("{}没有下发任务", task.getTaskNo());

                R.error(task.getTaskNo() + "没有下发任务");

            }

        } else {

            if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_ARRIVED.id

                    || task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id) {



                boolean update = taskService.update(new LambdaUpdateWrapper<Task>()

                        .set(Task::getTaskSts, TaskStsType.WAVE_SEED.id)

                        .set(Task::getOriginSite, arrivedParam.getSlotCode())

                        .eq(Task::getBarcode, arrivedParam.getContainerCode()));

                if (!update) {

                    throw new CoolException("容器到达任务更新失败！！");

                }

            } else if (task.getTaskSts().equals(TaskStsType.UPDATED_OUT.id)) {

                ConveyorStarParam conveyorStarParam = new ConveyorStarParam();

                conveyorStarParam.setSlotCode(task.getOriginSite())

                        .setContainerCode(task.getBarcode())

                        .setDirection("200");

                // 出库完成，清除输送线条码，取下箱子

                CommonReponse response = HttpEssUtils.post("清除输送线条码", HttpEssUtils.CONVEYOR_START, conveyorStarParam);

                if (response.getCode().equals(200)) {

                    log.info("{}出库完成，清除{}输送线条码{}成功", task.getTaskNo(), task.getOriginSite(), task.getBarcode());

                }

            }

        }



        return R.success("success");

    }



    /**

     * 容器执行状态上报

     *

     * @param callbackParam

     * @param stockType

     * @param hostId

     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public boolean receiveTaskStatus(TasksStatusCallbackParam callbackParam) {

        TaskStsType taskStsType = TaskStsType.WCS_CONTAINER_RECEIVE;



       if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态

           taskStsType = TaskStsType.WCS_TOTE_LOAD;

        } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态

           taskStsType = TaskStsType.WCS_TOTE_UNLOAD;

        } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件

           taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;

       }



        return taskService.update(new LambdaUpdateWrapper<Task>()

                .set(Task::getRobotCode, callbackParam.getRobotCode())

                .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())

                .set(Task::getTaskSts, taskStsType.id)

                .set(Task::getExcudeStatus, callbackParam.getStatus())

                .set(Task::getTaskDesc, callbackParam.getMessage())

    public void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType, Long hostId) {

        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>()

                .eq(Task::getBarcode, callbackParam.getContainerCode())

                .eq(Task::getTaskNo, callbackParam.getTaskCode()));

        if (!Collections.isEmpty(list)) {

            list.forEach(task -> {

                log.info("容器执行状态上报，任务号：{}，当前状态：{}，上报状态：{}", task.getTaskNo(), task.getTaskSts$(), callbackParam.getEventType());

                if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_ALLOCATED.event)) {

                    return;

                }

                // ESS只能配置一个状态上报接口，根据任务号判断是入库任务或出库任务

                String taskType = task.getTaskType() > 100 ? "outStock" : "inStock";

                TaskStsType taskStsType = null;

                if (taskType.equals("inStock")) { //入库任务

                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态

//                        if (task.getTaskSts() == TaskStsType.WCS_CONVEYOR_START.id) {

                        taskStsType = TaskStsType.WCS_TOTE_LOAD;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_LOAD.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态

//                        if (task.getTaskSts() == TaskStsType.WCS_TOTE_LOAD.id) {

                        taskStsType = TaskStsType.WCS_TOTE_UNLOAD;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_UNLOAD.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件

//                        if (task.getTaskSts() == TaskStsType.WCS_TOTE_UNLOAD.id) {

                        taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_PUTAWAY_SUCESS.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    }

                    boolean result = taskService.update(new LambdaUpdateWrapper<Task>()

                            .set(Task::getRobotCode, callbackParam.getRobotCode())

//                            .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())

                            .set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())

                            .set(Task::getExcudeStatus, callbackParam.getStatus())

                            .set(Task::getTaskDesc, callbackParam.getMessage())

                            .eq(Task::getBarcode, callbackParam.getContainerCode())

                            .eq(Task::getTaskNo, callbackParam.getTaskCode()));



                    //event事件为task，表明任务上报完成状态

                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event) && result) {

                        //任务状态修改为 99 入库完成

                        workService.completeTask(task.getId());

                    }

                } else { //出库任务

                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态

//                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id ) {

                        taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态

//                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id) {

                        taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //上报完成状态

//                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.id || task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id) {

                        //出库任务完成，修改状态为容器到达，定时任务生成播种波次

                        taskStsType = TaskStsType.WCS_EXECUTE_OUT_TASK_DONE;

//                        } else {

//                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.desc + "任务";

//                            log.error(errMsg);

//                            throw new CoolException(errMsg);

//                        }

                    }

                    //更新出库状态及相关字段

                    boolean update = taskService.update(new LambdaUpdateWrapper<Task>()

                            .set(Task::getRobotCode, callbackParam.getRobotCode())

                            .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())

                            .set(Task::getTaskSts, taskStsType != null ? taskStsType.id : task.getTaskType())

                            .set(Task::getExcudeStatus, callbackParam.getStatus())

                            .set(Task::getTaskDesc, callbackParam.getMessage())

                            .eq(Task::getBarcode, callbackParam.getContainerCode())

                            .eq(Task::getTaskNo, callbackParam.getTaskCode()));



                    if (!update) {

                        throw new CoolException("任务更新失败！！");

                    }



                }



            });

        } else {

            throw new CoolException("更新内容不存在！！");

        }

    }



    /**

     * 容器流动通知

     *

     * @param code

     * @return

     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public synchronized R containerConveryor(String code) throws Exception {

        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));

        if (Objects.isNull(task)) {

            throw new CoolException("容器码任务不存在！！");

        }

        try {

            ConveyorStarParam conveyorStarParam = new ConveyorStarParam();

            conveyorStarParam.setSlotCode(task.getOriginSite())

                    .setContainerCode(task.getBarcode());

            if (task.getTaskType() == 101) { //任务类型为101全盘出库，直接取下容器，传200

                conveyorStarParam.setDirection("200");

            } else if (task.getTaskType() == 103 || task.getTaskType() == 107) { //如果为任务类型为103，需走回库操作，传100

                conveyorStarParam.setDirection("100");

            }

            //调用三方接口，将任务推送至ESS平台

            MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();

            // 设置请求参数

            HttpHeaders headers = new HttpHeaders();

            headers.add("Content-Type", "application/json");

            headers.add("api-version", "v2.0");

            HttpEntity httpEntity = new HttpEntity<>(conveyorStarParam, headers);

            log.info("请求地址：{}，请求参数：{}", HttpEssUtils.CONVEYOR_START, JSONObject.toJSONString(conveyorStarParam));

            ResponseEntity<String> exchange = restTemplate.exchange("http://192.168.2.200:9046/conveyor/moveContainer", HttpMethod.POST, httpEntity, String.class);

            log.info("下发流动通知 返回结果：{}", exchange);

            if (exchange.getBody() == null) {

                throw new CoolException("下发流动通知失败！！");

            } else {

                CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);

                if (commonReponse.getCode() == 0) {

                    //流动通知下发完成后，修改任务状态为输送线流动中。。

                    if (task.getTaskType() == 103 || task.getTaskType() == 107) {

                        //更新库存信息,修改任务状态为4 （RCS容器流动任务已下发）

                        workService.pickTask(task.getId());

                    } else {

                        taskService.update(new LambdaUpdateWrapper<Task>()

                                .eq(Task::getId, task.getId())

                                .set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));

                    }

                    log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());

                } else {

                    throw new CoolException("下发流动通知失败！！");

                }

            }

        } catch (Exception ex) {

            log.error("UNK", ex);

        }

        return R.ok();

    }





    @Override

    public R rfidCallback(RfidSingalRequest request) {

        return null;

    }



    @Override

    public R getPlatforms() {

        return R.ok(platformService.list(new LambdaQueryWrapper<>()));

    }



    /**

     * 拍灯拣料逻辑，详细说明见接口调用说明

     *

     * @param request

     * @return

     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public R slapLightLogic(Map<String, Object> request) {

        String taskNo = request.get("taskNo").toString();

        String orderNo = request.get("orderNo").toString();

        String siteNo = Objects.isNull(request.get("siteNo")) ? null : request.get("siteNo").toString();

        List<CacheSite> performs = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));

        if (Objects.isNull(performs.stream().findFirst().get().getPlatformId())) {

            throw new CoolException("请打印明细，并绑定目标集货区");

        }

        //* 1. 判断当前容器是否还有物料未拣，未拣完闪灯，拣完通知容器流动，并灭灯

        SlapLightControlParam slapParam = new SlapLightControlParam();

        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();

        Order one = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, orderNo));

        if (Objects.isNull(one)) {

            throw new CoolException("当前订单明细不存在！！");

        }



        if (Cools.isEmpty(slapParam)) {

            return null;

        }



        //判断当前任务是否还有物料未拣

        if (!checked(orderNo, taskNo)) {

            log.info("未完成闪灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));

            //调用三方接口,闪灯不做操作

            // 设置请求参数

            mobileService.sowLightMange(siteNo, one, "LIGHT");

//            throw new CoolException("当前任务未完成，不能执行此操作！！");

//            params.add("params", JSONObject.toJSONString(slapParam));

        } else {

            //调用三方接口,灭灯通知容器流动， 传灭灯参数

            //todo 判断当前订单是否完成，完成灭灯，未完成保持拣货状态亮灯



//            //获取播种已完成的订单明细

//            List<OrderDetl> detlList = orderDetls.stream().filter(detl -> {

//                return detl.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val;

//            }).collect(Collectors.toList());

            //判断数量是否与订单明细的需求量相同，相同则订单完成



            List<WaveSeed> seeds = waveSeedService.list(new LambdaQueryWrapper<WaveSeed>().eq(WaveSeed::getOrderNo, orderNo));

            if (Objects.isNull(seeds)) {

                throw new CoolException("数据错误：播种数据不存在！！");

            }

            Double tolAnfme = seeds.stream().mapToDouble(WaveSeed::getAnfme).sum();

            Double toDouble = seeds.stream().mapToDouble(WaveSeed::getWorkQty).sum();

            if (toDouble.compareTo(tolAnfme) >= 0) {

                //播种完成，释放绑定站点

                List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>()

                        .eq(!Objects.isNull(siteNo), CacheSite::getSiteNo, siteNo)

                        .eq(CacheSite::getOrderNo, orderNo));

                for (CacheSite cacheSite : cacheSites) {

                    if (!cacheSite.getSiteStatus().equals(CacheSiteStatusType.O.id)) {

                        cacheSite.setSiteStatus(CacheSiteStatusType.O.id);

                        cacheSite.setOrderId(null);

                        cacheSite.setBarcode(null);

                        cacheSite.setOrderNo(null);

                        cacheSite.setPlatformId(null);

                        cacheSite.setPlatformNo(null);

                        cacheSite.setUpdateTime(new Date());

                        if (!cacheSiteService.updateById(cacheSite)) {

                            throw new CoolException("播种站点更新失败");

                        }

                    }

                }

                //订单完成，灭灯

                mobileService.sowLightMange(siteNo, one, "DARK");

                log.info("完成灭灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));

            } else {

                //订单未完成，继续亮灯

                mobileService.sowLightMange(siteNo, one, "LIGHT");

                log.info("继续亮灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));



            }

            params.add("params", JSONObject.toJSONString(slapParam));

            log.info("完成灭灯请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));

        }



        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, request.get("taskNo")));

        if (Objects.isNull(task)) {

            throw new CoolException("任务不存在！！");

        }

        try {

            containerConveryor(task.getBarcode());

        } catch (Exception e) {

            log.error("执行异常:UNK", e);

            throw new CoolException(e.getMessage());

        }

        return R.ok();

    }



    /**

     * 判断当前任务下，订单是否已完成拣货

     *

     * @param orderNo

     * @param taskNo

     * @return

     */

    public synchronized boolean checked(String orderNo, String taskNo) {

        if (Objects.isNull(orderNo)) {

            throw new CoolException("订单编码不能为空！！");

        }

        if (Objects.isNull(taskNo)) {

            throw new CoolException("任务编码不能为空！！");

        }



        List<TaskDetl> taskDetls = taskDetlService.list(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getTaskNo, taskNo));

        if (taskDetls.isEmpty()) {

            throw new CoolException("订单明细不存在！！");

        }



        List<Long> detlIds = taskDetls.stream().map(TaskDetl::getId).collect(Collectors.toList());



        double taskNum = taskDetls.stream().mapToDouble(TaskDetl::getAnfme).sum();



        List<WaveSeed> seeds = waveSeedService.list(new LambdaQueryWrapper<WaveSeed>().in(WaveSeed::getTaskDetlId, detlIds));

        if (seeds.isEmpty()) {

            throw new CoolException("播种信息不存在！！！");

        }

        double seedNum = seeds.stream().mapToDouble(WaveSeed::getWorkQty).sum();

        //判断任务需求总量是否等播种总数量

        if (taskNum == seedNum) {

            return true;

        } else {

            return false;

        }

    }



}