添加出库流程

skyouc

2024-12-23 2cf6f25ee51dea59dbd1e2183a06796961bb8644

添加出库流程

 zy-asrs-admin/src/components/order/order/index.vue

@@ -1,30 +1,44 @@
<template>

    <div v-if="props.ioModel === 'in'">

        <OrderInView ioModel="in"/>

    </div>

    <div v-else-if="props.ioModel === 'out'">

        <OrderOutView ioModel="out"/>

    </div>

    <div v-else>

        <OrderView/>

    </div>

</template>

<script setup>

import { defineProps } from 'vue';

import OrderView from './order.vue'

import OrderInView from './orderIn.vue'

import OrderOutView from './orderOut.vue'



const props = defineProps({

  ioModel: null

})

    const props = defineProps({

        ioModel: null

    })

</script>



<script>

export default {

  name: '订单'

}

    import {defineProps} from 'vue';

    import OrderView from './order.vue'

    import OrderInView from './orderIn.vue'

    import OrderOutView from './orderOut.vue'

    export default {

        name: '订单',

        // props: {

        //     ioModel: null,

        // },

        data() {

            return {}

        },

        created() {



        },

        components: {

            OrderInView,

            OrderOutView,

            OrderView

        }

    }

</script>

<style>



<template>

  <div v-if="props.ioModel === 'in'">

    <OrderInView ioModel="in" />

  </div>

  <div v-else-if="props.ioModel === 'out'">

    <OrderOutView ioModel="out" />

  </div>

  <div v-else>

    <OrderView />

  </div>

</template>



<style></style>

</style>


 zy-asrs-admin/src/components/order/order/order.vue

