add

lms/nladmin-system/nlsso-server/src/main/java/org/nl/wms/sch/task_manage/task/tasks/DGRKTask.java

@@ -0,0 +1,431 @@
+package org.nl.wms.sch.task_manage.task.tasks;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.http.HttpRequest;
+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 lombok.extern.slf4j.Slf4j;
+import org.nl.common.exception.BadRequestException;
+import org.nl.system.service.param.ISysParamService;
+import org.nl.wms.ext.service.dto.to.BaseResponse;
+import org.nl.wms.mes.domain.Head;
+import org.nl.wms.mes.domain.QPMES062Request;
+import org.nl.wms.mes.domain.QPMES062RequestBody;
+import org.nl.wms.sch.data.service.dao.mapper.MaterialDataMapper;
+import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
+import org.nl.wms.sch.material.service.dao.MesInMaterial;
+import org.nl.wms.sch.material.service.dao.mapper.MesInMaterialMapper;
+import org.nl.wms.sch.point.service.ISchBasePointService;
+import org.nl.wms.sch.point.service.dao.SchBasePoint;
+import org.nl.wms.sch.point.service.dto.PointLeftDto;
+import org.nl.wms.sch.task.service.ISchBaseTaskService;
+import org.nl.wms.sch.task.service.ISchBaseTaskconfigService;
+import org.nl.wms.sch.task.service.dao.SchBaseTask;
+import org.nl.wms.sch.task.service.dao.SchBaseTaskconfig;
+import org.nl.wms.sch.task_manage.AbstractTask;
+import org.nl.wms.sch.task_manage.enums.PointTypeEnum;
+import org.nl.wms.sch.task_manage.task.TaskType;
+import org.nl.wms.sch.task_manage.task.core.TaskStatus;
+import org.nl.wms.sch.task_manage.task.tasks.mapper.PointMapper;
+import org.nl.wms.util.PointUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author: zds
+ * @Description: 东阁楼入库区任务配置
+ * @Date: 2024/1/24
+ */
+@Slf4j
+@Component
+@TaskType("DGRKTask")
+@Lazy
+public class DGRKTask extends AbstractTask {
+    private static String TASK_CONFIG_CODE = "DGRKTask";
+    /**
+     * 入口
+     */
+    private static String ENTRANCE = "1";
+    @Autowired
+    private ISchBasePointService pointService;
+    @Autowired
+    private ISchBaseTaskService taskService;
+    @Autowired
+    private ISchBaseTaskconfigService taskConfigService;
+    @Autowired
+    private PointMapper pointMapper;
+    @Autowired
+    private MesInMaterialMapper materialMapper;
+
+    @Override
+    protected void create() throws BadRequestException {
+        // 获取任务
+        List<SchBaseTask> tasks = taskService.findTasksByTaskStatus(TASK_CONFIG_CODE, TaskStatus.APPLY);
+        // 配置信息
+        SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
+                .eq(SchBaseTaskconfig::getConfig_code, TASK_CONFIG_CODE));
+        // 获取任务配置最大下发任务数
+        Integer tcmn = taskConfig.getTask_issue_max_num();
+        // 获取执行中的任务
+        List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findCreateTasksByTaskConfig(TASK_CONFIG_CODE);
+        //执行中任务数量小于最大可生成任务数
+        if(unFinishTasksByTaskConfig.size() < tcmn){
+            Integer now_num = unFinishTasksByTaskConfig.size();
+            for (SchBaseTask task : tasks) {
+                if(now_num < tcmn){
+                    //若终点不为空，说明是4、5层的中转任务
+                    String point_code2 = task.getPoint_code2();
+                    //若不是4、5层的第二条任务
+                    if(ObjectUtil.isEmpty(point_code2)){
+                        // 获取参数
+                        JSONObject extGroupData = ObjectUtil.isNotEmpty(task.getExt_group_data())
+                                ? JSONObject.parseObject(task.getExt_group_data())
+                                : null;
+                        SchBasePoint point = findNextPoint(extGroupData.getString("sub_tray"),extGroupData.getDouble("height"));
+                        if (ObjectUtil.isEmpty(point)) {
+                            task.setRemark("未找到所需点位!");
+                            taskService.update(task);
+                            // 消息通知
+                            log.info("入库未找到当前符合条件的点位！");
+                            continue;
+                        }else{
+                            // 获取任务
+                            Integer taskList = taskService.findUnFinishTasksByPoint_code2(task.getTask_code(),point.getPoint_code());
+                            if(taskList>0){
+                                task.setRemark("分配终点点位"+point.getPoint_code()+"已存在未完成任务!");
+                                taskService.update(task);
+                                // 消息通知
+                                log.info("分配终点点位"+point.getPoint_code()+"已存在未完成任务!");
+                                continue;
+                            }
+                        }
+                        //层号
+                        Integer layer_num = point.getLayer_num();
+                        SchBasePoint point2 = null;
+                        if(layer_num > 3){
+                            //查找2层中转点
+                            point2 = pointMapper.findPointByCondition2Desc(point.getRegion_code(),point.getRow_num(),PointTypeEnum.TRANSFER_POINT.getCode());
+                            if (ObjectUtil.isEmpty(point2)) {
+                                task.setRemark("未找到所需中转点位!");
+                                taskService.update(task);
+                                // 消息通知
+                                log.info("入库未找到当前符合条件的中转点位！");
+                                continue;
+                            }
+                        }
+                        //复制对象
+                        SchBaseTask acs_task = BeanUtil.copyProperties(task,SchBaseTask.class);
+                        if(layer_num > 3){
+                            //设置中转点
+                            acs_task.setPoint_code2(point2.getPoint_code());
+                            //设置货位终点
+                            acs_task.setPoint_code3(point.getPoint_code());
+                        }else{
+                            //设置货位终点
+                            acs_task.setPoint_code2(point.getPoint_code());
+                        }
+                        acs_task.setVehicle_code(extGroupData.getString("mother_tray"));
+                        acs_task.setVehicle_code2(extGroupData.getString("sub_tray"));
+                        //下发
+                        JSONObject result = this.renotifyAcs(acs_task);
+                        String status = result.getString("status");
+                        //下发成功
+                        if("200".equals(status)){
+                            // 设置终点并修改创建成功状态
+                            task.setTask_status(TaskStatus.CREATED.getCode());
+                            task.setRemark("下发");
+                            if(layer_num > 3){
+                                //设置中转点
+                                task.setPoint_code2(point2.getPoint_code());
+                                //设置货位终点
+                                task.setPoint_code3(point.getPoint_code());
+                            }else{
+                                //设置货位终点
+                                task.setPoint_code2(point.getPoint_code());
+                            }
+                            task.setVehicle_code(extGroupData.getString("mother_tray"));
+                            task.setVehicle_code2(extGroupData.getString("sub_tray"));
+                            taskService.update(task);
+
+                            //发起任务时先把点位占用，防止发起重复任务
+                            point.setIng_task_code(task.getTask_code());
+                            pointService.update(point);
+                            if(layer_num > 3){
+                                point2.setIng_task_code(task.getTask_code());
+                                pointService.update(point2);
+                            }
+                            now_num++;
+                        }else{
+                            task.setRemark("下发acs失败:"+result.toString());
+                            taskService.update(task);
+                        }
+                    }
+                    else{//若是4、5层的中转任务
+                        //查询4、5层点位信息
+                        SchBasePoint point =  pointService.getById(point_code2);
+                        if (ObjectUtil.isEmpty(point)) {
+                            task.setRemark("目标点位信息异常，查询失败!");
+                            taskService.update(task);
+                            // 消息通知
+                            log.info("入库未找到当前符合条件的点位！");
+                            continue;
+                        }else{
+                            // 获取任务
+                            Integer taskList = taskService.findUnFinishTasksByPoint_code2(task.getTask_code(),point.getPoint_code());
+                            if(taskList>0){
+                                task.setRemark("分配终点点位"+point.getPoint_code()+"已存在未完成任务!");
+                                taskService.update(task);
+                                // 消息通知
+                                log.info("分配终点点位"+point.getPoint_code()+"已存在未完成任务!");
+                                continue;
+                            }
+                        }
+                        //下发
+                        JSONObject result = this.renotifyAcs(task);
+                        String status = result.getString("status");
+                        //下发成功
+                        if("200".equals(status)){
+                            // 设置终点并修改创建成功状态
+                            task.setTask_status(TaskStatus.CREATED.getCode());
+                            task.setRemark("下发");
+                            taskService.update(task);
+
+                            //发起任务时先把点位占用，防止发起重复任务
+                            point.setIng_task_code(task.getTask_code());
+                            pointService.update(point);
+                            now_num++;
+                        }else{
+                            task.setRemark("下发acs失败:"+result.toString());
+                            taskService.update(task);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 判断目标点位
+     *
+     * @return
+     */
+    private SchBasePoint findNextPoint(String sub_tray,Double height) {
+        //1、优先从中间库存区查找
+        String regionCode = "ZJK";
+        SchBasePoint point = getSchBasePointByYL(regionCode,height);
+        if (ObjectUtil.isNotEmpty(point)){
+            return point;
+        }else {//2、中间存区未找到，则去东西阁楼库区
+            regionCode="DGK";
+            point = getSchBasePointByYL(regionCode,height);
+            if (ObjectUtil.isNotEmpty(point)){
+                return point;
+            }else {//2、中间存区未找到，则去东西阁楼库区
+                regionCode="XGK";
+                return  getSchBasePointByYL(regionCode,height);
+            }
+        }
+    }
+
+    /**
+     * 根据区域编码和货物高度查找合适的点位
+     * 规则：根据启用的原料区的排号顺序分配
+     * @param regionCode
+     * @return
+     */
+    private SchBasePoint getSchBasePointByYL(String regionCode,Double height) {
+        List<PointLeftDto> rowList = new ArrayList<PointLeftDto>();
+        //根据库区和高度，查询有空位，且按 当前已入库载具数量、排号升序
+        if(height == 1.2){
+            rowList = pointMapper.findPointRowByCondition(regionCode,0,1.2);
+            if(rowList.size() == 0){
+                rowList = pointMapper.findPointRowByCondition(regionCode,0,1.8);
+                if(rowList.size() == 0){
+                    rowList = pointMapper.findPointRowByCondition(regionCode,0,2.0);
+                }
+            }
+        }else if(height == 1.8){
+            rowList = pointMapper.findPointRowByCondition(regionCode,0,1.8);
+            if(rowList.size() == 0){
+                rowList = pointMapper.findPointRowByCondition(regionCode,0,2.0);
+            }
+        }else if(height == 2.0){
+            rowList = pointMapper.findPointRowByCondition(regionCode,0,2.0);
+        }
+        //若存在满足条件的排号
+        if(rowList.size() > 0){
+            Integer row = rowList.get(0).getRow_num();
+            //分配入库点位，按层数又低到高、列号由小到大
+            SchBasePoint point = pointMapper.findPointByCondition2Desc(regionCode,row, PointTypeEnum.STORAGE_POINT.getCode());
+            if(ObjectUtil.isNotEmpty(point)){
+                return point;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected void updateStatus(String task_code, TaskStatus status) {
+        // 校验任务
+        SchBaseTask taskObj = taskService.getById(task_code);
+        if (taskObj.getTask_status().equals(TaskStatus.FINISHED.getCode())) {
+            throw new BadRequestException("该任务已完成!");
+        }
+        if (taskObj.getTask_status().equals(TaskStatus.CANCELED.getCode())) {
+            throw new BadRequestException("该任务已取消!");
+        }
+        // 获取参数
+        JSONObject extGroupData = ObjectUtil.isNotEmpty(taskObj.getExt_group_data())
+                ? JSONObject.parseObject(taskObj.getExt_group_data())
+                : null;
+        String startPoint = taskObj.getPoint_code1(); // 获取起点
+        String endPoint = taskObj.getPoint_code2(); // 获取终点
+        String point_code3 = taskObj.getPoint_code3(); // 获取终点
+        SchBasePoint startPointObj = pointService.getById(startPoint);
+        SchBasePoint endPointObj = pointService.getById(endPoint);
+        SchBasePoint pointObj3 = null;
+        if(ObjectUtil.isNotEmpty(point_code3)){
+            pointObj3 = pointService.getById(point_code3);
+        }
+        // 根据传来的类型去对任务进行操作
+        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
+            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
+            taskObj.setRemark("执行中");
+            taskService.update(taskObj);
+        }
+       else if (status.equals(TaskStatus.FINISHED)) { // 完成
+            // 起点清空
+            if (ObjectUtil.isNotEmpty(startPointObj)) {
+                PointUtils.clearPoint(startPointObj);
+            }
+            //更新终点
+            endPointObj.setUpdate_time(DateUtil.now());
+            endPointObj.setVehicle_code(taskObj.getVehicle_code());
+            endPointObj.setVehicle_code2(taskObj.getVehicle_code2());
+            endPointObj.setVehicle_qty(1);
+            endPointObj.setInstorage_time(DateUtil.now());
+            if (ObjectUtil.isNotEmpty(pointObj3)) {
+                //复制对象
+                SchBaseTask acs_task = BeanUtil.copyProperties(taskObj,SchBaseTask.class);
+                //设置任务状态为 申请状态(当前任务参数不全，不具备下发条件)
+                acs_task.setTask_status(TaskStatus.APPLY.getCode());
+                acs_task.setPoint_code1(taskObj.getPoint_code2());
+                acs_task.setPoint_code2(taskObj.getPoint_code3());
+                acs_task.setPoint_code3("");
+                acs_task.setTask_group_seq(2);
+                //创建中转指令
+                String task_code_new =taskService.create(acs_task);
+                //更新终点任务号
+                endPointObj.setIng_task_code(task_code_new);
+                pointObj3.setIng_task_code(task_code_new);
+                pointService.update(pointObj3);
+            }else{
+                // 终点解锁
+                endPointObj.setIng_task_code("");
+            }
+            pointService.update(endPointObj);
+
+            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
+            taskObj.setRemark("任务完成");
+            taskService.update(taskObj);
+            //如果是两点任务，回传mes
+            if(ObjectUtil.isEmpty(pointObj3)){
+                LambdaQueryWrapper<MesInMaterial> wrapper = new LambdaQueryWrapper<>();
+                wrapper.eq(MesInMaterial::getPallet_sn,taskObj.getVehicle_code2());
+                //回传状态为0的
+                wrapper.eq(MesInMaterial::getReturn_status,"0");
+                List<MesInMaterial> materialList= materialMapper.selectList(wrapper);
+
+                try {
+                    //输送线到原材料库的任务完成，反馈MES接口。逻辑可以去掉。
+                    if(ObjectUtil.isNotEmpty(materialList)) {
+                        String url = "http://192.168.9.124/sitAppWebApi/PDSToWMS/Api/QPMES062";
+                        QPMES062Request qpmes062Request = new QPMES062Request();
+                        Head head=new Head();
+                        head.setDest_system("WMS");
+                        head.setIntf_id("QPMES062");
+                        head.setSrc_msgid(IdUtil.simpleUUID());
+                        head.setSrc_system("LMS");
+                        qpmes062Request.setHead(head);
+                        List<QPMES062RequestBody> qpmes062RequestBodyList=new ArrayList<>();
+                        for(MesInMaterial material:materialList) {
+                            QPMES062RequestBody qpmes062RequestBody = new QPMES062RequestBody();
+                            qpmes062RequestBody.setOrder_code(material.getOrder_code());
+                            qpmes062RequestBody.setBatch(material.getBatch());
+                            qpmes062RequestBody.setPallet_sn(material.getPallet_sn());
+                            qpmes062RequestBody.setProduct_description(material.getProduct_description());
+                            qpmes062RequestBody.setProduct_name(material.getProduct_name());
+                            qpmes062RequestBody.setQty(material.getQty());
+                            qpmes062RequestBody.setSpecification(material.getSpecification());
+                            //设置外部系统仓位标识
+                            qpmes062RequestBody.setStrcut_code(endPointObj.getExt_point_code());
+                            qpmes062RequestBodyList.add(qpmes062RequestBody);
+                        }
+                        qpmes062Request.setBody(qpmes062RequestBodyList);
+                        log.info("开始调用QPMES062服务，入参{}", JSON.toJSONString(qpmes062Request));
+                       String resultMsg = HttpRequest.post(url)
+                                .body(JSON.toJSONString(qpmes062Request))
+                                .execute().body();
+                        log.info("QPMES062服务调用成功，反馈{}",resultMsg);
+                        JSONObject result = JSONObject.parseObject(resultMsg);
+                        String code = result.getString("code");
+                        if("0".equals(code)){
+                            //更新接口表
+                            LambdaUpdateWrapper<MesInMaterial> updateWrapper = new LambdaUpdateWrapper<>();
+                            updateWrapper.eq(MesInMaterial::getPallet_sn,taskObj.getVehicle_code2());
+                            //回传状态为0的
+                            updateWrapper.eq(MesInMaterial::getReturn_status,"0");
+                            updateWrapper.set(MesInMaterial::getReturn_status,"1");
+                            materialMapper.update(null,updateWrapper);
+                        }
+                    }else{
+                        log.error("当前子托盘:"+taskObj.getVehicle_code2()+"不存在需要回传的物料信息，请确认！");
+                    }
+                }catch (Exception e){
+                    log.error("入库上报MES失败{}",e.getMessage(),e);
+                }
+            }
+        }
+       else if (status.equals(TaskStatus.CANCELED)) { // 取消
+            // 终点解锁
+            if (ObjectUtil.isNotEmpty(endPointObj)) {
+                endPointObj.setIng_task_code("");
+                //任务取消把原先占用的位置释放
+                pointService.update(endPointObj);
+            }
+            if (ObjectUtil.isNotEmpty(pointObj3)) {
+                pointObj3.setIng_task_code("");
+                //任务取消把原先占用的位置释放
+                pointService.update(pointObj3);
+            }
+            taskObj.setRemark("任务取消");
+            taskObj.setTask_status(TaskStatus.CANCELED.getCode());
+            taskService.update(taskObj);
+        }
+
+    }
+
+    @Override
+    public void forceFinish(String task_code) {
+        this.updateStatus(task_code, TaskStatus.FINISHED);
+    }
+
+    @Override
+    public void cancel(String task_code) {
+        this.updateStatus(task_code, TaskStatus.CANCELED);
+    }
+
+    @Override
+    protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
+        //该场景无需重算等待点
+    }
+}