基础task修改

acs/nladmin-system/nlsso-server/src/main/resources/config/application-dev.yml

@@ -7,7 +7,7 @@ spring:
       db-type: com.alibaba.druid.pool.DruidDataSource
       driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
 #      url: jdbc:log4jdbc:mysql://${DB_HOST:192.168.81.252}:${DB_PORT:3306}/${DB_NAME:stand_acs}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
-      url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:cw_acs}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
+      url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:gc_acs}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
       username: ${DB_USER:root}
 #      password: ${DB_PWD:Root.123456}
       password: ${DB_PWD:123456}

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

@@ -99,7 +99,7 @@ public abstract class AbstractTask {
         SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
                 .eq(SchBaseTaskconfig::getConfig_code, config_code));
         taskDto.setPriority(taskConfig.getPriority());
-//        taskDto.setTask_type(taskConfig.getTask_type());
+        taskDto.setTask_type(taskConfig.getTask_type());
         taskDto.setRoute_plan_code(taskConfig.getRoute_plan_code());
         return taskDto;
     }

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

@@ -1,232 +0,0 @@
-package org.nl.wms.sch.task_manage.task.tasks;
-
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import lombok.extern.slf4j.Slf4j;
-import org.nl.common.exception.BadRequestException;
-import org.nl.config.MapOf;
-import org.nl.wms.ext.service.WmsToAcsService;
-import org.nl.wms.ext.service.dto.to.BaseResponse;
-import org.nl.wms.pdm.service.IPdmBdWorkorderService;
-import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
-import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
-import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
-import org.nl.wms.sch.point.service.ISchBasePointService;
-import org.nl.wms.sch.point.service.dao.SchBasePoint;
-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.GroupBindMaterialStatusEnum;
-import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
-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.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author: psh
- * @Description: 空固化架入库
- * @Date: 2023/9/28
- */
-@Slf4j
-@Component
-@TaskType("KGHJRKTask")
-@Lazy
-public class KGHJRKTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "KGHJRKTask";
-    /**
-     * 入口
-     */
-    private static String ENTRANCE = "1";
-    @Autowired
-    private ISchBasePointService pointService;
-    @Autowired
-    private ISchBaseTaskService taskService;
-    @Autowired
-    private ISchBaseTaskconfigService taskConfigService;
-    @Autowired
-    private IPdmBdWorkorderService workorderService;
-    @Autowired
-    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
-    @Autowired
-    private PointMapper pointMapper;
-    @Autowired
-    private WmsToAcsService wmsToAcsService;
-
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    protected void create() throws BadRequestException {
-        // 获取任务
-        List<SchBaseTask> tasks = taskService.findTasksByTaskStatus(TASK_CONFIG_CODE, TaskStatus.APPLY);
-
-        for (SchBaseTask task : tasks) {
-            // 找终点
-            SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                    .eq(SchBasePoint::getPoint_code, task.getPoint_code1()));
-            SchBasePoint point = findNextPoint(startPoint,task.getVehicle_type());
-            if (ObjectUtil.isEmpty(point)) {
-                task.setRemark("未找到所需点位!");
-                taskService.update(task);
-                // 消息通知
-                log.info("空固化架入库未找到当前符合条件的点位");
-                continue;
-            }
-            // 设置终点并修改创建成功状态
-            if("1".equals(task.getVehicle_type())){
-                task.setTask_type("11");
-            }else{
-                task.setTask_type("12");
-            }
-            task.setPoint_code2(point.getNext_wait_point());
-            task.setTask_status(TaskStatus.CREATED.getCode());
-            task.setRemark("");
-            taskService.update(task);
-
-//            //发起任务时先把点位占用，防止发起重复任务
-//            point.setIng_task_code(task.getTask_code());
-//            pointService.update(point);
-
-            //下发
-            this.renotifyAcs(task);
-        }
-    }
-
-    /**
-     * 判断目标点位
-     * 1.A区的去A区缓存点,B区的去B区
-     * 2.倒叙查找，找到满足当前位置数量不足3的即可
-     */
-    private SchBasePoint findNextPoint(SchBasePoint startPoint,String vehicleType) {
-        String regionCode = null;
-        if ("A1".equals(startPoint.getWorkshop_code())) {
-            //A1空架到HCQ1
-            regionCode = "HCQ1";
-            if("1".equals(vehicleType)){
-                regionCode="ZJBKGHJDJW";
-            }
-
-        } else if ("A2".equals(startPoint.getWorkshop_code())) {
-            //A1空架到KGHJ2
-            regionCode = "KGHJ2";
-        }
-        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode,"1");
-        //从前往后判断，直到发现点位有货，取前一个
-        SchBasePoint schBasePoint=null;
-        if(!"ZJBKGHJDJW".equals(regionCode)) {
-            for (int i = schBasePointList.size() - 1; i >= 0; i--) {
-                SchBasePoint temp = schBasePointList.get(i);
-                if (temp.getVehicle_qty() == 1 &&
-                        ObjectUtil.isEmpty(temp.getIng_task_code())) {
-                    if (schBasePoint != null) {
-                        log.info("空固化架放货找到当前点位有货：{}，取上一个空位：{}", temp.getPoint_code(), schBasePoint.getPoint_code());
-                    } else {
-                        log.info("当前区域："+regionCode+"所有点位均已放满，暂时跳过");
-                    }
-                    break;
-                }
-                schBasePoint = temp;
-            }
-        }else{
-            for (int i = schBasePointList.size() - 1; i >= 0; i--) {
-                SchBasePoint temp = schBasePointList.get(i);
-                if (temp.getVehicle_qty() <3  &&
-                        ObjectUtil.isEmpty(temp.getIng_task_code())) {
-                    schBasePoint = temp;
-                }
-            }
-            if (schBasePoint==null){
-                log.info("当前区域："+regionCode+"所有点位均已放满，暂时跳过");
-            }
-        }
-        return schBasePoint;
-    }
-
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    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("该任务已取消!");
-        }
-
-        String startPoint = taskObj.getPoint_code1(); // 获取起点
-        String endPoint = taskObj.getPoint_code2(); // 获取终点
-        SchBasePoint startPointObj = pointService.getById(startPoint);
-        SchBasePoint endPointObj = pointService.getById(endPoint);
-        // 根据传来的类型去对任务进行操作
-        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
-            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
-            taskObj.setRemark("执行中");
-        }
-        if (status.equals(TaskStatus.FINISHED)) { // 完成
-            // 终点解锁,库存增加
-            startPointObj.setIng_task_code("");
-            //正极板对接位通过plc信号同步，任务完成不增加
-            if(!"ZJBKGHJDJW".equals(startPointObj.getRegion_code())) {
-                startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() + 1);
-            }
-            pointService.update(endPointObj);
-
-            // 任务完成
-            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
-            taskObj.setRemark("任务完成");
-        }
-        if (status.equals(TaskStatus.CANCELED)) { // 取消
-            // 终点解锁
-            if (ObjectUtil.isNotEmpty(endPointObj)) {
-                endPointObj.setIng_task_code("");
-                pointService.update(endPointObj);
-            }
-            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) {
-        //重新计算固化室放货点位
-        JSONObject extGroupData = JSONObject.parseObject(schBaseTask.getExt_group_data());
-        SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                .eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code1()));
-        SchBasePoint point = findNextPoint(startPoint, schBaseTask.getVehicle_type());
-        if("ZJBKGHJDJW".equals(point.getRegion_code())) {
-            schBaseTask.setPoint_code2(point.getPoint_code() + "0" + (point.getVehicle_qty() + 1));
-        }else{
-            schBaseTask.setPoint_code2(point.getPoint_code().replace("HCQ","QHQ"));
-        if(ObjectUtil.isNotEmpty(point.getIng_task_code())&&!schBaseTask.getTask_code().equals(point.getIng_task_code())){
-            throw new BadRequestException("当前空架点位有任务，暂不反馈！");
-        }
-        //重算点位时把点位占用
-        point.setIng_task_code(schBaseTask.getTask_code());
-        pointService.update(point);
-    }
-    }
-}

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