@@ -161,6 +161,7 @@
  }).then((resp) => {

    let result = resp.data;

    if (result.code == 200) {

        console.log('--------->')

      let data = result.data;

      tableData.value = data;




 zy-asrs-admin/src/views/out/order/index.vue

@@ -1,17 +1,27 @@
<script setup>

import OrderView from '@/components/order/order/index.vue';

</script>

<template>

    <div>

        <OrderView ioModel="out"/>

    </div>

</template>



<script>

export default {

  name: '出库订单'

}

</script>

    import OrderView from '@/components/order/order/index.vue';

    export default {

        name: 'OutOrder',

        data() {

            return {}

        },

        components: {

            OrderView,

        },

        created() {



<template>

  <div>

    <OrderView ioModel="out"  />

  </div>

</template>

        },

        mounted() {



        },

        methods: {}

    }

</script>



<style></style>


 zy-asrs-framework/src/main/java/com/zy/asrs/framework/common/BaseRes.java

@@ -3,7 +3,7 @@
public interface BaseRes {



    String OK = "200-操作成功";

    String SUCESS = "0";

    String SUCESS = "sucess";

    String EMPTY = "201-暂无数据";

    String LIMIT = "202-无权限";

    String PARAM = "401-参数为空";


 zy-asrs-framework/src/main/java/com/zy/asrs/framework/common/R.java

@@ -22,12 +22,10 @@
        return parse(BaseRes.OK);

    }



    public static R success(){return  parse(BaseRes.SUCESS);}

    public static R success(){return  success(BaseRes.SUCESS);}



    public static R success(String msg){

        R r = success();

        r.put(MSG, msg);

        return r;

        return new R(0, msg);

    }



    public static R ok(String msg){


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/InStockController.java

File was renamed from zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/WcsApiController.java
@@ -2,7 +2,6 @@


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

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

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

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

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

import io.netty.util.internal.StringUtil;

@@ -12,9 +11,9 @@
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;



@RequestMapping("/openapi/")

@RequestMapping("/in/stock/")

@RestController

public class WcsApiController {

public class InStockController {



    @Autowired

    private WcsApiService wcsApiService;

@@ -35,7 +34,7 @@
            return R.error("输送线节点编码不能为空！！");

        }



        return wcsApiService.containerArrivedNotify(arrivedParam);

        return wcsApiService.containerArrivedNotify(arrivedParam, "inStock");



    }



@@ -54,28 +53,12 @@
            if (StringUtil.isNullOrEmpty(callbackParam.getTaskCode())) {

                return R.error("任务编码不能为空！！");

            }

            boolean result = wcsApiService.receiveTaskStatus(callbackParam);

           wcsApiService.receiveTaskStatus(callbackParam, "inStock");

        } else {

            return R.error("上报事件类型不能为空！！");

        }



        return R.success();

    }





//    /**

//     * 下发点对点搬运任务

//     * @param

//     * @return

//     */

//    @PostMapping("/carry")

//    public R publishTaskOfCarry() {

//        PublishTasksReponse reponse = wcsApiService.publishTaskOfCarry();

//        if (reponse.getCode() == 0) {

//            return R.ok(reponse.getData());

//        } else {

//            return R.error(reponse.getMsg());

//        }

//    }



}


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/OutStockController.java

copy from zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/WcsApiController.java
copy to zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/OutStockController.java
File was copied from zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/controller/WcsApiController.java
@@ -1,81 +1,66 @@
package com.zy.asrs.wms.apis.wcs.controller;



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

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

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

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

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

import io.netty.util.internal.StringUtil;

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

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;



@RequestMapping("/openapi/")

@RestController

public class WcsApiController {



    @Autowired

    private WcsApiService wcsApiService;





    /***

     * 容器到达接收

     * @param arrivedParam

     * @return

     */

    @PostMapping("/container/arrived")

    public R containerArrivedNotify(@RequestBody ContainerArrivedParam arrivedParam) {



        if (StringUtil.isNullOrEmpty(arrivedParam.getContainerCode())) {

            return R.error("容器编码不能为空！！");

        }

        if (StringUtil.isNullOrEmpty(arrivedParam.getSlotCode())) {

            return R.error("输送线节点编码不能为空！！");

        }



        return wcsApiService.containerArrivedNotify(arrivedParam);



    }





    /**

     * ESS上报任务状态接口

     * @param callbackParam

     * @return

     */

    @PostMapping("/receive/tasks/status")

    public R receiveTaskStatus(@RequestBody TasksStatusCallbackParam callbackParam) {

        if (!StringUtil.isNullOrEmpty(callbackParam.getEventType())) {

            if (StringUtil.isNullOrEmpty(callbackParam.getContainerCode())) {

                return R.error("容器编码不能为空！！");

            }

            if (StringUtil.isNullOrEmpty(callbackParam.getTaskCode())) {

                return R.error("任务编码不能为空！！");

            }

            boolean result = wcsApiService.receiveTaskStatus(callbackParam);

        } else {

            return R.error("上报事件类型不能为空！！");

        }



        return R.success();

    }





//    /**

//     * 下发点对点搬运任务

//     * @param

//     * @return

//     */

//    @PostMapping("/carry")

//    public R publishTaskOfCarry() {

//        PublishTasksReponse reponse = wcsApiService.publishTaskOfCarry();

//        if (reponse.getCode() == 0) {

//            return R.ok(reponse.getData());

//        } else {

//            return R.error(reponse.getMsg());

//        }

//    }



}

package com.zy.asrs.wms.apis.wcs.controller;


import com.zy.asrs.framework.common.R;
import com.zy.asrs.wms.apis.wcs.entity.request.ContainerArrivedParam;
import com.zy.asrs.wms.apis.wcs.entity.request.TasksStatusCallbackParam;
import com.zy.asrs.wms.apis.wcs.services.WcsApiService;
import io.netty.util.internal.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/out/stock/")
public class OutStockController {

    @Autowired
    private WcsApiService wcsApiService;

    /**
     * 出库任务-接收回调状态接口
     * @param callbackParam
     * @return
     */
    @PostMapping("/receive/tasks/status")
    public R receiveTaskStatus(@RequestBody TasksStatusCallbackParam callbackParam) {
        if (!StringUtil.isNullOrEmpty(callbackParam.getEventType())) {
            if (StringUtil.isNullOrEmpty(callbackParam.getContainerCode())) {
                return R.error("容器编码不能为空！！");
            }
            if (StringUtil.isNullOrEmpty(callbackParam.getTaskCode())) {
                return R.error("任务编码不能为空！！");
            }
            wcsApiService.receiveTaskStatus(callbackParam, "outStock");
        } else {
            return R.error("上报事件类型不能为空！！");
        }

        return R.success();
    }

    /***
     * 容器到达接收
     * @param arrivedParam
     * @return
     */
    @PostMapping("/container/arrived")
    public R containerArrivedNotify(@RequestBody ContainerArrivedParam arrivedParam) {

        if (StringUtil.isNullOrEmpty(arrivedParam.getContainerCode())) {
            return R.error("容器编码不能为空！！");
        }
        if (StringUtil.isNullOrEmpty(arrivedParam.getSlotCode())) {
            return R.error("输送线节点编码不能为空！！");
        }

        return wcsApiService.containerArrivedNotify(arrivedParam, "outStock");

    }


}

 zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/entity/domain/Constant.java

@@ -5,7 +5,7 @@


    private static String HOST = "http://localhost:8080";



    public static String ISSUE_TASK_OF_PUTAWAY = HOST +  "/task/create";

    public static String ISSUE_TASK_OF_EVENT = HOST +  "/task/create";



    public static String CONVEYOR_START = HOST + "/conveyor/moveContainer";

}


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/apis/wcs/schedule/ScheduleJobs.java

