#拣货单功能

DESKTOP-LMJ82IJ\Eno

2025-01-07 adfce6c5a94c7aefa9b5d4f67e63db7eaac268d9

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

@@ -3,26 +3,25 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

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

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.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.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 io.jsonwebtoken.lang.Collections;

import lombok.extern.slf4j.Slf4j;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;



import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;



@Slf4j

@Service

public class WcsApiServiceImpl implements WcsApiService {



@@ -33,104 +32,210 @@
    @Autowired

    private TaskService taskService;



    @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();

    }



    /**

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

     * //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;

    }





    /**

     * 容器到达接收

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

     * * 当前问题：

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

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

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

     *

     * @param arrivedParam

     * @param hostId

     * @return

     */

    @Override

    @Transactional

    public R containerArrivedNotify(ContainerArrivedParam arrivedParam) {

    @Transactional(rollbackFor = Exception.class)

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

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

        if (Collections.isEmpty(tasks)) {

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

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

        }



        //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()));

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

            //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()));

        } else {

            //容器到达时更新任务状态为：入库完成，定时任务根据状态码更新库存

            //当状态为入库完成时，更新库存信息

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

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

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

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

            //fixme 容器到达状态更改为播种中...

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

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

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

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



        }



        return R.success("success");

    }



    @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 -> {

                    TaskStsType taskStsType = null;

                    if (stockType.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.id)

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

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

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

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



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

                            workService.completeTask(task.getId());

                        }

                    } else { //出库任务

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

                            //TODO 定时器开启后，要删除 || task.getTaskType() == TaskStsType.GENERATE_OUT.id

                            if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id || task.getTaskSts() == TaskStsType.GENERATE_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);

                            }

                        }



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

                         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())

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

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



                    }



                });

        } else {

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

        }

    }



    /**

     * 容器流动通知

     * @param code

     * @return

     */

    @Override

    public R containerConveryor(String code) {

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

        if (tasks.isEmpty()) {

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

        } else if (tasks.size() > 1){

            return R.error("容器码任务错误！！");

        }

        tasks.forEach(task -> {

            //            try {

//                ConveyorStarParam conveyorStarParam = new ConveyorStarParam();

//                conveyorStarParam.setSlotCode(task.getOriginLoc())

//                        .setContainerCode(task.getBarcode());

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

//                    conveyorStarParam.setDirection("200");

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

//                    conveyorStarParam.setDirection("100");

//                }

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

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

//                // 设置请求参数

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

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

//                HttpHeaders headers = new HttpHeaders();

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

//                HttpEntity httpEntity = new HttpEntity<>(params, headers);

//                // 请求

//                ResponseEntity<String> exchange = restTemplate.exchange(Constant.CONVEYOR_START, 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) {

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

            //TODO 判断任务是否为103拣料出库，103拣料流动后修改为4（RCS容器流动任务已下发）

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

                workService.pickTask(task.getId());

//                taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId()).set(Task::getTaskSts, TaskStsType.WCS_CONVEYOR_START))

            } 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(ex.getMessage());

//            } finally {

//                //如果异常修改禁用状态

//                taskService.update(new LambdaUpdateWrapper<Task>().set(Task::getStatus, 0)

//                        .set(Task::getUpdateTime, new Date())

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

//            }

        });

        return R.ok();

    }



}