Merge branch 'master' of http://10.153.19.25:10105/r/YiWuProject

wangfei

2025-09-23 1a74c9c77b67ee5faa444e9671dcb2020e673341

Merge branch 'master' of http://10.153.19.25:10105/r/YiWuProject

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/controller/ProductAlarmInfoController.java

New file
@@ -0,0 +1,37 @@
package com.mes.alarm.controller;


import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.mes.alarm.entity.ProductAlarmInfo;
import com.mes.alarm.entity.request.ProductAlarmInfoRequest;
import com.mes.alarm.service.ProductAlarmInfoService;
import com.mes.common.config.Const;
import com.mes.utils.Result;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author Administrator
 */
@RestController
@RequestMapping("productAlarmInfo")
public class ProductAlarmInfoController {
    /**
     * 服务对象
     */
    @Resource
    private ProductAlarmInfoService productAlarmInfoService;

    @ApiOperation("报警数据确认")
    @PostMapping("/updateAlarmInfo")
    public Result<Boolean> updateAlarmInfo(@RequestBody ProductAlarmInfoRequest request) {
        return Result.build(200, "查询成功", productAlarmInfoService.update(new LambdaUpdateWrapper<ProductAlarmInfo>()
                .eq(ProductAlarmInfo::getId, request.getId()).set(ProductAlarmInfo::getState, Const.RAW_GLASS_TASK_SUCCESS)));
    }
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/entity/ProductAlarmInfo.java

New file
@@ -0,0 +1,56 @@
package com.mes.alarm.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

import java.util.Date;

/**
 * 生产报警表(ProductAlarmInfo)表实体类
 *
 * @author makejava
 * @since 2025-09-19 16:00:31
 */
@Data
public class ProductAlarmInfo {
    /**
     * 报警ID
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    /**
     * 报警模块
     */
    private String alarmModule;
    /**
     * 报警类型
     */
    private String alarmType;
    /**
     * 报警编码
     */
    private String alarmCode;
    /**
     * 报警级别(ERROR/WARN/INFO)
     */
    private String alarmLevel;
    /**
     * 报警详细信息
     */
    private String alarmMessage;
    /**
     * 任务状态
     */
    private Integer state;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/entity/request/ProductAlarmInfoRequest.java

New file
@@ -0,0 +1,48 @@
package com.mes.alarm.entity.request;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;

/**
 * @Author : zhoush
 * @Date: 2025/9/19 16:24
 * @Description:
 */
@ApiModel(description = "生产预警请求")
@Data
public class ProductAlarmInfoRequest {