@@ -0,0 +1,253 @@
+package org.nl.wms.sch.task_manage.task.tasks;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.extern.slf4j.Slf4j;
+import org.nl.common.exception.BadRequestException;
+import org.nl.wms.ext.service.WmsToAcsService;
+import org.nl.wms.ext.service.dto.to.BaseResponse;
+import org.nl.wms.pdm.service.IPdmBdWorkorderService;
+import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
+import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
+import org.nl.wms.sch.point.service.ISchBasePointService;
+import org.nl.wms.sch.point.service.dao.SchBasePoint;
+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.GeneralDefinition;
+import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
+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.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @Author: psh
+ * @Description: 点对点任务
+ * @Date: 2023/1/24
+ */
+@Slf4j
+@Component
+@TaskType("POINTTask")
+@Lazy
+public class POINTTask extends AbstractTask {
+    private static String TASK_CONFIG_CODE = "POINTTask";
+    /**
+     * 入口
+     */
+    private static String ENTRANCE = "1";
+    @Autowired
+    private ISchBasePointService pointService;
+    @Autowired
+    private ISchBaseTaskService taskService;
+    @Autowired
+    private ISchBaseTaskconfigService taskConfigService;
+    @Autowired
+    private IPdmBdWorkorderService workorderService;
+    @Autowired
+    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
+    @Autowired
+    private PointMapper pointMapper;
+    @Autowired
+    private WmsToAcsService wmsToAcsService;
+
+    @Override
+//    @Transactional(rollbackFor = Exception.class)
+    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));
+        for (SchBaseTask task : tasks) {
+            String extGroupData = task.getExt_group_data();
+            JSONObject jsonObject = JSONObject.parseObject(extGroupData);
+            String materialType = jsonObject.getString("material_type");
+            SchBasePoint point = findNextPoint(jsonObject,task);
+            if (ObjectUtil.isEmpty(point)) {
+                task.setRemark("未找到所需点位!");
+                taskService.update(task);
+                // 消息通知
+                log.info("包片上料未找到当前符合条件的点位materialType:{},",materialType);
+                continue;
+            }
+            // 设置起点并修改创建成功状态
+            // 取料先去等待点
+            task.setTask_type("3");
+            task.setPoint_code1(point.getNext_wait_point());
+            task.setTask_status(TaskStatus.CREATED.getCode());
+            task.setRemark("");
+            taskService.update(task);
+
+            //发起任务时先把点位占用，防止发起重复任务
+//            point.setIng_task_code(task.getTask_code());
+//            point.setVehicle_qty(point.getVehicle_qty() - 1);
+//            point.setVehicle_type(materialType);
+//            pointService.update(point);
+
+            //下发
+            this.renotifyAcs(task);
+        }
+    }
+
+    /**
+     * 判断目标点位
+     * 从10-1查找可以物料一致且有货的点位
+     *
+     * @param extGroupData
+     * @return
+     */
+    private SchBasePoint findNextPoint(JSONObject extGroupData,SchBaseTask task) {
+        String regionCode = "";
+        String materialType = extGroupData.getString("material_type");
+        if("1".equals(materialType)){
+            regionCode="ZJBDJW";
+        }else if("2".equals(materialType)){
+            regionCode="HCQ2";
+        }else if ("3".equals(materialType)){
+            regionCode="HCQ3";
+        }
+        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode,"1");
+        for(int i=schBasePointList.size()-1;i>=0;i--){
+            SchBasePoint schBasePoint=schBasePointList.get(i);
+            //已锁定直接返回
+            if(task.getTask_code().equals(schBasePoint.getIng_task_code())){
+                return schBasePoint;
+            }
+            if (!"2".equals(schBasePoint.getPoint_type())&&schBasePoint.getVehicle_qty()!=0
+                    &&ObjectUtil.isEmpty(schBasePoint.getIng_task_code())
+                    &&(ObjectUtil.isEmpty(schBasePoint.getVehicle_type())||materialType.equals(schBasePoint.getVehicle_type()))){
+                log.info("包片上料任务找到当前符合条件的缓存区位置{}",schBasePoint.getPoint_code());
+                return schBasePoint;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 1.取货完毕后起点减少最后一份组盘，并且该组盘视为已结束
+     * 2.包片机LMS不记录点位信息，由人工对组盘进行操作
+     */
+    @Override
+//    @Transactional(rollbackFor = Exception.class)
+    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("该任务已取消!");
+        }
+        String startPoint = taskObj.getPoint_code1(); // 获取起点
+        String endPoint = taskObj.getPoint_code2(); // 获取终点
+        SchBasePoint startPointObj = pointService.getById(startPoint);
+        SchBasePoint endPointObj = pointService.getById(endPoint);
+        // 根据传来的类型去对任务进行操作
+        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
+            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
+            taskObj.setRemark("执行中");
+        }
+        if (status.equals(TaskStatus.FINISHED)) { // 完成
+            List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
+            String vehicleCode=vehicleCodeList.get(vehicleCodeList.size()-1);
+            SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
+                    .eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
+                    .eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
+                            GroupBindMaterialStatusEnum.BOUND.getValue()));
+            if (ObjectUtil.isNotEmpty(one)) {
+//                throw new BadRequestException(vehicleCode + " => " + startPointObj.getVehicle_type() + "的组盘信息未找到");
+//            }
+                one.setTask_code(taskObj.getTask_code());
+                one.setPoint_code(endPointObj.getPoint_code()); // 当前位置
+                one.setPoint_name(endPointObj.getPoint_name());
+                one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code());
+                one.setGroup_bind_material_status(GroupBindMaterialStatusEnum.UNBOUND.getValue());
+                one.setUpdate_id(GeneralDefinition.ACS_ID);
+                one.setUpdate_name(GeneralDefinition.ACS_NAME);
+                one.setUpdate_time(DateUtil.now());
+                vehiclematerialgroupService.updateById(one);
+            }
+            // 起点清空
+            if (vehicleCodeList.size()==1) {
+                startPointObj.setVehicle_code("");
+            }else{
+                StringBuilder vehicle_code=new StringBuilder();
+                for(int i=0;i<=vehicleCodeList.size()-2;i++){
+                    vehicle_code.append(vehicleCodeList.get(i)).append(',');
+                }
+                startPointObj.setVehicle_code(vehicle_code.toString());
+            }
+            if (!startPointObj.getPoint_code().startsWith("ZJBDJW")) {
+                startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() - 1);
+            }
+            startPointObj.setIng_task_code("");
+            startPointObj.setUpdate_time(DateUtil.now());
+            pointService.updateById(startPointObj);
+            //包片上料完毕后，整排打上记号只允许包片上料
+            pointMapper.updatePointType(endPointObj.getPoint_code().substring(0,endPointObj.getPoint_code().length()-2),"1");
+            // 任务完成
+            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
+            taskObj.setGroup_id(one.getGroup_id());
+            taskObj.setRemark("任务完成");
+        }
+        if (status.equals(TaskStatus.CANCELED)) { // 取消
+            // 终点解锁
+            if (ObjectUtil.isNotEmpty(endPointObj)) {
+                endPointObj.setIng_task_code("");
+                pointService.update(endPointObj);
+            }
+            // 起点解锁
+            if (ObjectUtil.isNotEmpty(startPointObj)) {
+                startPointObj.setIng_task_code("");
+                if (startPointObj.getPoint_code().startsWith("ZJBDJW")) {
+                    startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() + 1);
+                }
+                pointService.update(endPointObj);
+            }
+            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) {
+        //重算最优点
+        JSONObject jsonObject = JSONObject.parseObject(schBaseTask.getExt_group_data());
+        SchBasePoint point = this.findNextPoint(jsonObject,schBaseTask);
+        //正极板现在不堆叠
+        if( "1".equals(jsonObject.getString("material_type"))) {
+            schBaseTask.setPoint_code1(point.getPoint_code()+"0"+(point.getVehicle_qty()));
+        }else{
+            schBaseTask.setPoint_code1(point.getPoint_code().replace("HCQ","QHQ"));
+        }
+        //重算点位时把点位占用
+            point.setIng_task_code(schBaseTask.getTask_code());
+        //如果是正极板对接位则直接减库存
+        if ((point.getPoint_code().startsWith("ZJBDJW"))) {
+            point.setVehicle_qty(point.getVehicle_qty() - 1);
+        }
+        pointService.update(point);
+    }
+}

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

