Merge remote-tracking branch 'origin/master'

wangfei

2025-04-02 880d2fb2f1082ed63b3f21259710ed683b14ae51

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/OpcLoadGlassTask.java

@@ -10,6 +10,8 @@
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.opctask.service.LoadGlassDeviceTaskHistoryService;
import com.mes.opctask.service.LoadGlassDeviceTaskService;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.uppattenusage.entity.UpPattenUsage;
@@ -17,6 +19,7 @@
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@@ -47,6 +50,8 @@
    private LoadGlassDeviceTaskHistoryService loadGlassDeviceTaskHistoryService;
    @Resource
    private UpPattenUsageMapper upPattenUsageMapper;
    @Resource
    private OptimizeProjectService optimizeProjectService;

    private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
    private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104);
@@ -58,28 +63,49 @@

    private static final String LOAD_GLASS_DEVICE_TWO_TASK = "load_glass_device_two_task";


    //设备id   上片位信息   任务表不一致   历史任务表公用一张 新增任务/任务结束，后会在历史表中新增一条记录并在结束后更新任务  一个任务即可
    //定时任务扫描上片位有没有原片
    //1、是否有在执行的任务
    //2、1号上片位是否有原片，原片尺寸是否和上片待上片的尺寸一致
    //3、1号无原片，且没有架子，2号上片位尺寸是否和带上片尺寸一致
    //4、不一致可能出现玻璃破损导致的上一架原片数量不够
    @Scheduled(fixedDelay = 5000)
    public void opcLoadGlassOne() {
        opcLoadGlassChild(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE);
    }

    @Scheduled(fixedDelay = 5000)
    public void opcLoadGlassTwo() {
        opcLoadGlassChild(LOAD_GLASS_DEVICE_TWO_TASK, LOAD_GLASS_TWO_DEVICE);
    }


    @Scheduled(fixedDelay = 5000)
    public void opcLoadGlassOneFinish() {
        opcLoadGlassFinishChid(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE);
    }

    @Scheduled(fixedDelay = 5000)
    public void opcLoadGlassTwoFinish() {
        opcLoadGlassFinishChid(LOAD_GLASS_DEVICE_TWO_TASK, LOAD_GLASS_TWO_DEVICE);
    }

    /**
     * 定时任务扫码已完成上片的工程，将工程状态改为已完成，同步pp表的工程表，状态改为300
     */
    @Scheduled(fixedDelay = 5000)
    public void updateEngineerState() {
        log.info("修改已完成工程状态任务开始执行");
        List<Engineering> engineerings = engineeringMapper.selectList(new LambdaQueryWrapper<Engineering>().eq(Engineering::getState, Const.ENGINEERING_RUNNING));
        for (Engineering engineering : engineerings) {
            Integer count = upPattenUsageMapper.selectCount(new LambdaQueryWrapper<UpPattenUsage>()
                    .eq(UpPattenUsage::getEngineeringId, engineering.getEngineerId()).ne(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS));
            if (count == 0) {
                engineeringMapper.update(null, new LambdaUpdateWrapper<Engineering>().set(Engineering::getState, Const.ENGINEERING_SUCCESS)
                        .eq(Engineering::getEngineerId, engineering.getEngineerId()));
                optimizeProjectService.update(null, new LambdaUpdateWrapper<OptimizeProject>().set(OptimizeProject::getState, 300)
                        .eq(OptimizeProject::getProjectNo, engineering.getEngineerId()));
            }
        }
    }

    private void opcLoadGlassChild(String tableName, Integer deviceId) {
@@ -87,11 +113,16 @@
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING).eq(Engineering::getStationCell, deviceId));
        if (null == engineering) {
            log.info("{}上片线，没有工程任务", deviceId);
            return;
        }
        //任务暂停
        LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName);
        if ("1".equals(task.getTaskState())) {
            log.info("有正在执行的上片任务，结束本地上片请求");
        if (0 == task.getInkageState()) {
            log.info("{}上片线，处于离线状态：{}，结束本地上片请求", deviceId, task.getInkageState());
            return;
        }
        if (task.getTaskRunning().equals(Const.ENGINEERING_RUNNING)) {
            log.info("{}上片线，有正在执行的任务，结束本地上片请求", deviceId);
            return;
        }
        List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(engineering.getEngineerId());
@@ -104,12 +135,12 @@
        Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
                .collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber));
        log.info("获取当前需要上片的原片数据");
        List<UpPattenUsageVO> usageVOS = upListMap.get(0);
        List<UpPattenUsageVO> usageVOS = upListMap.get("1");
//        获取1号上片位是有架子且有玻璃
        List<Integer> loadStation = LOAD_GLASS_DEVICE_ONE_TASK.equals(tableName) ? LOAD_STATION_01 : LOAD_STATION_02;
        List<RawGlassStorageDetails> loadStationList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN_ALL)
                .eq(RawGlassStorageDetails::getDeviceId, deviceId));
        if (CollectionUtils.isEmpty(loadStationList)) {
            log.info("当前上片线路两个上片位都没有原片信息，结束本次上片任务，等待仓储调度任务");
@@ -118,7 +149,7 @@
        RawGlassStorageDetails oneLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(0))).findFirst().orElse(null);
        if (null == oneLoadStation) {
            RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
            if (!compareRawSize(usageVOS.get(0), oneLoadStation)) {
            if (!compareRawSize(usageVOS.get(0), twoLoadStation)) {
                log.info("二号上片位有架子，原片数量为0或者原片信息与待上片尺寸不一致，结束本次上片任务，等待仓储调度任务");
                return;
            }
@@ -151,8 +182,12 @@

    private void opcLoadGlassFinishChid(String tableName, Integer deviceId) {
        LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName);
        if (task.getTaskRunning().equals(Const.ENGINEERING_NEW)) {
            log.info("无任务,结束");
            return;
        }
        if (task.getTaskState() <= 1) {
            log.info("无任务或任务正在执行中");
            log.info("任务正在执行,结束");
            return;
        }
        //获取任务完成情况
@@ -165,12 +200,16 @@
                .inSql("slot", "select slot from raw_glass_storage_station where enable_state = 1")
                .eq("slot", task.getSlot())
                .eq("state", Const.RAW_GLASS_STATE_IN)
                .set("remain_quantity", "remain_quantity - " + (finishCount + damageCount)));
                .setSql("remain_quantity = remain_quantity - " + (finishCount + damageCount)));
        //更新工程下的原片数量 todo:sql待优化
        upPattenUsageMapper.update(null, new LambdaUpdateWrapper<UpPattenUsage>()
                .inSql(UpPattenUsage::getId, " SELECT id FROM up_patten_usage ORDER BY id ASC LIMIT 10")
                .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS));
        //todo:任务表数据情况

        if (finishCount > 0) {
            List<Integer> ids = upPattenUsageMapper.queryFinishByEngineering(deviceId, finishCount);
            upPattenUsageMapper.update(null, new LambdaUpdateWrapper<UpPattenUsage>()
                    .in(UpPattenUsage::getId, ids)
                    .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS));
        }
        //任务表数据情况
        task.setTaskRunning(0);
        task.setTotalCount(0);
        task.setRawGlassWidth(0);