    /**
     * 报警ID
     */
    @ApiModelProperty(value = "报警ID", position = 1)
    private Long id;
    /**
     * 报警模块
     */
    @ApiModelProperty(value = "报警模块", position = 2)
    private String alarmModule;
    /**
     * 报警类型
     */
    @ApiModelProperty(value = "报警类型", position = 3)
    private String alarmType;
    /**
     * 报警编码
     */
    @ApiModelProperty(value = "报警编码", position = 4)
    private String alarmCode;
    /**
     * 报警级别(ERROR/WARN/INFO)
     */
    @ApiModelProperty(value = "报警级别(ERROR/WARN/INFO)", position = 5)
    private String alarmLevel;
    /**
     * 任务状态
     */
    @ApiModelProperty(value = "报警状态", position = 6)
    private Integer state;
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/mapper/ProductAlarmInfoMapper.java

New file
@@ -0,0 +1,15 @@
package com.mes.alarm.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.alarm.entity.ProductAlarmInfo;

/**
 * 生产报警表(ProductAlarmInfo)表数据库访问层
 *
 * @author makejava
 * @since 2025-09-19 16:00:31
 */
public interface ProductAlarmInfoMapper extends BaseMapper<ProductAlarmInfo> {

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/service/ProductAlarmInfoService.java

New file
@@ -0,0 +1,15 @@
package com.mes.alarm.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.alarm.entity.ProductAlarmInfo;

/**
 * 生产报警表(ProductAlarmInfo)表服务接口
 *
 * @author makejava
 * @since 2025-09-19 16:00:31
 */
public interface ProductAlarmInfoService extends IService<ProductAlarmInfo> {

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/alarm/service/impl/ProductAlarmInfoServiceImpl.java

New file
@@ -0,0 +1,19 @@
package com.mes.alarm.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.alarm.mapper.ProductAlarmInfoMapper;
import com.mes.alarm.entity.ProductAlarmInfo;
import com.mes.alarm.service.ProductAlarmInfoService;
import org.springframework.stereotype.Service;

/**
 * 生产报警表(ProductAlarmInfo)表服务实现类
 *
 * @author makejava
 * @since 2025-09-19 16:00:31
 */
@Service
public class ProductAlarmInfoServiceImpl extends ServiceImpl<ProductAlarmInfoMapper, ProductAlarmInfo> implements ProductAlarmInfoService {

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/OptimizeProjectServiceImpl.java

@@ -16,6 +16,7 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
@@ -36,9 +37,12 @@
    @Override
    public List<OptimizeProject> listByState(OptimizeRequest optimizeRequest) {
        //PP表未开始的工程号
        // 计算二个月前的时间
        LocalDateTime twoMonthAgo = LocalDateTime.now().minusMonths(2);
        LambdaQueryWrapper<OptimizeProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(OptimizeProject::getProjectNo)
                .eq(OptimizeProject::getState, optimizeRequest.getState());
                .eq(OptimizeProject::getState, optimizeRequest.getState())
                .ge(OptimizeProject::getCreateTime, twoMonthAgo);
        List<OptimizeProject> glass = this.list(wrapper);
        //暂停的工程号
        List<Engineering> engineerings = engineeringService.selectTask();
@@ -59,21 +63,21 @@
    @Override
    public void changeTask(String engineeringId, int state) {
        UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
        wrapper.eq("project_no",engineeringId)
                .set("state",state);
        wrapper.eq("project_no", engineeringId)
                .set("state", state);
        boolean updateSuccess = this.update(wrapper);
        log.info("工程表更新状态{}",updateSuccess);
        log.info("工程表更新状态{}", updateSuccess);

    }

    @Override
    public boolean overTask(UpPattenUsage sequence, int state) {
        if(sequence.getState()==100){
            UpdateWrapper<OptimizeProject> wrapper=new  UpdateWrapper<>();
            wrapper.eq("project_no",sequence.getEngineeringId())
                    .set("state",state);
        if (sequence.getState() == 100) {
            UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
            wrapper.eq("project_no", sequence.getEngineeringId())
                    .set("state", state);
            boolean updateSuccess = this.update(wrapper);
            log.info("工程完成更新状态{}",updateSuccess);
            log.info("工程完成更新状态{}", updateSuccess);
        }
        return false;
    }
@@ -82,7 +86,7 @@
    public List<OptimizeProject> getDoingTask() {
        QueryWrapper<OptimizeProject> wrapper = new QueryWrapper<>();
        wrapper.select("project_no,project_name")
        .eq("state",200);
                .eq("state", 200);
        return this.list(wrapper);
    }


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/controller/EngineeringController.java

@@ -15,7 +15,6 @@
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

@@ -129,8 +128,8 @@
//        glassInfoService.deleteTask(engineering.getEngineerId());
//        upPattenUsageService.deleteTask(engineering.getEngineerId());
//        optimizeProjectService.changeTask(engineering.getEngineerId(), 100);
        //暂停工程
        engineeringService.pauseTask(engineering.getEngineerId(), 0);
        //暂停工程  - > 改为删除工程
        engineeringService.deleteTask(engineering.getEngineerId());
        //查询未上片的小片信息
        List<GlassInfo> glasslist = glassInfoService.selectEdgGlassInfo(engineering.getEngineerId());
        return Result.build(200, "删除成功" + engineering.getEngineerId(), glasslist);

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java

@@ -10,6 +10,8 @@
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.alarm.entity.ProductAlarmInfo;
import com.mes.alarm.service.ProductAlarmInfoService;
import com.mes.base.entity.HollowBigStorageCageBaseInfo;
import com.mes.bigstoragecagetask.entity.BigStorageCageTask;
import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;
@@ -101,11 +103,19 @@
    @Qualifier("CMJ1ModbusTcp")
    ModbusTcp CMJ1ModbusTcp;

    @Resource
    private ProductAlarmInfoService productAlarmInfoService;

    private static final String BIG_STORAGE_CAGE_IN_TWO_TASK = "big_storage_cage_in_two_task";
    private static final String BIG_STORAGE_CAGE_OUT_TWO_TASK = "big_storage_cage_out_two_task";

    private static final List<Integer> ONE_LINE_FIRST = Arrays.asList(930, 931, 932);
    private static final List<Integer> TWO_LINE_FIRST = Arrays.asList(931, 930, 932);


    private static final String ALARM_MODULE = "中空";
    private static final String ALARM_TYPE = "中空大理片";
    private static final String ALARM_CODE = "sizeSame";

    /**
     * 直通格子
@@ -118,6 +128,15 @@

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() {
        List<ProductAlarmInfo> alarmInfos = productAlarmInfoService.list(new LambdaQueryWrapper<ProductAlarmInfo>()
                .eq(ProductAlarmInfo::getState, Const.LOAD_RAW_GLASS_NEW)
                .eq(ProductAlarmInfo::getAlarmModule, ALARM_MODULE)
                .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE)
                .eq(ProductAlarmInfo::getAlarmCode, ALARM_CODE));
        if (CollectionUtil.isNotEmpty(alarmInfos)) {
            log.info("界面报警，等待人工干预处理");
            return;
        }
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        log.info("进片任务读取s7DataZKDLPOne:{}", s7DataZKDLPOne);
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
@@ -240,51 +259,49 @@
        List<HollowBigStorageCageHistoryTask> historyTasks = new ArrayList<>();

        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        try {
            log.info("开始计算目标格子,玻璃id有：{}", inTaskList);
            if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
                for (BigStorageCageTask task : inTaskList) {
                    GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                    HollowBigStorageDTO bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),

        log.info("开始计算目标格子,玻璃id有：{}", inTaskList);
        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
            for (BigStorageCageTask task : inTaskList) {
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                HollowBigStorageDTO bigStorageDTO = null;
                try {
                    bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),
                            info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer());
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                    hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
                            .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                            .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
                    task.setTargetSlot(bigStorageDTO.getSlot());
                    task.setGlassId(info.getGlassId());
                    //存放历史任务
                    HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                    BeanUtils.copyProperties(task, historyTask);
                    historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
                    historyTask.setGlassCount(glassInfoList.size());
                    historyTask.setTaskState(Const.ENGINEERING_NEW);
                    historyTasks.add(historyTask);
                    //存放详情数据
                    HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
                    BeanUtils.copyProperties(bigStorageDTO, cageDetails);
                    BeanUtils.copyProperties(info, cageDetails);
                    cageDetails.setState(Const.GLASS_STATE_NEW);
                    cageDetails.setSequence(bigStorageDTO.getSlotSequence());
                    cageDetails.setGap(glassGap);
                    cageDetails.setId(null);
                    hollowBigStorageCageDetailsService.save(cageDetails);
                } catch (Exception exception) {
                    log.info("进片任务执行中发生异常：{}", exception);
                    //保存故障信息
                    ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
                    alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
                    alarmInfo.setAlarmModule(ALARM_MODULE);
                    alarmInfo.setAlarmType(ALARM_TYPE);
                    alarmInfo.setAlarmCode(ALARM_CODE);
                    alarmInfo.setAlarmMessage(info.getGlassId());
                    productAlarmInfoService.save(alarmInfo);
                    //重置详情表数据
                    hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                            .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_TAKE)
                            .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW));
                    //重置中空关系表数据
                    hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                            .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
                            .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
                            .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
                            .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
                            .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                            .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
                            .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
                            .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
                            .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
                            .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                            .set(HollowGlassRelationInfo::getGlassId, null)
                            .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
                            .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
                            .set(HollowGlassRelationInfo::getEngineerId, null)
                            .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
                            .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                    );
                    //将格子尺寸恢复
                    hollowBigStorageCageService.resetCage();
                    return;
                }
            } else {
                BigStorageCageTask task = inTaskList.get(0);
                task.setTargetSlot(THROUGH_SLOT);

//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
                        .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                        .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
                task.setTargetSlot(bigStorageDTO.getSlot());
                task.setGlassId(info.getGlassId());
                //存放历史任务
                HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -292,37 +309,52 @@
                historyTask.setGlassCount(glassInfoList.size());
                historyTask.setTaskState(Const.ENGINEERING_NEW);
                historyTasks.add(historyTask);
                GlassInfo info = glassInfoList.get(0);
                //存放详情数据
                HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
                BeanUtils.copyProperties(bigStorageDTO, cageDetails);
                BeanUtils.copyProperties(info, cageDetails);
                cageDetails.setSlot(THROUGH_SLOT);
                cageDetails.setState(Const.GLASS_STATE_NEW);
                cageDetails.setDeviceId(0);
                cageDetails.setSequence(0);
                cageDetails.setHollowSequence(0);
                cageDetails.setSequence(bigStorageDTO.getSlotSequence());
                cageDetails.setGap(glassGap);
                cageDetails.setFilmsId(info.getFilmsid());
                cageDetails.setId(null);
                hollowBigStorageCageDetailsService.save(cageDetails);
                hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                        .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
                        .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
                        .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
                        .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
                        .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                        .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
                        .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
                        .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
                        .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
                        .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                );
            }
        } catch (Exception exception) {
            log.info("进片任务执行中发生异常：{}", exception);
            hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                    .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_TAKE)
                    .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW));

            hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                    .set(HollowGlassRelationInfo::getGlassId, null)
                    .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
                    .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
                    .set(HollowGlassRelationInfo::getEngineerId, null)
                    .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
                    .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
            );
            //将格子尺寸恢复
            hollowBigStorageCageService.resetCage();
            return;
        } else {
            BigStorageCageTask task = inTaskList.get(0);
            task.setTargetSlot(THROUGH_SLOT);
            //存放历史任务
            HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
            BeanUtils.copyProperties(task, historyTask);
            historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
            historyTask.setGlassCount(glassInfoList.size());
            historyTask.setTaskState(Const.ENGINEERING_NEW);
            historyTasks.add(historyTask);
            GlassInfo info = glassInfoList.get(0);
            HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            cageDetails.setSlot(THROUGH_SLOT);
            cageDetails.setState(Const.GLASS_STATE_NEW);
            cageDetails.setDeviceId(0);
            cageDetails.setSequence(0);
            cageDetails.setHollowSequence(0);
            cageDetails.setGap(glassGap);
            cageDetails.setFilmsId(info.getFilmsid());
            cageDetails.setId(null);
            hollowBigStorageCageDetailsService.save(cageDetails);
        }

        //历史数据入库
        hollowBigStorageCageHistoryTaskService.saveBatch(historyTasks);
        //向opc发送启动信号

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/PushMessageToIndex.java

@@ -5,6 +5,8 @@
import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.service.MiloService;
import com.mes.alarm.entity.ProductAlarmInfo;
import com.mes.alarm.service.ProductAlarmInfoService;
import com.mes.bigstoragecagetask.entity.BigStorageCageTask;
import com.mes.bigstoragecagetask.entity.BigStorageTaskVO;
import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;
@@ -67,6 +69,8 @@

    @Autowired(required = false)
    MiloService miloService;
    @Resource
    ProductAlarmInfoService productAlarmInfoService;

    @Autowired
    @Qualifier("s7SerializerZKDLPOne")
@@ -94,6 +98,10 @@

    @Resource
    RedisUtil redisUtil;

    private static final String ALARM_MODULE = "中空";
    private static final String ALARM_TYPE = "中空大理片";
    private static final String ALARM_CODE = "sizeSame";

    @Scheduled(fixedDelay = 5000)
    public void hollowGlassTaskOne() {
@@ -330,6 +338,12 @@
        //缺片详情
        List<LackDetailsDTO> lackDetailsList = hollowGlassRelationInfoService.queryLackByFlowCard();
        jsonObject.append("lackDetailsList", lackDetailsList);

        jsonObject.append("alarmInfo", productAlarmInfoService.list(new LambdaQueryWrapper<ProductAlarmInfo>()
                .eq(ProductAlarmInfo::getState, Const.LOAD_RAW_GLASS_NEW)
                .eq(ProductAlarmInfo::getAlarmModule, ALARM_MODULE)
                .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE)
                .eq(ProductAlarmInfo::getAlarmCode, ALARM_CODE)));
    }

    @Scheduled(fixedDelay = 1000)