@@ -33,6 +33,7 @@


import java.util.ArrayList;

import java.util.Comparator;

import java.util.Date;

import java.util.List;

import java.util.stream.Collectors;



@@ -42,21 +43,19 @@


    @Autowired

    private DataSourceTransactionManager transactionManager;



    @Autowired

    private TaskService taskService;



    @Autowired

    private RestTemplate restTemplate;



    @Autowired

    private WorkService workService;





    /***

     * 通知ESS输送线流动

     * 入库任务---通知ESS输送线流动

     */

    //    @Scheduled(cron = "0/3 * * * * ? ")

    @Transactional(rollbackFor = Exception.class)

    public void conveyorStart() {

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

                .eq(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id).eq(Task::getStatus, 0));

@@ -74,13 +73,16 @@
                headers.add("Content-Type", "application/json");

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

                // 请求

                ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_PUTAWAY, HttpMethod.POST, httpEntity, String.class);

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

                        taskService.update(new LambdaUpdateWrapper<Task>()

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

                                .set(Task::getTaskType, TaskStsType.WCS_CONVEYOR_START.id));

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

                    } else {

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

@@ -98,40 +100,7 @@




    /***

     * 每隔3秒，获取库中状态为『任务完成』且状态『sucess』的订单

     * 并将任务变为历史档

     */

    //    @Scheduled(cron = "0/3 * * * * ? ")

    @Transactional

    public void completeTaskSchedule() {

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

                        .eq(Task::getTaskType, 1)

                        .eq(Task::getTaskSts, TaskStsType.WCS_PUTAWAY_SUCESS)

                        .eq(Task::getExcudeStatus, "sucess"))

                .stream().sorted(Comparator.comparing(Task::getTaskSts))

                .collect(Collectors.toList());



        DefaultTransactionDefinition def = new DefaultTransactionDefinition();

        // TODO 单个执行失败后， 加入失败列表，添加失败处理字段，避免重复查询调用

//        def.setName("SomeTxName");

        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        TransactionStatus status = transactionManager.getTransaction(def);

        try {

            tasks.forEach(task -> {

                workService.completeTask(task.getId());

            });

            // execute your business logic here

            //db operation

        } catch (Exception ex) {

            transactionManager.rollback(status);

            throw ex;

        }



    }





    /***

     * 每隔10秒，刷新当前通知档列表，下发待入库订单至ESS

     * 入库任务---每隔3秒，刷新当前通知档列表，下发待入库订单至ESS

     * 查询当前任务列表，

     */

//    @Scheduled(cron = "0/3 * * * * ? ")

@@ -165,18 +134,17 @@
        });



        tasksParam.setTaskType("putaway");



        // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况

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

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

        // 设置请求参数

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

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

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

        HttpHeaders headers = new HttpHeaders();

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

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

        // 请求

        ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_PUTAWAY, HttpMethod.POST, httpEntity, String.class);

        ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);

        log.info("下发任务 返回结果：{}", exchange);

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

            throw new CoolException("下发任务失败！！");

@@ -196,10 +164,122 @@
        }

    }



    /***

     * 每隔10秒执行，刷新当前任务列表，下发任务到ESS



    /**

     * 出库任务--- 每隔3秒，获取当前出库任务列表状态为WCS_EXECUTE_OUT_TASK_DONE的任务，并通知ESS流动输送线

     * */