@@ -1,215 +0,0 @@
-package org.nl.wms.sch.task_manage.task.tasks;
-
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import lombok.extern.slf4j.Slf4j;
-import org.nl.common.exception.BadRequestException;
-import org.nl.config.MapOf;
-import org.nl.wms.ext.service.WmsToAcsService;
-import org.nl.wms.ext.service.dto.to.BaseResponse;
-import org.nl.wms.pdm.service.IPdmBdWorkorderService;
-import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
-import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
-import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
-import org.nl.wms.sch.point.service.ISchBasePointService;
-import org.nl.wms.sch.point.service.dao.SchBasePoint;
-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.GroupBindMaterialStatusEnum;
-import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
-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.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author: psh
- * @Description: 涂板线补空架
- * @Date: 2023/9/28
- */
-@Slf4j
-@Component
-@TaskType("TBXBKJTask")
-@Lazy
-public class TBXBKJTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "TBXBKJTask";
-    /**
-     * 入口
-     */
-    private static String ENTRANCE = "1";
-    @Autowired
-    private ISchBasePointService pointService;
-    @Autowired
-    private ISchBaseTaskService taskService;
-    @Autowired
-    private ISchBaseTaskconfigService taskConfigService;
-    @Autowired
-    private IPdmBdWorkorderService workorderService;
-    @Autowired
-    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
-    @Autowired
-    private PointMapper pointMapper;
-    @Autowired
-    private WmsToAcsService wmsToAcsService;
-
-    /**
-     * 涂版线工位发起叫料请求
-     * 从对应AB区的空固化架缓存位生成搬运任务
-     * 不记录组盘，不考虑点位状态
-     */
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    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));
-        for (SchBaseTask task : tasks) {
-            // 找起点
-            SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                    .eq(SchBasePoint::getPoint_code, task.getPoint_code2()));
-            SchBasePoint point = findNextPoint(startPoint,task);
-            if (ObjectUtil.isEmpty(point)) {
-                task.setRemark("未找到所需点位!");
-                taskService.update(task);
-                // 消息通知
-                log.info("涂板线补空架未找到空架缓存点存在空架！");
-                continue;
-            }
-            // 设置终点并修改创建成功状态
-            if("TBX1".equals(startPoint.getRegion_code())) {
-                task.setTask_type("4");
-            }else{
-                task.setTask_type("7");
-            }
-            task.setPoint_code1(point.getStart_wait_point());
-            task.setTask_status(TaskStatus.CREATED.getCode());
-            task.setRemark("");
-            taskService.update(task);
-
-            //下发
-            this.renotifyAcs(task);
-        }
-    }
-
-
-    /**
-     * 从01到10顺序判断最先有货的工位
-     */
-    private SchBasePoint findNextPoint(SchBasePoint startPoint,SchBaseTask task) {
-        String regionCode = null;
-        if ("TBX1".equals(startPoint.getRegion_code())) {
-            //TBX1找A区
-            regionCode = "HCQ1";
-
-        } else if ("TBX2".equals(startPoint.getRegion_code())) {
-            //TBX2找B区
-            regionCode = "HCQ5";
-        }
-        SchBasePoint temp = null;
-        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode, "1");
-        for (SchBasePoint schBasePoint : schBasePointList) {
-            //如果当前任务已锁定则直接返回
-            if(task.getTask_code().equals(schBasePoint.getIng_task_code())){
-                return schBasePoint;
-            }
-            if (schBasePoint.getVehicle_qty() > 0 &&
-                    (ObjectUtil.isEmpty(schBasePoint.getIng_task_code()))) {
-                if (temp == null ||
-                        schBasePoint.getPoint_code().startsWith(temp.getPoint_code().substring(0, temp.getPoint_code().length() - 2))
-                &&schBasePoint.getPoint_code().compareTo(temp.getPoint_code())>0){
-                    temp=schBasePoint;
-                    log.info("涂板线补空架找到当前符合条件的点位{}", schBasePoint.getPoint_code());
-                }
-            }
-        }
-        return temp;
-    }
-
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    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("该任务已取消!");
-        }
-
-        String startPoint = taskObj.getPoint_code1(); // 获取起点
-        String endPoint = taskObj.getPoint_code2(); // 获取终点
-        SchBasePoint startPointObj = pointService.getById(startPoint);
-        SchBasePoint endPointObj = pointService.getById(endPoint);
-        // 根据传来的类型去对任务进行操作
-        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
-            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
-            taskObj.setRemark("执行中");
-        }
-        if (status.equals(TaskStatus.FINISHED)) { // 完成
-            // 起点解锁,库存减少
-            startPointObj.setIng_task_code("");
-            startPointObj.setVehicle_qty(startPointObj.getVehicle_qty() - 1);
-            pointService.update(startPointObj);
-
-            // 任务完成
-            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
-            taskObj.setRemark("任务完成");
-        }
-        if (status.equals(TaskStatus.CANCELED)) { // 取消
-            // 起点解锁
-            if (ObjectUtil.isNotEmpty(startPointObj)) {
-                startPointObj.setIng_task_code("");
-                pointService.update(endPointObj);
-            }
-            // 终点解锁
-            if (ObjectUtil.isNotEmpty(endPointObj)) {
-                endPointObj.setIng_task_code("");
-                pointService.update(endPointObj);
-            }
-            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) {
-        //todo 重算最优点
-        SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                .eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code2()));
-        SchBasePoint point = this.findNextPoint(startPoint,schBaseTask);
-        schBaseTask.setPoint_code1(point.getPoint_code());
-        //重算点位时把点位占用，防止发起重复任务
-        point.setIng_task_code(schBaseTask.getTask_code());
-//        //空固化架区别于组盘，任务完成后再扣除库存
-////            point.setVehicle_qty(point.getVehicle_qty() - 1);
-        pointService.update(point);
-    }
-}

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

