blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
skyouc
2024-12-23 2cf6f25ee51dea59dbd1e2183a06796961bb8644 
 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());



            }



        }







    }



}