//    @Scheduled(cron = "0/3 * * * * ? ")

    @Transactional(rollbackFor = Exception.class)

    public void conveyorToNotify() {

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

                .eq(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id).eq(Task::getStatus, 0));

        tasks.forEach(task -> {

            try {

                ConveyorStarParam conveyorStarParam = new ConveyorStarParam();

                conveyorStarParam.setSlotCode(task.getOriginLoc())

                        .setContainerCode(task.getBarcode());

                //调用三方接口，将任务推送至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) {

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

                        taskService.update(new LambdaUpdateWrapper<Task>()

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

                                .set(Task::getTaskType, TaskStsType.WCS_EXECUTE_OUT_CONVEYOR.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, 1)

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

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

            }

        });

    }





    /**

     * 出库任务--- 每隔3秒，获取当前出库任务列表状态为GENERATE_OUT的任务，下发任务至ESS

     * //TODO  出库任务分两种：

     * //TODO 1. 正常出库后，清除任务，

     * //TODO 2. 出库后还有库存，需要添加容器回库操作

     */

    public void flowNotify() {

    //    @Scheduled(cron = "0/3 * * * * ? ")

    @Transactional(rollbackFor = Exception.class)

    public void waveToTask() {

        //获取当前任务档中，所有为待出库状态的任务档，按时间升序排列

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

                        .eq(Task::getTaskType, 101) //TODO 如何确认是101，还是103

                        .eq(Task::getTaskSts, TaskStsType.GENERATE_OUT))

                .stream().sorted(Comparator.comparing(Task::getTaskSts))

                .collect(Collectors.toList());



        // 数据组装

        PublishTasksParam tasksParam = new PublishTasksParam();

        //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）

        tasks.forEach(task -> {

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

            TaskParam param = new TaskParam();

            //设置容器编码

            param.setTaskCode(task.getTaskNo());

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

            TaskDescribe describe = new TaskDescribe();

            //设置目标库位，站点

            describe.setContainerCode(task.getBarcode())

                    .setToLocationCode(task.getTargetLoc())

                    .setToStationCode(task.getTargetSite());

            taskDescribes.add(describe);

            param.setTaskDescribe(taskDescribes);

            params.add(param);

            tasksParam.setTasks(params);

        });



        tasksParam.setTaskType("carry");

        // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况

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

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

        // 设置请求参数

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

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

        HttpHeaders headers = new HttpHeaders();

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

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

        // 请求

        ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);

        log.info("下发任务 返回结果：{}", exchange);

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

            throw new CoolException("下发任务失败！！");

        } else {

            CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());

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

                //请求成功后，统一修改所有任务档状态为入库执行中。

                tasks.forEach(task -> {

                    taskService.update(new LambdaUpdateWrapper<Task>()

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

                            .eq(Task::getBarcode, task.getBarcode()));

                });

            } else {

                // TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态

                throw new CoolException(reponse.getMsg());

            }

        }



    }

}


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

@@ -3,6 +3,7 @@
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.framework.exception.CoolException;

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

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

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

@@ -14,6 +15,7 @@
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;

@@ -23,6 +25,7 @@
import java.util.Map;

import java.util.stream.Collectors;



@Slf4j

@Service

public class WcsApiServiceImpl implements WcsApiService {



@@ -33,104 +36,141 @@
    @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

     * @return

     */

    @Override

    @Transactional

    public R containerArrivedNotify(ContainerArrivedParam arrivedParam) {

    @Transactional(rollbackFor = Exception.class)

    public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType) {

        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 {

            taskService.update(new LambdaUpdateWrapper<Task>()

                    .set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_ARRIVED.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 type = 1L;

        if (stockType.equals("outStock")) { //出库任务

            type = 101L;

        }

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

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

                .eq(Task::getTaskType, type)

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

    }

        if (!Collections.isEmpty(list)) {

            Long finalType = type;

            list.forEach(task -> {

                    TaskStsType taskStsType = null;

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

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

                            if (task.getTaskType() == TaskStsType.WCS_CONTAINER_RECEIVE.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.getTaskType() == 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.getTaskType() == 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::getTaskType, finalType)

                                .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)) { //上报取箱状态

                            if (task.getTaskType() == 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.getTaskType() == 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.getTaskType() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.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::getTaskType, finalType)

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

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



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

////                            workService.completeTask(task.getId());

//                        }

                    }



                });

        }

    }



}


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

@@ -11,12 +11,8 @@


public interface WcsApiService {