@@ -39,15 +39,15 @@ import java.util.stream.Collectors;
 
 /**
  * @Author: psh
- * @Description: 包片上料
+ * @Description: 原材料出库
- * @Date: 2023/9/28
+ * @Date: 2023/1/24
  */
 @Slf4j
 @Component
-@TaskType("BPSLTask")
+@TaskType("YCLCKTask")
 @Lazy
-public class BPSLTask extends AbstractTask {
+public class YCLCKTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "BPSLTask";
+    private static String TASK_CONFIG_CODE = "YCLCKTask";
     /**
      * 入口
      */

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

@@ -40,15 +40,15 @@ import java.util.Set;
 
 /**
  * @Author: psh
- * @Description: 满架下料
+ * @Description: 原材料入库
- * @Date: 2023/9/28
+ * @Date: 2024/1/24
  */
 @Slf4j
 @Component
-@TaskType("MJXLTask")
+@TaskType("YCLRKTask")
 @Lazy
-public class MJXLTask extends AbstractTask {
+public class YCLRKTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "MJXLTask";
+    private static String TASK_CONFIG_CODE = "YCLRKTask";
     /**
      * 入口
      */
@@ -82,28 +82,24 @@ public class MJXLTask extends AbstractTask {
                     .eq(SchBasePoint::getPoint_code, task.getPoint_code1()));
             String extGroupData = task.getExt_group_data();
             JSONObject jsonObject = JSONObject.parseObject(extGroupData);
-            String materialType = jsonObject.getString("material_type");
+//            String materialType = jsonObject.getString("material_type");
             SchBasePoint point = findNextPoint(startPoint, jsonObject);
             if (ObjectUtil.isEmpty(point)) {
                 task.setRemark("未找到所需点位!");
                 taskService.update(task);
                 // 消息通知
-                log.info("满架下料未找到当前符合条件的点位materialType:{},", materialType);
+                log.info("原材料入库未找到当前符合条件的点位！");
                 continue;
             }
-            task.setTask_type("5");
-            if("TBX2".equals(startPoint.getRegion_code())){
-                task.setTask_type("9");
-            }
             // 设置终点并修改创建成功状态
-            task.setPoint_code2(point.getNext_wait_point());
+            task.setPoint_code2(point.getPoint_code());
             task.setTask_status(TaskStatus.CREATED.getCode());
             task.setRemark("");
             taskService.update(task);
 
             //发起任务时先把点位占用，防止发起重复任务
-//            point.setIng_task_code(task.getTask_code());
+            point.setIng_task_code(task.getTask_code());
-            point.setVehicle_type(materialType);
+//            point.setVehicle_type(materialType);
             pointService.update(point);
 
             //下发
@@ -263,9 +259,6 @@ public class MJXLTask extends AbstractTask {
             if (ObjectUtil.isNotEmpty(endPointObj)) {
                 endPointObj.setIng_task_code("");
                 //任务取消把原先占用的位置释放
-                if (endPointObj.getVehicle_qty() <= 0) {
-                    endPointObj.setVehicle_type(null);
-                }
                 pointService.update(endPointObj);
             }
             taskObj.setRemark("任务取消");
@@ -286,17 +279,6 @@ public class MJXLTask extends AbstractTask {
 
     @Override
     protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
-        //重新计算固化室放货点位
+        //该场景无需重算等待点
-            JSONObject extGroupData = JSONObject.parseObject(schBaseTask.getExt_group_data());
-            SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                    .eq(SchBasePoint::getPoint_code, schBaseTask.getPoint_code1()));
-            SchBasePoint point = findNextPoint(startPoint, extGroupData);
-            schBaseTask.setPoint_code2(point.getPoint_code()+"0"+(point.getVehicle_qty()+1));
-            if(ObjectUtil.isNotEmpty(point.getIng_task_code())&&!schBaseTask.getTask_code().equals(point.getIng_task_code())){
-                throw new BadRequestException("当前固化室点位有任务，暂不反馈！");
-            }
-            //重算点位时把点位占用
-            point.setIng_task_code(schBaseTask.getTask_code());
-            pointService.update(point);
     }
 }

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

@@ -1,99 +0,0 @@
-package org.nl.wms.sch.task_manage.task.tasks;
-
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import lombok.extern.slf4j.Slf4j;
-import org.nl.common.exception.BadRequestException;
-import org.nl.config.MapOf;
-import org.nl.wms.ext.service.WmsToAcsService;
-import org.nl.wms.ext.service.dto.to.BaseResponse;
-import org.nl.wms.pdm.service.IPdmBdWorkorderService;
-import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
-import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
-import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
-import org.nl.wms.sch.point.service.ISchBasePointService;
-import org.nl.wms.sch.point.service.dao.SchBasePoint;
-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.GroupBindMaterialStatusEnum;
-import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
-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.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author: psh
- * @Description: 正极板转库堆叠
- * @Date: 2023/9/28
- */
-@Slf4j
-@Component
-@TaskType("ZJBZKDDTask")
-@Lazy
-public class ZJBZKDDTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "ZJBZKDDTask";
-    /**
-     * 入口
-     */
-    private static String ENTRANCE = "1";
-    @Autowired
-    private ISchBasePointService pointService;
-    @Autowired
-    private ISchBaseTaskService taskService;
-    @Autowired
-    private ISchBaseTaskconfigService taskConfigService;
-    @Autowired
-    private IPdmBdWorkorderService workorderService;
-    @Autowired
-    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
-    @Autowired
-    private PointMapper pointMapper;
-    @Autowired
-    private WmsToAcsService wmsToAcsService;
-
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    protected void create() throws BadRequestException {
-
-    }
-
-
-    private SchBasePoint findNextPoint(SchBasePoint startPoint) {
-        return null;
-    }
-
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    protected void updateStatus(String task_code, TaskStatus status) {
-    }
-
-    @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) {
-        //todo 重算最优点
-    }
-}

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