    CommonReponse publishTaskOfCarry();

    R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType);



    CommonReponse publishTaskOfCarry(List<WaitPakin> pakins);



    R containerArrivedNotify(ContainerArrivedParam arrivedParam);



    boolean receiveTaskStatus(TasksStatusCallbackParam callbackParam);

    void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType);



}


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/controller/MobileController.java

@@ -12,8 +12,10 @@
import com.zy.asrs.wms.asrs.service.MobileService;

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

import com.zy.asrs.wms.system.controller.BaseController;

import com.zy.asrs.wms.system.entity.Host;

import com.zy.asrs.wms.system.entity.User;

import com.zy.asrs.wms.system.entity.UserLogin;

import com.zy.asrs.wms.system.service.HostService;

import com.zy.asrs.wms.system.service.UserLoginService;

import com.zy.asrs.wms.system.service.UserService;

import io.jsonwebtoken.lang.Collections;

@@ -30,7 +32,6 @@


    @Value("${super.pwd}")

    private String superPwd;



    @Autowired

    private UserService userService;

    @Autowired

@@ -40,6 +41,15 @@
    @Autowired

    private MobileService mobileService;



    /**

     * 获取用户机构

     * @return

     */

    @GetMapping("/current/host")

    public R getUserHost() {

        List<Host> hosts = mobileService.getHosts();

        return R.ok(hosts);

    }



    /**

     * 入库单据--扫码获取订单明细列表


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/controller/OrderController.java

@@ -94,7 +94,7 @@


    @PreAuthorize("hasAuthority('asrs:order:list')")

    @PostMapping("/order/out/page")

    @CacheData(tableName = {"man_order", "man_order_type"})

//    @CacheData(tableName = {"man_order", "man_order_type"})

    public R pageOut(@RequestBody Map<String, Object> map) {

        String condition = map.getOrDefault("condition", "").toString();

        BaseParam baseParam = buildParam(map, BaseParam.class);


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/entity/enums/TaskStsType.java

@@ -3,14 +3,14 @@
public enum TaskStsType {



    GENERATE_IN(1L, "生成入库任务"),

    WCS_EXECUTE_IN(2L, "WCS执行中"),

    WCS_CONTAINER_RECEIVE(3L, "WCS容器到达扫描区"),

    WCS_EXECUTE_IN(2L, "入库执行中"),

    WCS_CONTAINER_RECEIVE(3L, "容器到达扫描区"),



    WCS_CONVEYOR_START(14L, "通知容器流动"),



    WCS_TOTE_LOAD(4L, "WCS机器人取箱"),

    WCS_TOTE_LOAD(4L, "机器人取箱"),



    WCS_TOTE_UNLOAD(5L, "WCS机器人放箱"),

    WCS_TOTE_UNLOAD(5L, "机器人放箱"),



    WCS_PUTAWAY_SUCESS(10L, "任务成功"),



@@ -24,7 +24,19 @@
    UPDATED_IN(100L, "库存更新完成"),



    GENERATE_OUT(101L, "生成出库任务"),

    WCS_EXECUTE_OUT(102L, "WCS执行中"),



    WCS_EXECUTE_OUT(102L, "出库执行中"),



    WCS_EXECUTE_OUT_TOTE_LOAD(113L, "机器人取箱"),



    WCS_EXECUTE_OUT_TOTE_UNLOAD(114L, "机器人放箱"),



    WCS_EXECUTE_OUT_TASK_DONE(115L, "任务状态回调完成"),



    WCS_EXECUTE_OUT_ARRIVED(116L, "容器到达扫码区"),



    WCS_EXECUTE_OUT_CONVEYOR(117L, "通知容器流动"),



    WAVE_SEED(198L, "播种中"),

    COMPLETE_OUT(199L, "出库完成"),

    UPDATED_OUT(200L, "库存更新完成"),


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/manage/OutManage.java

@@ -778,7 +778,7 @@


    }



    @Transactional

    @Transactional(rollbackFor = Exception.class)

    public void orderOutMergeWave(OrderOutMergeParamDto dto) {

        if(dto == null){

            throw new CoolException("参数不能为空");

@@ -929,8 +929,10 @@
                    }

                }



                //TODO 确认后，需将注释打开

                String matUniqueKey = Utils.getMatUniqueKey(taskDetl.getMatnr(), taskDetl.getBatch(), taskDetl.getUniqueField());

                WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));

//                WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getStockIndex, matUniqueKey).eq(WaveDetl::getWaveId, waveId));

                WaveDetl waveDetl = waveDetlService.getOne(new LambdaQueryWrapper<WaveDetl>().eq(WaveDetl::getWaveId, waveId));

                if (waveDetl == null) {

                    throw new CoolException("波次数据不存在");

                }

@@ -939,7 +941,6 @@
                if (!waveDetlService.updateById(waveDetl)) {

                    throw new CoolException("波次数据更新失败");

                }



            }



            //库位F => R


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/MobileService.java

@@ -1,10 +1,14 @@
package com.zy.asrs.wms.asrs.service;



import com.zy.asrs.wms.asrs.entity.param.BatchMergeOrdersParam;

import com.zy.asrs.wms.system.entity.Host;



import java.util.List;





public interface MobileService {



    boolean batchMergeOrders(BatchMergeOrdersParam ordersParam);



    List<Host> getHosts();

}


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/impl/MobileServiceImpl.java

@@ -8,20 +8,24 @@
import com.zy.asrs.wms.asrs.service.MobileService;

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

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

import com.zy.asrs.wms.system.entity.Host;

import com.zy.asrs.wms.system.service.HostService;

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.List;



@Service

public class MobileServiceImpl implements MobileService {



    @Autowired

    private WaitPakinService waitPakinService;



    @Autowired

    private WorkService workService;

    @Autowired

    private HostService hostService;



    @Override

    @Transactional

@@ -51,4 +55,9 @@
        }

        return false;

    }



    @Override

    public List<Host> getHosts() {

        return hostService.list();

    }

}


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/service/impl/WorkServiceImpl.java

@@ -430,7 +430,7 @@
            task.setTaskSts(TaskStsType.COMPLETE_IN.id);//99.入库完成

        }else {

            //出库

            TaskDetl taskDetl = taskDetls.get(0);

            TaskDetl taskDetl = taskDetls.get(0); //TODO  出库流程待确认，ESS取货后，输送线流转到扫码处状态

            if (taskDetl.getWaveId() == null) {

                task.setTaskSts(TaskStsType.COMPLETE_OUT.id);//199.出库完成

            }else {


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/timer/TaskLogTimer.java

@@ -44,7 +44,7 @@
    @Autowired

    private WaveService waveService;



//    @Scheduled(cron = "0/3 * * * * ? ")

    @Scheduled(cron = "0/30 * * * * ? ")

    @Transactional

    public void inExecute() {

        InterceptorIgnoreHelper.handle(IgnoreStrategy.builder().tenantLine(true).build());


 zy-asrs-wms/src/main/java/com/zy/asrs/wms/asrs/timer/TaskTimer.java

@@ -8,6 +8,7 @@
import com.zy.asrs.wms.asrs.entity.enums.LocStsType;

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

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

import lombok.extern.slf4j.Slf4j;

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

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

@@ -17,6 +18,7 @@
import java.util.Date;

import java.util.List;



@Slf4j

@Component

public class TaskTimer {



@@ -57,7 +59,7 @@
    private OrderDetlService orderDetlService;





//    @Scheduled(cron = "0/3 * * * * ? ")

    @Scheduled(cron = "0/30 * * * * ? ")

    @Transactional

    public void inExecute() {

        InterceptorIgnoreHelper.handle(IgnoreStrategy.builder().tenantLine(true).build());

@@ -141,6 +143,7 @@


        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocNo, task.getTargetLoc()).eq(Loc::getHostId, hostId));

        if (loc == null) {

            log.info("库位不存在" + "=======>" + task.getTargetLoc());

            throw new CoolException("库位不存在");

        }




 zy-asrs-wms/src/main/resources/mapper/asrs/ViewLocDetlMapper.xml

@@ -6,12 +6,12 @@
        select * from view_man_loc_detl ld

        where matnr = #{matnr}

        and freeze = 0

        <if test="batch!=null">

        <if test="batch != null and batch != ''">

            and batch = #{batch}

        </if>

        <if test="param!=null and param.size()>0">

            <foreach item="item" collection="param" index="index">

                <if test="item.value!=null">

                <if test="item.value!=null and item.value != ''">

                    and ${item.name} = #{item.value}

                </if>

            </foreach>