@@ -1,294 +0,0 @@
-package org.nl.wms.sch.task_manage.task.tasks.ghs;
-
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.lang.Assert;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import lombok.extern.slf4j.Slf4j;
-import org.nl.common.exception.BadRequestException;
-import org.nl.config.MapOf;
-import org.nl.wms.database.material.service.dao.MdBaseMaterial;
-import org.nl.wms.ext.service.WmsToAcsService;
-import org.nl.wms.ext.service.dto.to.BaseResponse;
-import org.nl.wms.pdm.service.IPdmBdWorkorderService;
-import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
-import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
-import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
-import org.nl.wms.sch.point.service.ISchBasePointService;
-import org.nl.wms.sch.point.service.dao.SchBasePoint;
-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.GeneralDefinition;
-import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
-import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
-import org.nl.wms.sch.task_manage.enums.PointStatusEnum;
-import org.nl.wms.sch.task_manage.enums.WorkOrderStatusEnum;
-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.nl.wms.util.TaskUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Component;
-
-import java.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author: psh
- * @Description: 固化室起始站点放满后自动生成搬运到内部的任务，优先级为8
- * @Date: 2023/9/28
- */
-@Slf4j
-@Component
-@TaskType("GHSFMTask")
-@Lazy
-public class GHSFMTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "GHSFMTask";
-    /**
-     * 入口
-     */
-    private static String ENTRANCE = "1";
-    @Autowired
-    private ISchBasePointService pointService;
-    @Autowired
-    private ISchBaseTaskService taskService;
-    @Autowired
-    private ISchBaseTaskconfigService taskConfigService;
-    @Autowired
-    private IPdmBdWorkorderService workorderService;
-    @Autowired
-    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
-    @Autowired
-    private PointMapper pointMapper;
-    @Autowired
-    private WmsToAcsService wmsToAcsService;
-
-    /**
-     * 1.扫描每个允许放货的固化室01和06位置是否满足三列均已放满，开始下一层判断
-     * 2.如果当列1-5或6-10总15个位置已经放满，则进行下一层判断
-     * 3.如果该固化室30个位置全部放满，则通知acs告知固化室开始固化
-     * 4.如果内部2-5或7-10仍有空列，则生成1-（2-5），6-（7-10）的任务，优先级为8最高
-     */
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    protected void create() throws BadRequestException {
-        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion("GHS", "2");
-        for (SchBasePoint schBasePoint : schBasePointList) {
-            if (!schBasePoint.getPoint_code().endsWith("01") &&
-                    !schBasePoint.getPoint_code().endsWith("06")) {
-                continue;
-            }
-            if (schBasePoint.getVehicle_qty() == 3 && ObjectUtil.isEmpty(schBasePoint.getIng_task_code())) {
-                log.info("固化室对接位{}已经放满,开始进行后续判断", schBasePoint.getPoint_code());
-                String first = schBasePoint.getPoint_code().substring(0, schBasePoint.getPoint_code().length() - 2);
-                String last = schBasePoint.getPoint_code().substring(schBasePoint.getPoint_code().length() - 1);
-                String middle = schBasePoint.getPoint_code().substring(schBasePoint.getPoint_code().length() - 4, schBasePoint.getPoint_code().length() - 2);
-                boolean flag = false;
-                String pointCode = null;
-                //倒叙检查是否有符合要求的终点
-                for (int i = 4; i > 0; i--) {
-                    pointCode = first + String.format("%02d", Integer.valueOf(last) + i);
-                    for (SchBasePoint schBasePoint1 : schBasePointList) {
-                        if (schBasePoint1.getPoint_code().equals(pointCode)
-                                && schBasePoint1.getVehicle_qty() == 0 && ObjectUtil.isEmpty(schBasePoint1.getIng_task_code())) {
-                            log.info("找到当前列内部存在空位{}", pointCode);
-                            flag = true;
-                            break;
-                        }
-                    }
-                    if (flag) {
-                        break;
-                    }
-                }
-                if (flag) {
-                    //生成任务并下发
-                    this.createTask(schBasePoint, pointCode);
-                } else {
-                    //如果当列均已放满，检查隔壁列是否已全部放满
-                    if ("1".equals(last)) {
-                        last = "6";
-                    }
-                    for (int i = 0; i <= 4; i++) {
-                        pointCode = first + String.format("%02d", Integer.valueOf(last) + i);
-                        for (SchBasePoint schBasePoint1 : schBasePointList) {
-                            if (schBasePoint1.getPoint_code().equals(pointCode)
-                                    && (schBasePoint1.getVehicle_qty() != 3 || ObjectUtil.isNotEmpty(schBasePoint1.getIng_task_code()))) {
-                                log.info("检查当前固化室{}隔壁列，找到当前列内部存在空位{}，不发送固化请求", schBasePoint.getPoint_code(), pointCode);
-                                flag = true;
-                                break;
-                            }
-                        }
-                    }
-
-                }
-                if (!flag) {
-                    //通知acs已经放满，固化室可以进行固化
-                    String device_code = "ZDM" + middle;
-                    log.info("当前固化室已经全部放满，通知固化室的自动门{}开始固化", device_code);
-                    JSONObject map = new JSONObject();
-                    map.put("device_code", device_code);
-                    map.put("type", "1");
-                    wmsToAcsService.notifyAcs(map);
-                }
-            }
-        }
-    }
-
-    /**
-     * 创建任务并下发
-     *
-     * @param schBasePoint
-     * @param endPoint
-     * @return
-     */
-    private void createTask(SchBasePoint schBasePoint, String endPoint) {
-        // 申请任务
-        SchBaseTask task = new SchBaseTask(); // 任务实体
-        String apply_point_code = schBasePoint.getPoint_code(); // 请求点
-        String config_code = "GHSFMTask";
-        // 1、校验数据
-        SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
-                .eq(SchBaseTaskconfig::getConfig_code, config_code));
-        Assert.notNull(taskConfig, "找不到配置文件，请确认[" + config_code + "]配置是否存在！");
-        // 最大任务数
-        Integer tcmn = taskConfig.getTask_create_max_num();
-        // 获取执行中的任务
-        List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(
-                taskConfig.getConfig_code(), apply_point_code + "01", taskConfig.getTask_direction());
-
-        Assert.isFalse(unFinishTasksByTaskConfig.size() >= tcmn,
-                "该点位申请的任务未完成数已超过上限，无法申请任务");
-        // 获取对接位点位对象
-        SchBasePoint pointObj = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                .eq(SchBasePoint::getPoint_code, apply_point_code));
-        // 校验是否需要自动agv
-        if (!pointObj.getIs_auto()) {
-            // 如果不需要自动，则不创建任务
-            return;
-        }
-        // 2、创建申请任务
-        task.setConfig_code(config_code);
-        task.setCreate_mode(GeneralDefinition.ACS_CREATION);
-        task.setVehicle_code(schBasePoint.getVehicle_code());
-        task.setVehicle_qty(schBasePoint.getVehicle_qty());
-        task.setTask_status(TaskStatus.APPLY.getCode());
-        task.setWorkshop_code(taskConfig.getWorkshop_code()); // 车间编码
-        //acs固化室首位不存在01和06整体概念，需要补充01生成第一个点位的任务
-        task.setPoint_code1(apply_point_code + "01");
-        task.setTask_type("2");
-        task.setPoint_code2(endPoint);
-        task.setTask_status(TaskStatus.CREATED.getCode());
-        task.setRemark("");
-        // 设置起/终点
-//        this.setTaskPoint(taskConfig, task, apply_point_code);
-        taskService.create(task);
-
-        //下发
-        this.renotifyAcs(task);
-    }
-
-    /**
-     * 修改任务状态
-     * 1.任务完成时，无需再次组盘，将点位表起点货位三个组盘信息移动到终点
-     * 2.组盘表中三个点位增加移动动作，并且修改当前点位到目标地点
-     * 3.
-     *
-     * @param task_code
-     * @param status
-     * @return
-     */
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    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("该任务已取消!");
-        }
-        String startPoint = taskObj.getPoint_code1().substring(0, taskObj.getPoint_code1().length() - 2); // 获取起点
-        String endPoint = taskObj.getPoint_code2(); // 获取终点
-        SchBasePoint startPointObj = pointService.getById(startPoint);
-        SchBasePoint endPointObj = pointService.getById(endPoint);
-        // 根据传来的类型去对任务进行操作
-        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
-            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
-            taskObj.setRemark("执行中");
-        }
-        if (status.equals(TaskStatus.FINISHED)) { // 完成
-            StringBuilder group_id = new StringBuilder();
-            // 终点解锁
-            endPointObj.setIng_task_code("");
-            endPointObj.setVehicle_type(startPointObj.getVehicle_type());
-            endPointObj.setVehicle_code(startPointObj.getVehicle_code());
-            endPointObj.setVehicle_qty(startPointObj.getVehicle_qty());
-            endPointObj.setUpdate_time(DateUtil.now());
-            pointService.update(endPointObj);
-            List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
-            for (String vehicleCode : vehicleCodeList) {
-                SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
-                        .eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
-                        .eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
-                                GroupBindMaterialStatusEnum.BOUND.getValue()));
-                if (ObjectUtil.isNotEmpty(one)) {
-//                    throw new BadRequestException(vehicleCode + " => " + startPointObj.getVehicle_type() + "的组盘信息未找到");
-//                }
-                    one.setTask_code(taskObj.getTask_code());
-                    one.setPoint_code(endPointObj.getPoint_code()); // 当前位置
-                    one.setPoint_name(endPointObj.getPoint_name());
-                    one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code());
-                    one.setUpdate_id(GeneralDefinition.ACS_ID);
-                    one.setUpdate_name(GeneralDefinition.ACS_NAME);
-                    one.setUpdate_time(DateUtil.now());
-                    vehiclematerialgroupService.updateById(one);
-                    group_id.append(one.getGroup_id()).append(',');
-                }
-            }
-            // 起点清空
-            if (ObjectUtil.isNotEmpty(startPointObj)) {
-                PointUtils.clearPoint(startPointObj);
-            }
-            // 任务完成
-            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
-            taskObj.setGroup_id(group_id.toString());
-            taskObj.setRemark("任务完成");
-        }
-        if (status.equals(TaskStatus.CANCELED)) { // 取消
-            // 终点解锁
-            if (ObjectUtil.isNotEmpty(endPointObj)) {
-                endPointObj.setIng_task_code("");
-                pointService.update(endPointObj);
-            }
-            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) {
-        //todo 重算最优点
-    }
-}

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

@@ -1,347 +0,0 @@
-package org.nl.wms.sch.task_manage.task.tasks.ghs;
-
-import cn.hutool.core.date.DateUtil;
-import cn.hutool.core.lang.Assert;
-import cn.hutool.core.util.IdUtil;
-import cn.hutool.core.util.ObjectUtil;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-import org.nl.common.exception.BadRequestException;
-import org.nl.config.MapOf;
-import org.nl.wms.ext.service.WmsToAcsService;
-import org.nl.wms.ext.service.dto.to.BaseResponse;
-import org.nl.wms.pdm.service.IPdmBdWorkorderService;
-import org.nl.wms.pdm.service.dao.PdmBdWorkorder;
-import org.nl.wms.sch.group.service.ISchBaseVehiclematerialgroupService;
-import org.nl.wms.sch.group.service.dao.SchBaseVehiclematerialgroup;
-import org.nl.wms.sch.point.service.ISchBasePointService;
-import org.nl.wms.sch.point.service.dao.SchBasePoint;
-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.GeneralDefinition;
-import org.nl.wms.sch.task_manage.enums.GroupBindMaterialStatusEnum;
-import org.nl.wms.sch.task_manage.enums.GroupStatusEnum;
-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.math.BigDecimal;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-/**
- * @Author: psh
- * @Description: 固化室通知取货后将十个点位增加到取货队列，固化室发起自动取货任务，当前固化室十个点位取货完毕后通知固化室取货完毕
- * @Date: 2023/9/28
- */
-@Slf4j
-@Component
-@TaskType("GHSQHTask")
-@Lazy
-public class GHSQHTask extends AbstractTask {
-    private static String TASK_CONFIG_CODE = "GHSQHTask";
-    /**
-     * 入口
-     */
-    private static String ENTRANCE = "1";
-    @Autowired
-    private ISchBasePointService pointService;
-    @Autowired
-    private ISchBaseTaskService taskService;
-    @Autowired
-    private ISchBaseTaskconfigService taskConfigService;
-    @Autowired
-    private IPdmBdWorkorderService workorderService;
-    @Autowired
-    private ISchBaseVehiclematerialgroupService vehiclematerialgroupService;
-    @Autowired
-    private PointMapper pointMapper;
-    @Autowired
-    private WmsToAcsService wmsToAcsService;
-
-    /**
-     * 1.扫描每个允许取货的固化室从1-10的顺序开始进行取货
-     */
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    protected void create() throws BadRequestException {
-
-        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion("GHS", "3");
-        if (schBasePointList.size() == 0) {
-            // 消息通知
-            log.info("未找到当前符合允许取货的固化室点位，暂不生成任务");
-            return;
-        }
-        SchBasePoint schBasePoint = null;
-        //按顺序查找第一个符合条件的固化室位置，发起任务
-        for (SchBasePoint schBasePoint1 : schBasePointList) {
-            if (schBasePoint1.getVehicle_qty() == 3 && ObjectUtil.isEmpty(schBasePoint1.getIng_task_code())) {
-                schBasePoint = schBasePoint1;
-                break;
-            }
-        }
-        if (ObjectUtil.isEmpty(schBasePoint)) {
-            // 消息通知
-            log.info("未找到当前符合允许取货的固化室点位，暂不生成任务");
-            return;
-        }
-        SchBasePoint nextPoint = this.findNextPoint(schBasePoint);
-        if (ObjectUtil.isEmpty(nextPoint)) {
-            // 消息通知
-            log.info("未找到当前符合允许放货的缓存点，暂不生成任务Vehicle_type:{}", schBasePoint.getVehicle_type());
-            return;
-        }
-        // 放料先去等待点
-        this.createTask(schBasePoint, nextPoint.getStart_wait_point());
-
-    }
-
-    /**
-     * 创建任务并下发
-     *
-     * @param schBasePoint
-     * @param endPoint
-     * @return
-     */
-    private void createTask(SchBasePoint schBasePoint, String endPoint) {
-        // 申请任务
-        SchBaseTask task = new SchBaseTask(); // 任务实体
-        String apply_point_code = schBasePoint.getPoint_code(); // 请求点
-        // 获取对接位点位对象
-        SchBasePoint pointObj = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                .eq(SchBasePoint::getPoint_code, apply_point_code));
-        //首位01或06生成任务需要补01，例如GHS0101下发需要改成GHS010101
-        if(apply_point_code.endsWith("01")||apply_point_code.endsWith("06")) {
-            apply_point_code+="01";
-        }
-        String config_code = "GHSQHTask";
-        // 1、校验数据
-        SchBaseTaskconfig taskConfig = taskConfigService.getOne(new LambdaQueryWrapper<SchBaseTaskconfig>()
-                .eq(SchBaseTaskconfig::getConfig_code, config_code));
-        Assert.notNull(taskConfig, "找不到配置文件，请确认[" + config_code + "]配置是否存在！");
-        // 最大任务数
-        Integer tcmn = taskConfig.getTask_create_max_num();
-        // 获取执行中的任务
-        List<SchBaseTask> unFinishTasksByTaskConfig = taskService.findUnFinishTasksByTaskConfig(
-                taskConfig.getConfig_code(), apply_point_code, taskConfig.getTask_direction());
-
-        Assert.isFalse(unFinishTasksByTaskConfig.size() >= tcmn,
-                "该点位申请的任务未完成数已超过上限，无法申请任务");
-        // 校验是否需要自动agv
-        if (!pointObj.getIs_auto()) {
-            // 如果不需要自动，则不创建任务
-            return;
-        }
-        // 2、创建申请任务
-        task.setConfig_code(config_code);
-        task.setCreate_mode(GeneralDefinition.ACS_CREATION);
-        task.setVehicle_code(schBasePoint.getVehicle_code());
-        task.setVehicle_qty(schBasePoint.getVehicle_qty());
-//        task.setTask_status(TaskStatus.APPLY.getCode());
-        task.setWorkshop_code(taskConfig.getWorkshop_code()); // 车间编码
-        //首位01或06生成任务需要补01，例如GHS0101下发需要改成GHS010101
-        task.setPoint_code1(apply_point_code);
-        task.setPoint_code2(endPoint);
-        task.setTask_status(TaskStatus.CREATED.getCode());
-        task.setRemark("");
-        if("GHS1".equals(schBasePoint.getRegion_code())) {
-            task.setTask_type("6");
-        }else{
-            task.setTask_type("10");
-        }
-        // 设置起/终点
-//        this.setTaskPoint(taskConfig, task, apply_point_code);
-        taskService.create(task);
-
-        //下发
-        this.renotifyAcs(task);
-    }
-
-    /**
-     * 1.根据当前固化室所处区域，判断到哪个区的缓存位
-     * 正极板到HCQ4,负极板到HCQ2，边负极板到HCQ3
-     * 2.从1010列到0101列倒叙判断当前列物料类型是否与起点一致且存在空位
-     * 3.将当前点位设置为目标点
-     * 4.如果没有符合条件的点位，跳过执行暂时等待
-     */
-    private SchBasePoint findNextPoint(SchBasePoint startPoint) {
-        String regionCode = null;
-        String materialType = startPoint.getVehicle_type();
-        if ("1".equals(startPoint.getVehicle_type())) {
-            //正极板到缓存区4
-            regionCode = "HCQ4";
-
-        } else if ("2".equals(startPoint.getVehicle_type())) {
-            //负极板到缓存区2
-            regionCode = "HCQ2";
-        } else if ("3".equals(startPoint.getVehicle_type())) {
-            //边负极板到缓存区3
-            regionCode = "HCQ3";
-        }
-        List<SchBasePoint> schBasePointList = pointMapper.findPointByRegion(regionCode, "1");
-        for (int i = schBasePointList.size() - 1; i >= 0; i--) {
-            SchBasePoint schBasePoint = schBasePointList.get(i);
-            SchBasePoint temp = null;
-            if (schBasePoint.getVehicle_qty() == 0
-                    && ObjectUtil.isEmpty(schBasePoint.getIng_task_code())
-                    //放货三拖一起放，只能到01位置
-                    && schBasePoint.getPoint_code().endsWith("01")
-                    && (ObjectUtil.isEmpty(schBasePoint.getVehicle_type()) || materialType.equals(schBasePoint.getVehicle_type()))) {
-                //发现有空位时暂存当前位置，检查当前列前面是否存在已放货位置，找最前面无货的位置
-                //如果当列其他位置均已放满，则继续找下一列
-                List<SchBasePoint> tempList = pointMapper.findPointByParentPoint(schBasePoint.getParent_point_code());
-
-                for (SchBasePoint tempPoint : tempList) {
-                    if ((tempPoint.getVehicle_qty() != 0 || ObjectUtil.isNotEmpty(schBasePoint.getIng_task_code()))
-                    ) {
-                        break; // 如果当前库位非空，则跳出循环
-                    } else {
-                        if(tempPoint.getPoint_code().endsWith("01")) {
-                            temp = tempPoint; // 更新最大空库位
-                        }
-                    }
-                }
-                if (temp != null) {
-                    log.info("固化室取货任务找到当前符合条件的缓存区位置{}", schBasePoint.getPoint_code());
-                }
-                return temp;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 1.如果起点点位为10结尾视为最后该固化室最后一个任务，取完后通知acs取货完毕
-     */
-    @Override
-//    @Transactional(rollbackFor = Exception.class)
-    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("该任务已取消!");
-        }
-        String startPoint = taskObj.getPoint_code1(); // 获取起点
-        if(startPoint.endsWith("0101")||startPoint.endsWith("0601")){
-            startPoint=startPoint.substring(0,startPoint.length()-2);
-        }
-        String endPoint = taskObj.getPoint_code2(); // 获取终点
-        SchBasePoint startPointObj = pointService.getById(startPoint);
-        SchBasePoint endPointObj = pointService.getById(endPoint);
-        // 根据传来的类型去对任务进行操作
-        if (status.equals(TaskStatus.EXECUTING)) { // 执行中
-            taskObj.setTask_status(TaskStatus.EXECUTING.getCode());
-            taskObj.setRemark("执行中");
-        }
-        if (status.equals(TaskStatus.FINISHED)) { // 完成
-            StringBuilder group_id = new StringBuilder();
-            // 终点解锁，缓存区现在由一个点位改为三个点位，所以将物料存在010203三个位置上
-            for(int i=1;i<=3;i++) {
-                SchBasePoint point = pointService.getById(endPoint.substring(0,endPoint.length()-1)+i);
-                point.setIng_task_code("");
-                List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
-                point.setVehicle_code(vehicleCodeList.get(i-1));
-                point.setVehicle_type(startPointObj.getVehicle_type());
-                point.setVehicle_qty(1);
-                point.setUpdate_time(DateUtil.now());
-                pointService.update(point);
-            }
-            //固化室放料完毕后，将当前一整排都标记上物料信息，防止出现混放情况
-            pointMapper.updateVehicleType(endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 2), endPointObj.getVehicle_type());
-            List<String> vehicleCodeList = Arrays.stream(startPointObj.getVehicle_code().split(",")).collect(Collectors.toList());
-            for (int i=0;i<vehicleCodeList.size();i++) {
-                String vehicleCode=vehicleCodeList.get(i);
-                SchBaseVehiclematerialgroup one = vehiclematerialgroupService.getOne(new LambdaQueryWrapper<SchBaseVehiclematerialgroup>()
-                        .eq(SchBaseVehiclematerialgroup::getVehicle_code, vehicleCode)
-                        .eq(SchBaseVehiclematerialgroup::getGroup_bind_material_status,
-                                GroupBindMaterialStatusEnum.BOUND.getValue()));
-                if (ObjectUtil.isNotEmpty(one)) {
-                    one.setTask_code(taskObj.getTask_code());
-                    one.setPoint_code(endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 1) + (i + 1)); // 当前位置
-                    one.setPoint_name(endPointObj.getPoint_name().substring(0, endPointObj.getPoint_name().length() - 1) + (i + 1));
-                    one.setMove_way(one.getMove_way() == null ? "" : (one.getMove_way() + " -> ") + endPointObj.getPoint_code().substring(0, endPointObj.getPoint_code().length() - 1) + (i + 1));
-                    one.setUpdate_id(GeneralDefinition.ACS_ID);
-                    one.setUpdate_name(GeneralDefinition.ACS_NAME);
-                    one.setUpdate_time(DateUtil.now());
-                    vehiclematerialgroupService.updateById(one);
-                    group_id.append(one.getGroup_id()).append(',');
-                }
-
-            }
-            // 起点清空
-            if (ObjectUtil.isNotEmpty(startPointObj)) {
-                PointUtils.clearPoint(startPointObj);
-            }
-            // 任务完成
-            taskObj.setTask_status(TaskStatus.FINISHED.getCode());
-            taskObj.setGroup_id(group_id.toString());
-            taskObj.setRemark("任务完成");
-
-            //如果起点点位为10结尾视为最后该固化室最后一个任务，取完后通知acs取货完毕
-            // (如果不放满的情况可以固化，可能逻辑需要改成任务完成时检测当前固化室所有点位是否已完成)
-            if (taskObj.getPoint_code1().endsWith("10")) {
-                String middle = taskObj.getPoint_code1().substring(taskObj.getPoint_code1().length() - 4, taskObj.getPoint_code1().length() - 2);
-                //通知acs已经放满，固化室可以进行固化
-                String device_code = "ZDM" + middle;
-                log.info("当前固化室已经全部取完，通知固化室的自动门{}取货完毕", device_code);
-                JSONObject map = new JSONObject();
-                map.put("device_code", device_code);
-                map.put("type", "2");
-                wmsToAcsService.notifyAcs(map);
-            }
-        }
-        if (status.equals(TaskStatus.CANCELED)) { // 取消
-            // 终点解锁
-            if (ObjectUtil.isNotEmpty(endPointObj)) {
-                endPointObj.setIng_task_code("");
-                pointService.update(endPointObj);
-            }
-            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);
-    }
-
-    @SneakyThrows
-    @Override
-    protected void feedbackTaskState(JSONObject param, SchBaseTask schBaseTask, BaseResponse result) {
-        //todo 重算最优点
-        String schBasePoint=schBaseTask.getPoint_code1();
-        if(schBasePoint.endsWith("0101")||schBasePoint.endsWith("0601")){
-            schBasePoint=schBasePoint.substring(0,schBasePoint.length()-2);
-        }
-        SchBasePoint startPoint = pointService.getOne(new LambdaQueryWrapper<SchBasePoint>()
-                .eq(SchBasePoint::getPoint_code, schBasePoint));
-        SchBasePoint nextPoint = this.findNextPoint(startPoint);
-        if (ObjectUtil.isEmpty(nextPoint)) {
-            throw new Exception("当前起点" + schBaseTask.getPoint_code1() + "未找到合适的放货点位");
-        }
-        //上位记的是整一个缓存区三个点
-        schBaseTask.setPoint_code2(nextPoint.getPoint_code());
-        nextPoint.setIng_task_code(schBaseTask.getTask_code());
-        pointService.update(nextPoint);
-    }
-}

lms/nladmin-system/nlsso-server/src/main/resources/config/application-dev.yml

@@ -6,7 +6,7 @@ spring:
     druid:
       db-type: com.alibaba.druid.pool.DruidDataSource
       driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
-      url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:cw_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
+      url: jdbc:log4jdbc:mysql://${DB_HOST:127.0.0.1}:${DB_PORT:3306}/${DB_NAME:gc_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
 #      url: jdbc:log4jdbc:mysql://${DB_HOST:47.111.78.178}:${DB_PORT:3306}/${DB_NAME:stand_lms}?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false&useOldAliasMetadataBehavior=true
       username: ${DB_USER:root}
       password: ${DB_PWD:123456}