Merge remote-tracking branch 'origin/master'

wangfei

2024-11-08 3c7d672fb7d6c34742fb7da6f66616ccf3be2c9a

Merge remote-tracking branch 'origin/master'

# Conflicts:
#	hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/entity/Engineering.java

 UI-Project/src/views/ReportWork/reportWork.vue

@@ -7,8 +7,8 @@
    <el-select v-model="report.type" :placeholder="$t('reportmanage.ctype')" style="margin-left: 10px;" >
      <el-option :label="$t('reportmanage.all')" value="0"></el-option>
      <el-option :label="$t('reportmanage.completed')" value="1"></el-option>
      <el-option :label="$t('reportmanage.broke')" value="2"></el-option>
      <el-option :label="$t('reportmanage.takeout')" value="3"></el-option>
      <el-option :label="$t('reportmanage.broke')" value="8"></el-option>
      <el-option :label="$t('reportmanage.takeout')" value="9"></el-option>
    </el-select>
    <el-select v-model="report.status" :placeholder="$t('reportmanage.cstate')" style="margin-left: 10px;" >
      <el-option :label="$t('reportmanage.all')" value="0"></el-option>

 hangzhoumesParent/JsonFile/PlcCacheVerticalGlass.json

@@ -74,7 +74,7 @@
        },
        {
            "codeId": "D05ID2",
            "addressIndex": "328",
            "addressIndex": "320",
            "addressLenght": "32",
            "ratio": "1",
            "unit": ""
@@ -372,6 +372,21 @@
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        },
        {
            "codeId": "D03Request",
            "addressIndex": "898",
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        },
        {
            "codeId": "D05Request",
            "addressIndex": "900",
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        }

    ]
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java

@@ -57,13 +57,22 @@
    public static final List<Integer> GLASS_STATE_IN_ALL_ZERO = Arrays.asList(0, 100, 102, 103, 104);

    /**
     * 卧式理片笼详情表玻璃状态
     * 进片任务1
     * 出片任务2
     * 卧离任务类型
     * 空任务 0
     * 进片任务 1
     * 出片任务 2
     * 直通任务 3
     * 进行中 4
     * 结束 5
     * 其他 6
     */
    public static final Integer GLASS_CACHE_TYPE_EMPTY = 0;
    public static final Integer GLASS_CACHE_TYPE_IN = 1;
    public static final Integer GLASS_CACHE_TYPE_OUT = 2;
    public static final Integer GLASS_CACHE_TYPE_THROUGH = 3;
    public static final Integer GLASS_CACHE_TYPE_RUNNING = 4;
    public static final Integer GLASS_CACHE_TYPE_FINISH = 5;
    public static final Integer GLASS_CACHE_TYPE_OTHER = 6;
    public static final List<Integer> GLASS_CACHE_TYPE_OUT_ALL = Arrays.asList(2, 3);

    /**
@@ -185,6 +194,9 @@
     * 原片仓储任务类型
     * 进片任务1
     * 出片任务2
     * 调度任务3
     * 进片请求4
     * 出片请求5
     */
    public static final Integer RAW_GLASS_TASK_TYPE_IN = 1;
    public static final Integer RAW_GLASS_TASK_TYPE_OUT = 2;
@@ -193,9 +205,9 @@
    public static final Integer RAW_GLASS_TASK_TYPE_OUT_REQUEST = 5;

    /**
     * 原片仓储任务类型
     * 进片任务1
     * 出片任务2
     * 原片仓储任务状态
     * 新建0
     * 已完成1
     */
    public static final Integer ENGINEERING_NEW = 0;
    public static final Integer ENGINEERING_RUNNING = 1;
@@ -224,5 +236,13 @@
     */
    public static final List<Integer> RAW_GLASS_DEVICE = Arrays.asList(1, 2, 3);

    /**
     * 原片上片状态
     * 0 新增
     * 100 已完成
     */
    public static final Integer LOAD_RAW_GLASS_NEW = 0;
    public static final Integer LOAD_RAW_GLASS_SUCCESS = 100;


}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassdetails/entity/RawGlassStorageDetails.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassdetails/entity/request/RawGlassRequest.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassdetails/mapper/RawGlassStorageDetailsMapper.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassdetails/service/RawGlassStorageDetailsService.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassdetails/service/impl/RawGlassStorageDetailsServiceImpl.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglassdetails/service/impl/RawGlassStorageDetailsServiceImpl.java
@@ -177,7 +177,7 @@

        List<ReadWriteEntity> list = new ArrayList<>();
        list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
        list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//        list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
        list.add(generateReadWriteEntity("A01-CC.dev.startSlot", startSlot));
        list.add(generateReadWriteEntity("A01-CC.dev.endSlot", endSlot));
        miloService.writeToOpcWord(list);

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassstation/entity/RawGlassStorageStation.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassstation/mapper/RawGlassStorageStationMapper.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglassstation/mapper/RawGlassStorageStationMapper.java
@@ -8,7 +8,7 @@

/**
 * <p>
 *  Mapper 接口
 * Mapper 接口
 * </p>
 *
 * @author wf
@@ -16,5 +16,5 @@
 */
public interface RawGlassStorageStationMapper extends BaseMapper<RawGlassStorageStation> {

  List<RawGlassStorageDetails> listRawGlassDetails();
    List<RawGlassStorageDetails> listRawGlassDetails();
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassstation/service/RawGlassStorageStationService.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglassstation/service/RawGlassStorageStationService.java
@@ -19,12 +19,12 @@

    boolean insertRawGlassStorageStation(RawGlassStorageStation rw);

  /**
   * 获取工位及对应的原片信息
   *
   * @return
   */
  List<RawGlassStorageDetails> listRawGlassDetails();
    /**
     * 获取工位及对应的原片信息
     *
     * @return
     */
    List<RawGlassStorageDetails> listRawGlassDetails();

  boolean updateSlotState(Integer slot, Integer enableState);
    boolean updateSlotState(Integer slot, Integer enableState);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglassstation/service/impl/RawGlassStorageStationServiceImpl.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglassstation/service/impl/RawGlassStorageStationServiceImpl.java
@@ -24,11 +24,12 @@
    public List<RawGlassStorageStation> selectStations() {
        return list();
    }

    @Override
    public boolean updateRawGlassStorageStation(String slot) {
        UpdateWrapper<RawGlassStorageStation> wrapper = new UpdateWrapper<>();  //这个类型定义错了，不应该是tasking
        wrapper.set("slot","105")
                .eq( "slot",slot);
        wrapper.set("slot", "105")
                .eq("slot", slot);
        return update(wrapper);
    }

@@ -44,16 +45,16 @@
        return this.save(rw);
    }

  @Override
  public List<RawGlassStorageDetails> listRawGlassDetails() {
    @Override
    public List<RawGlassStorageDetails> listRawGlassDetails() {
        return baseMapper.listRawGlassDetails();
    }

  @Override
  public boolean updateSlotState(Integer slot, Integer enableState) {
    return update(
        new LambdaUpdateWrapper<RawGlassStorageStation>()
            .set(RawGlassStorageStation::getEnableState, enableState)
            .eq(RawGlassStorageStation::getSlot, slot));
  }
    @Override
    public boolean updateSlotState(Integer slot, Integer enableState) {
        return update(
                new LambdaUpdateWrapper<RawGlassStorageStation>()
                        .set(RawGlassStorageStation::getEnableState, enableState)
                        .eq(RawGlassStorageStation::getSlot, slot));
    }
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/entity/RawGlassStorageTask.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/entity/request/RawGlassTaskRequest.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglasstask/entity/request/RawGlassTaskRequest.java
@@ -8,7 +8,7 @@
import java.util.List;

@Data
public class RawGlassTaskRequest  {
public class RawGlassTaskRequest {

    /**
     * 任务类型   1 入库    2 出库    3 调度

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/mapper/RawGlassStorageTaskMapper.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglasstask/mapper/RawGlassStorageTaskMapper.java
@@ -1,11 +1,11 @@
package com.mes.rawglasstask.mapper;

import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.rawglasstask.entity.RawGlassStorageTask;

/**
 * <p>
 *  Mapper 接口
 * Mapper 接口
 * </p>
 *
 * @author wf

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/mapper/xml/RawGlassStorageTaskMapper.xml

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/service/RawGlassStorageTaskService.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/rawglasstask/service/impl/RawGlassRawGlassStorageTaskServiceImpl.java

File was renamed from hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawglasstask/service/impl/RawGlassRawGlassStorageTaskServiceImpl.java
@@ -3,12 +3,12 @@
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.common.utils.RedisUtil;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.entity.request.RawGlassTaskRequest;
import com.mes.rawglasstask.mapper.RawGlassStorageTaskMapper;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import com.mes.tools.DateUtil;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/mapper/UpPattenUsageMapper.java

@@ -9,7 +9,7 @@

/**
 * <p>
 *  Mapper 接口
 * Mapper 接口
 * </p>
 *
 * @author zhoush
@@ -18,4 +18,6 @@
public interface UpPattenUsageMapper extends MPJBaseMapper<UpPattenUsage> {

    List<UpPattenUsageVO> queryRawGlassByEngineeringId(@Param("engineeringId") String engineerId);

    List<Integer> queryFinishByEngineering(@Param("stationCell") Integer deviceId, @Param("finishCount") int finishCount);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/utils/RedisUtil.java

File was renamed from hangzhoumesParent/common/springsecurity/src/main/java/com/mes/common/utils/RedisUtil.java
@@ -1,4 +1,4 @@
package com.mes.common.utils;
package com.mes.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/RawGlassStorageDetailsMapper.xml

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/RawGlassStorageStationMapper.xml

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/UpPattenUsageMapper.xml

@@ -27,6 +27,14 @@
          and t.state = 0
        ORDER BY t.layout_sequence
    </select>
    <select id="queryFinishByEngineering" resultType="java.lang.Integer">
        SELECT id
        FROM up_patten_usage
        WHERE engineering_id IN (SELECT engineer_id FROM engineering WHERE station_cell = #{stationCell} AND state = 1)
          and state = 0
        order by id
        LIMIT ${finishCount}
    </select>


</mapper>

 hangzhoumesParent/common/springsecurity/src/main/java/com/mes/common/filter/JwtAuthenticationTokenFilter.java

@@ -1,10 +1,10 @@
package com.mes.common.filter;

import com.mes.common.utils.JwtUtil;
import com.mes.common.utils.RedisUtil;
import com.mes.common.utils.UserInfoUtils;
import com.mes.userinfo.entity.LoginUser;
import com.mes.userinfo.service.SysUserService;
import com.mes.utils.RedisUtil;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

 hangzhoumesParent/common/springsecurity/src/main/java/com/mes/userinfo/service/impl/SysUserServiceImpl.java

@@ -6,7 +6,6 @@
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.common.config.Const;
import com.mes.common.utils.JwtUtil;
import com.mes.common.utils.RedisUtil;
import com.mes.common.utils.UserInfoUtils;
import com.mes.entity.request.GeneralRequest;
import com.mes.menu.mapper.SysMenuMapper;
@@ -21,6 +20,7 @@
import com.mes.userinfo.mapper.SysUserRoleMapper;
import com.mes.userinfo.service.SysUserRoleService;
import com.mes.userinfo.service.SysUserService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/service/impl/EdgGlassTaskInfoServiceImpl.java

@@ -4,12 +4,12 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.common.utils.RedisUtil;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.entity.request.EdgGlassInfoRequest;
import com.mes.edgglasstask.mapper.EdgGlassTaskInfoMapper;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.tools.DateUtil;
import com.mes.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstaskqueueinfo/entity/EdgGlassTaskQueueInfo.java

New file
@@ -0,0 +1,51 @@
package com.mes.edgglasstaskqueueinfo.entity;

import lombok.Data;

import java.util.Date;

/**
 * (EdgGlassTaskQueueInfo)表实体类
 *
 * @author makejava
 * @since 2024-11-03 15:42:12
 */
@SuppressWarnings("serial")
@Data
public class EdgGlassTaskQueueInfo {
    /**
     * 磨边前玻璃id
     */
    private String glassId;
    /**
     * 宽
     */
    private Integer width;
    /**
     * 高
     */
    private Integer height;
    /**
     * 厚
     */
    private Integer thickness;
    /**
     * 状态
     */
    private Integer state;
    /**
     * 线路
     */
    private Integer line;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;


}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstaskqueueinfo/mapper/EdgGlassTaskQueueInfoDao.java

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

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo;

/**
 * (EdgGlassTaskQueueInfo)表数据库访问层
 *
 * @author makejava
 * @since 2024-11-03 15:42:11
 */
public interface EdgGlassTaskQueueInfoDao extends BaseMapper<EdgGlassTaskQueueInfo> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstaskqueueinfo/service/EdgGlassTaskQueueInfoService.java

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

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo;

/**
 * (EdgGlassTaskQueueInfo)表服务接口
 *
 * @author makejava
 * @since 2024-11-03 15:42:16
 */
public interface EdgGlassTaskQueueInfoService extends IService<EdgGlassTaskQueueInfo> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstaskqueueinfo/service/impl/EdgGlassTaskQueueInfoServiceImpl.java

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

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo;
import com.mes.edgglasstaskqueueinfo.mapper.EdgGlassTaskQueueInfoDao;
import com.mes.edgglasstaskqueueinfo.service.EdgGlassTaskQueueInfoService;
import org.springframework.stereotype.Service;

/**
 * (EdgGlassTaskQueueInfo)表服务实现类
 *
 * @author makejava
 * @since 2024-11-03 15:42:19
 */
@Service
public class EdgGlassTaskQueueInfoServiceImpl extends ServiceImpl<EdgGlassTaskQueueInfoDao, EdgGlassTaskQueueInfo> implements EdgGlassTaskQueueInfoService {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/mapper/EdgStorageCageDetailsMapper.java

@@ -13,4 +13,5 @@
 */
public interface EdgStorageCageDetailsMapper extends MPJBaseMapper<EdgStorageCageDetails> {

    EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/mapper/EdgStorageCageMapper.java

@@ -1,8 +1,8 @@
package com.mes.edgstoragecage.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import org.apache.ibatis.annotations.Param;

/**
 * <p>
@@ -14,4 +14,14 @@
 */
public interface EdgStorageCageMapper extends MPJBaseMapper<EdgStorageCage> {

    /**
     * 相同尺寸可以放下的格子
     *
     * @param deviceId
     * @param width
     * @param height
     * @param slot
     * @return
     */
    EdgStorageCage getEdgStorageCageBySize(@Param("deviceId") int deviceId, @Param("width") double width, @Param("height") double height, @Param("slot") int slot);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/EdgStorageCageDetailsService.java

@@ -78,4 +78,13 @@
     * @return
     */
    boolean inToVerify(String glassId);

    /**
     * 按照尺寸
     *
     * @param width
     * @param height
     * @return
     */
    EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/EdgStorageCageService.java

@@ -26,14 +26,17 @@
    EdgStorageCage selectNearestEmpty(int currentSlot, boolean flag);

    List<EdgStorageCage> selectCacheEmpty();

    /**
     * 查询笼内出片顺序详情
     *
     * @return
     */
    List<Map<String, Object>> selectCacheOut();

    /**
     * 查询笼内详情
     *
     * @return
     */
    List<Map<String, Object>> selectEdgStorageCages();
@@ -55,4 +58,15 @@
     */
    boolean updateEdgStorageCageDetails(int edgStorageCageId, EdgStorageCageDetails edgStorageCageDetails);

    /**
     * 相同尺寸可以放下的格子
     *
     * @param deviceId
     * @param width
     * @param height
     * @param slot
     * @return
     */
    EdgStorageCage getEdgStorageCageBySize(int deviceId, double width, double height, int slot);

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageDetailsServiceImpl.java

@@ -334,22 +334,22 @@
        for (int i = 1; i <= groupBy.keySet().size(); i++) {
            String key = i + "";
            if (key != null) {
                List<Map<String, Object>> galssInfo=groupBy.get(key);//当前钢化版图内玻璃小片集合
                if(!galssInfo.isEmpty()){
                    Map<String, Object> item=new HashMap<>();//新格式编排
                List<Map<String, Object>> galssInfo = groupBy.get(key);//当前钢化版图内玻璃小片集合
                if (!galssInfo.isEmpty()) {
                    Map<String, Object> item = new HashMap<>();//新格式编排
                    //以下为同层  {key:"groupBy.get(key)",olLayoutRate:"小片集合"}
                    //          {key:"groupBy.get(key)",olLayoutRate:[{},{},{},{}]}


                    item.put("listGlass",groupBy.get(key));
                    item.put("LayoutId",key);
                    item.put("olWidth",galssInfo.get(0).get("olWidth").toString());
                    item.put("olHeight",galssInfo.get(0).get("olHeight").toString());
                    item.put("olLayoutRate",galssInfo.get(0).get("olLayoutRate").toString());
                    item.put("listGlass", groupBy.get(key));
                    item.put("LayoutId", key);
                    item.put("olWidth", galssInfo.get(0).get("olWidth").toString());
                    item.put("olHeight", galssInfo.get(0).get("olHeight").toString());
                    item.put("olLayoutRate", galssInfo.get(0).get("olLayoutRate").toString());
                    result.add(item);
                }else{
                    log.info("当前钢化版图不存在小片数据请检查，版图号:{}"+key);
                    return null ;
                } else {
                    log.info("当前钢化版图不存在小片数据请检查，版图号:{}" + key);
                    return null;
                }
            }
        }
@@ -523,4 +523,9 @@
        }
        return false;
    }

    @Override
    public EdgStorageCageDetails queryEdgStorageDetailsBySize(double width, double height) {
        return baseMapper.queryEdgStorageDetailsBySize(width, height);
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageServiceImpl.java

@@ -51,6 +51,7 @@
                        .eq(EdgStorageCageDetails::getSlot, EdgStorageCage::getSlot)
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN))
                .isNull(EdgStorageCageDetails::getSlot)
                .eq(EdgStorageCage::getEnableState, Const.SLOT_ON)
                .last("order by abs(t.slot - " + currentSlot + ")  asc limit 2")
        );
        if (flag && CollectionUtil.isNotEmpty(emptyList)) {
@@ -181,5 +182,10 @@
        return true;
    }

    @Override
    public EdgStorageCage getEdgStorageCageBySize(int deviceId, double width, double height, int slot) {
        return baseMapper.getEdgStorageCageBySize(deviceId, width, height, slot);
    }


}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassTask.java

@@ -1,11 +1,23 @@
package com.mes.job;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.kangaroohy.milo.service.MiloService;
import com.mes.common.config.Const;
import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo;
import com.mes.edgglasstaskqueueinfo.service.EdgGlassTaskQueueInfoService;
import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.service.EdgStorageDeviceTaskService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author : zhoush
@@ -16,14 +28,98 @@
@Slf4j
public class OpcCacheGlassTask {

//    @Autowired
//    MiloService miloService;
//
//    @Autowired
//    SubscriptionCallback cacheGlassSubscriptionCallback;
//
//    @Scheduled(fixedDelay = Long.MAX_VALUE)
//    public void startOpcTask() throws Exception {
//        miloService.subscriptionFromOpcUa(Arrays.asList("my.device.x1", "my.device.x2"), cacheGlassSubscriptionCallback);
//    }
    private static final String EDG_STORAGE_DEVICE_ONE_TASK = "edg_storage_device_one_task";

    private static final String EDG_STORAGE_DEVICE_TWO_TASK = "edg_storage_device_two_task";

    @Autowired(required = false)
    MiloService miloService;


    @Resource(name = "cacheGlassStartCallback")
    SubscriptionCallback cacheGlassStartCallback;

    @Resource(name = "cacheGlassTestCallback")
    SubscriptionCallback cacheGlassTestCallback;

    @Resource
    EdgStorageDeviceTaskService edgStorageDeviceTaskService;
    @Resource
    EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService;
    private int sum = 0;

    @Scheduled(fixedDelay = 10)
    public void startOpcTask() throws Exception {
//        miloService.subscriptionFromOpcUa(Arrays.asList("C101-WL.S7-1200.plc_task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassStartCallback);
//        miloService.subscriptionFromOpcUa(Arrays.asList("mes.dec.edg_storage_device_one_task[1].task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassTestCallback);
//        log.info("--------------------s---------------------------");
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task");
        try {
            if (task == null) {
                log.info("任务表基础数据录入失败，请检查数据是否录入成功");
                return;
            }
            if (task.getTaskState() == sum) {
                return;
            }
            sum = task.getTaskState();
            task.setTaskRunning(sum);
            log.info("当前第{}次执行", task.getTaskRunning());
//            task.setTaskState(task.getTaskRunning());
            edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task);
        } catch (Exception e) {
            log.info("{}", e.getMessage());
        }
    }

//    mesControlWord glassId
//    width height
//    thickness             filmRemove
//    deviceControlWord             deviceWarnState

    //    @Scheduled(fixedDelay = 1000)
    public void edgOpcTask() throws Exception {
        ReadWriteEntity controlEntity = miloService.readFromOpcUa("A001-MB1.dev.deviceControlWord");
        String deviceControlWord = (String) controlEntity.getValue();
        if ("0".equals(deviceControlWord)) {
            ReadWriteEntity messageEntity = miloService.readFromOpcUa("A001-MB1.dev.mesControlWord");
            String messageValue = (String) messageEntity.getValue();
            if ("1".equals(messageValue)) {
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("A001-MB1.dev.mesControlWord", 0));
                miloService.writeToOpcWord(list);
            }
            log.info("当前未收到磨边机的请求任务");
            return;
        }
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_ONE_TASK);
        String glassId = task.getGlassId();
        if (StringUtils.isBlank(glassId)) {
            log.info("磨边前的架子没有玻璃信息");
            return;
        }
        //获取磨边对列
        EdgGlassTaskQueueInfo edgInfo = edgGlassTaskQueueInfoService.getOne(new LambdaQueryWrapper<EdgGlassTaskQueueInfo>()
                .eq(EdgGlassTaskQueueInfo::getGlassId, glassId)
                .eq(EdgGlassTaskQueueInfo::getState, Const.GLASS_STATE_NEW));
        if (edgInfo == null) {
            log.info("对列表中的玻璃id错误，请检查数据，玻璃id：{}", glassId);
            return;
        }
        List<ReadWriteEntity> list = new ArrayList<>();
        list.add(generateReadWriteEntity("A001-MB1.dev.mesControlWord", 1));
        list.add(generateReadWriteEntity("A001-MB1.dev.glassId", glassId));
        list.add(generateReadWriteEntity("A001-MB1.dev.width", edgInfo.getWidth()));
        list.add(generateReadWriteEntity("A001-MB1.dev.height", edgInfo.getHeight()));
        list.add(generateReadWriteEntity("A001-MB1.dev.thickness", edgInfo.getThickness()));
        list.add(generateReadWriteEntity("A001-MB1.dev.filmRemove", 0));
        miloService.writeToOpcWord(list);
    }

    private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) {
        ReadWriteEntity readWriteEntity = new ReadWriteEntity();
        readWriteEntity.setIdentifier(identifier);
        readWriteEntity.setValue(value);
        return readWriteEntity;
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassStartCallback.java

New file
@@ -0,0 +1,441 @@
package com.mes.job.opccallback;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.mes.common.config.Const;
import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo;
import com.mes.edgglasstaskqueueinfo.service.EdgGlassTaskQueueInfoService;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
import com.mes.edgstoragecage.service.EdgStorageCageDetailsService;
import com.mes.edgstoragecage.service.EdgStorageCageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import com.mes.opctask.service.EdgStorageDeviceTaskService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2024/10/10 14:13
 * @Description:
 */
@Service
@Slf4j
public class CacheGlassStartCallback implements SubscriptionCallback {

    private static final String EDG_STORAGE_DEVICE_ONE_TASK = "edg_storage_device_one_task";

    private static final String EDG_STORAGE_DEVICE_TWO_TASK = "edg_storage_device_two_task";

    @Resource
    EdgStorageDeviceTaskService edgStorageDeviceTaskService;
    @Resource
    GlassInfoService glassInfoService;
    @Resource
    EdgStorageCageDetailsService edgStorageCageDetailsService;
    @Resource
    EdgStorageCageService edgStorageCageService;
    @Resource
    EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService;

    @Resource
    EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService;

    @Value("${mes.glassGap}")
    private int glassGap;
    @Value("${mes.threshold}")
    private int threshold;
    @Value("${mes.cellLength}")
    private int cellLength;

    @Override
    public void onSubscribe(String identifier, Object value) {
        log.info("当前正在执行的任务为{}", value);
        String tableName = identifier.contains("edg_storage_device_one_task") ? EDG_STORAGE_DEVICE_ONE_TASK : EDG_STORAGE_DEVICE_TWO_TASK;
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName);
        try {
            if (task == null) {
                log.info("任务表基础数据录入失败，请检查数据是否录入成功");
                return;
            }
            int request = task.getTaskState();
            log.info("开始执行任务，任务请信息为{}", task);
            if (request == 0) {
                log.info("未收到任务请求，结束本次任务");
            } else if (request == 1) {
                //进片任务
                intoTask(task, tableName);
            } else if (request == 2) {
                //出片任务
                outTask(task, tableName);
            } else if (request == 3) {
                //直通任务
                if (!outTask(task, tableName)) {
                    intoTask(task, tableName);
                }
            } else if (request == 4) {
                log.info("将启动子改为0");
                task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING);
                edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
            } else {
                finishTask(task, tableName);
            }
        } catch (Exception e) {
            log.info("执行任务过程中发生异常，任务字{}，{}", task.getTaskState(), e.getMessage());
            log.info("将启动子改为0");
            task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY);
            edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        }
    }

    private boolean intoTask(EdgStorageDeviceTask task, String tableName) {
        //获取玻璃的基本信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
        if (null == glassInfo) {
            log.info("进片玻璃信息不存在，玻璃id:{}", task.getGlassIdIn());
            return Boolean.FALSE;
        }
        //获取当前进片玻璃id和进片格子  相同尺寸可以放下的格子
        EdgStorageCage edgStorageCage = edgStorageCageService.getEdgStorageCageBySize(1, glassInfo.getWidth(), glassInfo.getHeight(), task.getCurrentCell());
        if (edgStorageCage == null) {
            log.info("相同尺寸可以放下的格子未找到，格子id:{}", task.getCurrentCell());
//            SELECT * from edg_storage_cage where device_id = 1 and remain_width > 1000 order by abs(slot - 10)
            List<EdgStorageCage> storageCageList = edgStorageCageService.list(new LambdaQueryWrapper<EdgStorageCage>().eq(EdgStorageCage::getDeviceId, 1)
                    .eq(EdgStorageCage::getEnableState, Const.SLOT_ON)
                    .ge(EdgStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight())).last("order by abs(slot - " + task.getCurrentCell() + ")"));
//            //直通任务
//            if (flag && CollectionUtil.isNotEmpty(emptyList)) {
//                return emptyList.get(0);
//            }
            if (CollectionUtil.isEmpty(storageCageList) || storageCageList.size() == 1) {
                log.info("没有多余的空格子");
                return Boolean.FALSE;
            }
            edgStorageCage = storageCageList.get(0);
        }
        log.info("4、将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
        EdgStorageCageDetails details = new EdgStorageCageDetails();
        BeanUtils.copyProperties(glassInfo, details);
        details.setState(Const.GLASS_STATE_IN);
        details.setSlot(edgStorageCage.getSlot());
        details.setDeviceId(edgStorageCage.getDeviceId());
        edgStorageCageDetailsService.save(details);

        //更新任务信息
        task.setStartCell(edgStorageCage.getSlot());
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_IN);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        saveHistoryTask(task);
        return Boolean.TRUE;
    }

    private boolean outTask(EdgStorageDeviceTask task, String tableName) {
        EdgStorageCageDetails edgStorageCageDetails = null;
        //笼内是版图相差是否超过阈值
        boolean flag = queryMaxMinDiff(threshold);
        if (flag) {
            EdgStorageCageDetails minEdgDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                    .inSql(EdgStorageCageDetails::getSlot, "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON)
                    .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId)
                    .orderBy(Boolean.TRUE, Boolean.TRUE, EdgStorageCageDetails::getTemperingFeedSequence)
                    .last("limit 1"));
//            select * from edg_storage_cage_details where width = 551 and height = 1151 and id in (select min(id ) from edg_storage_cage_details where state = 100 group by slot )
            edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getWidth, minEdgDetails.getWidth())
                    .eq(EdgStorageCageDetails::getHeight, minEdgDetails.getHeight())
                    .inSql(EdgStorageCageDetails::getId, "select min(id) from edg_storage_cage_details where state = 100 group by slot ")
                    .last("order by abs(slot - " + task.getCurrentCell() + ")  asc limit 1")
            );
            //给直通任务
            if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) {
                GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getGlassId, task.getGlassIdIn())
                        .eq(GlassInfo::getWidth, minEdgDetails.getWidth())
                        .eq(GlassInfo::getHeight, minEdgDetails.getHeight()));
                if (null != glassInInfo) {
                    edgStorageCageDetails = new EdgStorageCageDetails();
                    BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails);
                }
            }
            if (null == edgStorageCageDetails) {
                edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(EdgStorageCageDetails::getSlot, minEdgDetails.getSlot())
                        .orderByAsc(EdgStorageCageDetails::getId)
                        .last("limit 1")
                );
            }
        }
        if (null == edgStorageCageDetails) {
            //        获取上次任务
//        获取历史表中上次任务最后一片尺寸
            EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
                    .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS)
                    .in(EdgStorageDeviceTaskHistory::getTaskType, Const.GLASS_CACHE_TYPE_OUT, Const.GLASS_CACHE_TYPE_THROUGH)
                    .orderByDesc(EdgStorageDeviceTaskHistory::getId).last("limit 1"));
            if (null != edgeData) {
                GlassInfo glassOutInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, edgeData.getGlassIdOut()));
                //笼内的玻璃的尺寸是否和上一次任务一致
                edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(glassOutInfo.getWidth(), glassOutInfo.getHeight());
                if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) {
                    GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getGlassId, task.getGlassIdIn())
                            .eq(GlassInfo::getWidth, glassOutInfo.getWidth())
                            .eq(GlassInfo::getHeight, glassOutInfo.getHeight()));
                    if (null != glassInInfo) {
                        edgStorageCageDetails = new EdgStorageCageDetails();
                        BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails);
                    }
                }
            }
        }
        if (null == edgStorageCageDetails) {
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(0, 0);
        }
        if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) {
            //和上次任务不存在相同尺寸
            GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
            edgStorageCageDetails = new EdgStorageCageDetails();
            BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails);
        }
        if (edgStorageCageDetails == null) {
            //和上次任务不存在相同尺寸
            log.info("笼内没有玻璃了");
            return Boolean.FALSE;
        }
        int taskType = Const.GLASS_CACHE_TYPE_OUT;
        String glassId = edgStorageCageDetails.getGlassId();
        if (glassId.equals(task.getGlassIdIn())) {
            log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails);
            //玻璃信息替换
            String glassIdChange = queryAndChangeGlass(glassId);
            if (StringUtils.isNotBlank(glassIdChange)) {
                edgStorageCageDetails = new EdgStorageCageDetails();
                GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
                BeanUtils.copyProperties(one, edgStorageCageDetails);
            }
            EdgStorageCage storageCage = edgStorageCageService.getOne(new LambdaQueryWrapper<EdgStorageCage>().eq(EdgStorageCage::getDeviceId, 1)
                    .eq(EdgStorageCage::getEnableState, Const.SLOT_ON)
                    .ge(EdgStorageCage::getRemainWidth, cellLength).last("order by abs(slot - " + task.getCurrentCell() + ")")
                    .last("limit 1"));
            Assert.isTrue(null != storageCage, "格子已满,无法执行直通任务");
            log.info("3、查询卧式理片笼里面的空格:{}", storageCage);
            edgStorageCageDetails.setSlot(storageCage.getSlot());
            edgStorageCageDetails.setState(Const.GLASS_STATE_OUT);
            edgStorageCageDetailsService.save(edgStorageCageDetails);
            taskType = Const.GLASS_CACHE_TYPE_THROUGH;
        } else {
            log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails);
            if (!edgStorageCageDetails.getSlot().equals(task.getCurrentCell())) {
                EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(EdgStorageCageDetails::getSlot, task.getCurrentCell()).eq(EdgStorageCageDetails::getWidth, edgStorageCageDetails.getWidth())
                        .eq(EdgStorageCageDetails::getHeight, edgStorageCageDetails.getHeight()).eq(EdgStorageCageDetails::getThickness, edgStorageCageDetails.getThickness())
                );
                if (null != currentGlass) {
                    edgStorageCageDetails = currentGlass;
                }
            }
            //玻璃信息替换
            String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId());
            //处理在卧理内的玻璃信息：笼内的数据处理
            queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange);
            LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>();
            wrapper.eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT);
            edgStorageCageDetailsService.update(wrapper);
            log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);
        }

        //玻璃信息替换
//        String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId());
        //处理在卧理内的玻璃信息：笼内的数据处理
//        queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange);
        //生成出片任务
        task.setGlassIdOut(edgStorageCageDetails.getGlassId());
        task.setStartCell(edgStorageCageDetails.getSlot());
        task.setTaskRunning(taskType);
        task.setWidth((int) edgStorageCageDetails.getWidth() * 10);
        task.setHeight((int) edgStorageCageDetails.getHeight() * 10);
        task.setThickness((int) edgStorageCageDetails.getThickness() * 10);
        task.setFilmRemove(0);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        saveHistoryTask(task);
        //更新详情表任务出片中
        edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()));
        //todo:磨边对列表新增一条数据
        EdgGlassTaskQueueInfo edgInfo = new EdgGlassTaskQueueInfo();
        BeanUtils.copyProperties(task, edgInfo);
        edgInfo.setState(Const.GLASS_STATE_NEW);
        edgGlassTaskQueueInfoService.save(edgInfo);
        return Boolean.TRUE;
    }

    private boolean finishTask(EdgStorageDeviceTask task, String tableName) {
        log.info("当前任务信息为：{}", task);
        if (task.getTaskState() <= 4) {
            log.info("有正在执行的任务，结束");
            return Boolean.FALSE;
        }
        Integer cell = task.getStartCell();
        Integer state = task.getTaskState();
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
//        task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setGlassIdOut("");
        task.setStartCell(0);
        task.setWidth(0);
        task.setHeight(0);
        task.setThickness(0);
        task.setFilmRemove(0);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>()
                .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .set(EdgStorageDeviceTaskHistory::getTaskState,
                        Const.GLASS_CACHE_TYPE_FINISH.equals(state) ? Const.RAW_GLASS_TASK_SUCCESS : Const.RAW_GLASS_TASK_FAILURE)
        );
        updateCellRemainWidth(cell);
        return Boolean.TRUE;
    }

    /**
     * 查询玻璃并进行交换
     *
     * @param glassId
     * @return
     */
    public String queryAndChangeGlass(String glassId) {
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
//                .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1"));
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");        //按照玻璃尺寸
        LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getWidth, glassInfo.getWidth())
                .eq(GlassInfo::getHeight, glassInfo.getHeight())
                .eq(GlassInfo::getThickness, glassInfo.getThickness())
                .eq(GlassInfo::getFilmsid, glassInfo.getFilmsid())
                .eq(GlassInfo::getFlowCardId, glassInfo.getFlowCardId())
                .eq(GlassInfo::getTotalLayer, glassInfo.getTotalLayer())
                .eq(GlassInfo::getLayer, glassInfo.getLayer())
                .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                .notInSql(GlassInfo::getGlassId, "select distinct glass_id from edg_storage_cage_details " +
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight()
                        + " and state != 100")
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, Boolean.TRUE, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");
        GlassInfo swapGlassInfo = glassInfoService.getOne(queryWrapper);
        if (swapGlassInfo != null && !glassInfo.getGlassId().equals(swapGlassInfo.getGlassId())) {
            String swapGlassId = swapGlassInfo.getGlassId();
            log.info("将玻璃{}和玻璃{}，信息互换,进玻璃 {}", glassInfo, swapGlassInfo, swapGlassInfo);
            swapGlassInfo.setGlassId(glassId);
            glassInfo.setGlassId(swapGlassId);
            glassInfoService.updateById(swapGlassInfo);
            glassInfoService.updateById(glassInfo);
            return swapGlassId;
        }
        return "";
    }


    /**
     * 查询卧式理片玻璃并进行交换
     *
     * @param glassId
     * @return
     */
    public void queryEdgAndChangeGlass(String glassId, String swapGlassId) {
        if (StringUtils.isBlank(swapGlassId)) {
            log.info("当前出笼玻璃不存在需要替换的玻璃");
            return;
        }
        //获取待出笼的玻璃
        EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
//        获取待出笼的玻璃需要替换的玻璃信息
        EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));

//      玻璃小片表中玻璃已经替换，更新卧理笼内现有的准备出笼的玻璃信息，
        if (null == swapGlassDetailInfo) {
            GlassInfo glassInfoBase = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                    .eq(GlassInfo::getGlassId, glassId));
            //需要替换的玻璃为存进卧理，仅需更新当前需要出笼的玻璃信息即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getGlassId, glassId)
                    .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfoBase.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfoBase.getTemperingFeedSequence()));
        } else {
            //需要替换的玻璃都在卧理内，按照玻璃id对调玻璃信息：对调玻璃id即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, glassInfo.getId())
                    .set(EdgStorageCageDetails::getTemperingLayoutId, swapGlassDetailInfo.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, swapGlassDetailInfo.getTemperingFeedSequence())
            );
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId())
                    .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence())
            );
        }
    }

    /**
     * 获取详情表内最大最小版图id的差值，判断是否出最小版图玻璃
     *
     * @return
     */
    public boolean queryMaxMinDiff(int threshold) {
        //获取笼子内最大版图id和最小版图id插值，判断是否大于阈值，大于阈值直接出最小版图玻璃
        QueryWrapper<EdgStorageCageDetails> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("max(tempering_layout_id)-min(tempering_layout_id) as diff")
                .eq("state", Const.GLASS_STATE_IN)
                .inSql("slot", "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON);
        List<Object> list = edgStorageCageDetailsService.listObjs(queryWrapper);
        //获取笼内玻璃版图差值是否大于阈值
        if (CollectionUtil.isNotEmpty(list)) {
            Long diff = (Long) list.get(0);
            return diff > threshold;
        } else {
            return Boolean.FALSE;
        }
    }

    public boolean saveHistoryTask(EdgStorageDeviceTask task) {
        EdgStorageDeviceTaskHistory taskHistory = new EdgStorageDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
        taskHistory.setTaskType(task.getTaskRunning());
        taskHistory.setCreateTime(new Date());
        taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW);
        edgStorageDeviceTaskHistoryService.save(taskHistory);
        return Boolean.TRUE;
    }

    private boolean updateCellRemainWidth(int slot) {
        List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, slot)
                .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
        int remainWidth = cellLength;
        if (CollectionUtil.isNotEmpty(list)) {
            int widthTotal = (int) list.stream().map(e -> Math.max(e.getWidth(), e.getHeight()) + glassGap).mapToDouble(Double::intValue).sum();
            remainWidth = cellLength - widthTotal >= 0 ? cellLength - widthTotal : 0;
        }
        edgStorageCageService.update(new LambdaUpdateWrapper<EdgStorageCage>().
                set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot));
        return Boolean.TRUE;
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassTestCallback.java

New file
@@ -0,0 +1,38 @@
package com.mes.job.opccallback;

import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.service.EdgStorageDeviceTaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author : zhoush
 * @Date: 2024/10/10 14:13
 * @Description:
 */
@Service
@Slf4j
public class CacheGlassTestCallback implements SubscriptionCallback {
    @Resource
    EdgStorageDeviceTaskService edgStorageDeviceTaskService;

    @Override
    public void onSubscribe(String identifier, Object value) {
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task");
        try {
            if (task == null) {
                log.info("任务表基础数据录入失败，请检查数据是否录入成功");
                return;
            }
            task.setTaskRunning(task.getTaskRunning() + 1);
            log.info("当前第{}次执行", task.getTaskRunning());
//            task.setTaskState(task.getTaskRunning());
            edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task);
        } catch (Exception e) {
            log.info("{}", e.getMessage());
        }
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opccallback/CacheGlassSubscriptionCallback.java

File was deleted

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/controller/EdgStorageDeviceController.java

New file
@@ -0,0 +1,9 @@
package com.mes.opctask.controller;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:35
 * @Description:
 */
public class EdgStorageDeviceController {
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/controller/EdgStorageDeviceTaskHistoryController.java

New file
@@ -0,0 +1,86 @@
package com.mes.opctask.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import com.mes.utils.Result;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.List;

/**
 * (EdgStorageDeviceTaskHistory)表控制层
 *
 * @author makejava
 * @since 2024-10-27 21:04:29
 */
@RestController
@RequestMapping("edgStorageDeviceTaskHistory")
public class EdgStorageDeviceTaskHistoryController {
    /**
     * 服务对象
     */
    @Resource
    private EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService;

    /**
     * 分页查询所有数据
     *
     * @param page                        分页对象
     * @param edgStorageDeviceTaskHistory 查询实体
     * @return 所有数据
     */
    @GetMapping
    public Result selectAll(Page<EdgStorageDeviceTaskHistory> page, EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.page(page, new QueryWrapper<>(edgStorageDeviceTaskHistory)));
    }

    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("{id}")
    public Result selectOne(@PathVariable Serializable id) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.getById(id));
    }

    /**
     * 新增数据
     *
     * @param edgStorageDeviceTaskHistory 实体对象
     * @return 新增结果
     */
    @PostMapping
    public Result insert(@RequestBody EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.save(edgStorageDeviceTaskHistory));
    }

    /**
     * 修改数据
     *
     * @param edgStorageDeviceTaskHistory 实体对象
     * @return 修改结果
     */
    @PutMapping
    public Result update(@RequestBody EdgStorageDeviceTaskHistory edgStorageDeviceTaskHistory) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.updateById(edgStorageDeviceTaskHistory));
    }

    /**
     * 删除数据
     *
     * @param idList 主键结合
     * @return 删除结果
     */
    @DeleteMapping
    public Result delete(@RequestParam("idList") List<Long> idList) {
        return Result.success(this.edgStorageDeviceTaskHistoryService.removeByIds(idList));
    }
}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/EdgStorageDeviceTask.java

New file
@@ -0,0 +1,76 @@
package com.mes.opctask.entity;

import lombok.Data;

import java.util.Date;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 10:22
 * @Description:
 */
@Data
public class EdgStorageDeviceTask {

    /**
     * 任务请求 0无任务 1进片 2出片 3直通
     */
    private Integer taskRunning;
    /**
     * 磨边前玻璃id
     */
    private String glassId;
    /**
     * 进片玻璃id
     */
    private String glassIdIn;
    /**
     * 出片玻璃id
     */
    private String glassIdOut;
    /**
     * 当前层号
     */
    private Integer currentCell;
    /**
     * 层号
     */
    private Integer startCell;
    /**
     * 预留层号
     */
    private Integer endCell;
    /**
     * 任务状态 0默认空任务 1执行中 2结束任务
     */
    private Integer taskState;
    /**
     * 任务类型
     */
    private Integer taskType;
    /**
     * 宽
     */
    private Integer width;
    /**
     * 高
     */
    private Integer height;
    /**
     * 厚
     */
    private Integer thickness;
    /**
     * 是否除膜
     */
    private Integer filmRemove;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/EdgStorageDeviceTaskHistory.java

New file
@@ -0,0 +1,63 @@
package com.mes.opctask.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;

import java.util.Date;

/**
 * (EdgStorageDeviceTaskHistory)表实体类
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
@SuppressWarnings("serial")
@Data
public class EdgStorageDeviceTaskHistory extends Model<EdgStorageDeviceTaskHistory> {
    /**
     * 工程表id
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    /**
     * 进片玻璃id
     */
    private String glassIdIn;
    /**
     * 出片玻璃id
     */
    private String glassIdOut;
    /**
     * 当前层号
     */
    private Integer currentCell;
    /**
     * 层号
     */
    private Integer startCell;
    /**
     * 预留层号
     */
    private Integer endCell;
    /**
     * 任务状态 0默认空任务 1 进片 2出片 3 直通 4执行中 5结束任务 6其他
     */
    private Integer taskState;
    /**
     * 任务状态 0默认空任务 1 进片 2出片 3 直通 4执行中 5结束任务 6其他
     */
    private Integer taskType;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;


}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/mapper/EdgStorageDeviceTaskHistoryMapper.java

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

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;

/**
 * (EdgStorageDeviceTaskHistory)表数据库访问层
 *
 * @author makejava
 * @since 2024-10-27 21:04:29
 */
public interface EdgStorageDeviceTaskHistoryMapper extends BaseMapper<EdgStorageDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/mapper/EdgStorageDeviceTaskMapper.java

New file
@@ -0,0 +1,16 @@
package com.mes.opctask.mapper;

import com.mes.opctask.entity.EdgStorageDeviceTask;
import org.apache.ibatis.annotations.Param;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:39
 * @Description:
 */
public interface EdgStorageDeviceTaskMapper {

    EdgStorageDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") EdgStorageDeviceTask edgStorageDeviceTask);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/EdgStorageDeviceTaskHistoryService.java

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

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;

/**
 * (EdgStorageDeviceTaskHistory)表服务接口
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
public interface EdgStorageDeviceTaskHistoryService extends IService<EdgStorageDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/EdgStorageDeviceTaskService.java

New file
@@ -0,0 +1,21 @@
package com.mes.opctask.service;

import com.mes.opctask.entity.EdgStorageDeviceTask;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:35
 * @Description:
 */
public interface EdgStorageDeviceTaskService {

    /**
     * 查询任务信息
     *
     * @return
     */
    EdgStorageDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(String tableName, EdgStorageDeviceTask edgStorageDeviceTask);

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/impl/EdgStorageDeviceTaskHistoryServiceImpl.java

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

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.mapper.EdgStorageDeviceTaskHistoryMapper;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import org.springframework.stereotype.Service;

/**
 * (EdgStorageDeviceTaskHistory)表服务实现类
 *
 * @author makejava
 * @since 2024-10-27 21:04:33
 */
@Service("edgStorageDeviceTaskHistoryService")
public class EdgStorageDeviceTaskHistoryServiceImpl extends ServiceImpl<EdgStorageDeviceTaskHistoryMapper, EdgStorageDeviceTaskHistory> implements EdgStorageDeviceTaskHistoryService {

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/service/impl/EdgStorageDeviceTaskServiceImpl.java

New file
@@ -0,0 +1,33 @@
package com.mes.opctask.service.impl;

import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.mapper.EdgStorageDeviceTaskMapper;
import com.mes.opctask.service.EdgStorageDeviceTaskService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author : zhoush
 * @Date: 2024/10/24 15:36
 * @Description:
 */
@Service
public class EdgStorageDeviceTaskServiceImpl implements EdgStorageDeviceTaskService {
//    @Override
//    public void updateTaskMessage(Integer slot, Integer taskRunning, String glassIdOut) {

    //    }
    @Resource
    EdgStorageDeviceTaskMapper edgStorageDeviceTaskMapper;

    @Override
    public EdgStorageDeviceTask queryTaskMessage(String tableName) {
        return edgStorageDeviceTaskMapper.queryTaskMessage(tableName);
    }

    @Override
    public boolean updateTaskMessage(String tableName, EdgStorageDeviceTask edgStorageDeviceTask) {
        return edgStorageDeviceTaskMapper.updateTaskMessage(tableName, edgStorageDeviceTask);
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/application.yml

@@ -8,6 +8,11 @@
    name: cacheGlass
  liquibase:
    enabled: false
  task:
    scheduling:
      pool:
        size: 10
      thread-name-prefix: task-cache
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
#  configuration:
@@ -28,6 +33,8 @@
    two: #第二条磨边线的最小尺寸信息
      firstLength: 400
      secondLength: 400
  glassGap: 300
  cellLength: 2700
  sequence:
    order: false
kangaroohy:
@@ -36,7 +43,8 @@
    primary: default
    config:
      default:
        endpoint: opc.tcp://zidonghua:49320
        endpoint: opc.tcp://192.168.10.241:49320
        security-policy: basic256sha256
        username: zsh
        username: liu
        password: 1qaz2wsx3edc4rfv


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageCageDetailsMapper.xml

New file
@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.edgstoragecage.mapper.EdgStorageCageDetailsMapper">

    <resultMap id="baseMap" type="com.mes.edgstoragecage.entity.EdgStorageCageDetails">
        <id column="id" property="id"/>
        <result column="engineer_id" property="engineerId"/>
        <result column="device_id" property="deviceId"/>
        <result column="slot" property="slot"/>
        <result column="glass_id" property="glassId"/>
        <result column="sequence" property="sequence"/>
        <result column="flow_card_id" property="flowCardId"/>
        <result column="glass_type" property="glassType"/>
        <result column="width" property="width"/>
        <result column="height" property="height"/>
        <result column="thickness" property="thickness"/>
        <result column="edg_width" property="edgWidth"/>
        <result column="edg_height" property="edgHeight"/>
        <result column="tempering_layout_id" property="temperingLayoutId"/>
        <result column="tempering_feed_sequence" property="temperingFeedSequence"/>
        <result column="pattern_sequence" property="patternSequence"/>
        <result column="state" property="state"/>
        <result column="gap" property="gap"/>
        <result column="glass_count" property="count"/>
    </resultMap>

    <select id="queryEdgStorageDetailsBySize" resultMap="baseMap">
        with min_id_temp as (
        select slot, min(id) as id, count(*) as glass_count
        from edg_storage_cage_details
        where state = 100
        group by slot
        ),
        size_max_temp as (
        select width, height, count(*) as total_count
        from edg_storage_cage_details t
        inner join min_id_temp t1 on t.id = t1.id
        group by width, height
        ),
        slot_temp as (
        select t.*, t1.glass_count
        from edg_storage_cage_details t
        inner join min_id_temp t1 on t.id = t1.id
        inner join size_max_temp t2 on t.width = t2.width and t.height = t2.height
        <where>
            <if test="width != 0">
                and t.width = #{width}
            </if>
            <if test="height != 0">
                and t.height = #{height}
            </if>
        </where>
        order by total_count desc, glass_count, abs(t.slot - 10)
        )
        select *
        from slot_temp limit 1
    </select>
</mapper>

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageCageMapper.xml

New file
@@ -0,0 +1,26 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.edgstoragecage.mapper.EdgStorageCageMapper">

    <resultMap id="baseMap" type="com.mes.edgstoragecage.entity.EdgStorageCage">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="device_id" property="deviceId" jdbcType="INTEGER"/>
        <result column="slot" property="slot" jdbcType="INTEGER"/>
        <result column="enable_state" property="enableState" jdbcType="INTEGER"/>
        <result column="remain_width" property="remainWidth" jdbcType="INTEGER"/>
    </resultMap>

    <select id="getEdgStorageCageBySize" resultMap="baseMap">
        select t.*
        from edg_storage_cage t
                 left join edg_storage_cage_details t1 on t.slot = t1.slot
        where t.device_id = #{deviceId}
          and t1.state = 100
          and t.remain_width >= #{width}
          and t1.width = #{width}
          and t1.height = #{height}
          and t.enable_state = 1
        order by abs(t.slot - #{slot})
        limit 1
    </select>
</mapper>

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageDeviceTaskMapper.xml

New file
@@ -0,0 +1,42 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.mes.opctask.mapper.EdgStorageDeviceTaskMapper">

    <resultMap id="baseMap" type="com.mes.opctask.entity.EdgStorageDeviceTask">
        <id column="task_running" property="taskRunning"/>
        <id column="glass_id_in" property="glassIdIn"/>
        <id column="glass_id_out" property="glassIdOut"/>
        <id column="current_cell" property="currentCell"/>
        <id column="start_cell" property="startCell"/>
        <id column="enc_cell" property="endCell"/>
        <id column="task_state" property="taskState"/>
        <id column="create_time" property="createTime"/>
        <id column="update_time" property="updateTime"/>
        <id column="width" property="width"/>
        <id column="height" property="height"/>
        <id column="thickness" property="thickness"/>
        <id column="film_remove" property="filmRemove"/>
    </resultMap>

    <select id="queryTaskMessage" resultMap="baseMap">
        select *
        from ${tableName}
        limit 1
    </select>

    <update id="updateTaskMessage">
        UPDATE ${tableName}
        SET task_running = #{task.taskRunning},
        glass_id_out = #{task.glassIdOut},
        current_cell = #{task.currentCell},
        start_cell = #{task.startCell},
        end_cell = #{task.endCell},
        width = #{task.width},
        height = #{task.height},
        thickness = #{task.thickness},
        film_remove = #{task.filmRemove}
        <if test="task.taskState == 0">
            ,task_state = #{task.taskState}
        </if>
    </update>
</mapper>

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/controller/BigStorageCageDetailsController.java

@@ -3,12 +3,11 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.utils.RedisUtil;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java

@@ -2,7 +2,6 @@

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
@@ -21,7 +20,6 @@
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
@@ -31,13 +29,17 @@
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
@@ -310,6 +312,29 @@

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<Integer> deviceUseds =  bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness());
        List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 1, 5)
        );
        List<BigStorageCageDetails> engineerCount2 = baseMapper.selectList(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 6, 8)
        );
        if (engineerCount1.size() > engineerCount2.size()) {
            deviceUsedList.removeIf(device -> device < 6);
        } else {
            deviceUsedList.removeIf(device -> device > 5);
        }
        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }
        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
@@ -381,17 +406,17 @@
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                if ("0".equals(temperingFeedSequence)){
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, "");
                    }
                }else{
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                }
                return true;
            }
        }
            return false;
        return false;
    }



 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageServiceImpl.java

@@ -53,6 +53,9 @@
    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    //进片逻辑
    @Override
    public BigStorageCageDetails feedGlass(GlassInfo glassInfo, BigStorageCageDetails bigStorageCageDetails) {
@@ -226,7 +229,7 @@
        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            double widths = Math.max(bigStorageCageDetails.getWidth(),bigStorageCageDetails.getHeight()) ;
            double widths = Math.max(bigStorageCageDetails.getWidth(), bigStorageCageDetails.getHeight());
            width = width - widths - glassGap;
        }
        //修改格子剩余宽度
@@ -243,9 +246,9 @@
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>();
        wrapper.selectAll(BigStorageCage.class).selectCollection(BigStorageCageDetails.class, BigStorageCage::getBigStorageCageDetails)
                .leftJoin(BigStorageCageDetails.class, on -> on.eq(BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
                        .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL,Const.GLASS_STATE_OUT_ING))
                        .orderByAsc(BigStorageCage::getDeviceId)
                        .orderByAsc(BigStorageCage::getSlot);
                        .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL, Const.GLASS_STATE_OUT_ING))
                .orderByAsc(BigStorageCage::getDeviceId)
                .orderByAsc(BigStorageCage::getSlot);
        return bigStorageCageMapper.selectJoinList(BigStorageCage.class, wrapper);
    }

@@ -256,7 +259,7 @@
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>();
        wrapper.selectAll(BigStorageCage.class).selectCollection(BigStorageCageDetails.class, BigStorageCage::getBigStorageCageDetails)
                .leftJoin(BigStorageCageDetails.class, on -> on.eq(BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
                        .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL,Const.GLASS_STATE_OUT_ING));
                        .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL, Const.GLASS_STATE_OUT_ING));
        List<BigStorageCage> bigStorageCages = bigStorageCageMapper.selectJoinList(BigStorageCage.class, wrapper);
        Map<Integer, List<BigStorageCage>> listMap = bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
        return listMap;
@@ -266,8 +269,7 @@
    @Override
    public List<Map<String, Object>> selectBigStorageCageUsage() {
        QueryWrapper<BigStorageCage> wrapper = new QueryWrapper<>();
        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2)*100 AS percentage,SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")

        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = " + slotWidth + " THEN 1 ELSE 0 END) / COUNT(device_id), 2)*100 AS percentage,SUM(CASE WHEN remain_width = " + slotWidth + " THEN 1 ELSE 0 END) AS count")
                .groupBy("device_id");
        List<Map<String, Object>> bigStorageCageUsages = baseMapper.selectMaps(wrapper);


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/common/S7object.java

@@ -62,12 +62,14 @@
            log.info("大理片笼读取plc数据,开始时间：{}，结束时间：{}，共耗时：{}ms,结束扫码任务", startDate, endDate, endDate.getTime() - startDate.getTime());
            if (getplcvlues != null) {
                PlcMesObject.setPlcParameterList(getplcvlues);
                log.info("大理片当前进卧转立确认字为d01:{},d04:{},进笼送片任务确认字为：d03:{},d05:{},出片任务确认字为{}",
                log.info("大理片当前进卧转立确认字为d01:{},d04:{},进笼送片任务确认字为：d03:{},d05:{},出片任务确认字为{},D03请求字为：{}，D05请求字为：{}",
                        PlcMesObject.getPlcParameter("MESToD01").getValue(),
                        PlcMesObject.getPlcParameter("MESToD04").getValue(),
                        PlcMesObject.getPlcParameter("MESToD03").getValue(),
                        PlcMesObject.getPlcParameter("MESToD05").getValue(),
                        PlcMesObject.getPlcParameter("MESToPLC").getValue());
                        PlcMesObject.getPlcParameter("MESToPLC").getValue(),
                        PlcMesObject.getPlcParameter("D03ToMES").getValue(),
                        PlcMesObject.getPlcParameter("D05ToMES").getValue());
            }
        }
    }

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java

New file
@@ -0,0 +1,295 @@
package com.mes.job;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.kangaroohy.milo.service.MiloService;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author SNG-015
 */
@Component
@Slf4j
public class OpcPlcStorageCageTask {

    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    private GlassInfoService glassInfoService;
    @Resource
    private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
    @Resource
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private EdgGlassTaskInfoService edgGlassTaskInfoService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private DamageService damageService;

    @Autowired(required = false)
    MiloService miloService;

    @Resource(name = "bigStorageStartCallback")
    SubscriptionCallback bigStorageStartCallback;

    @Value("${mes.carWidth}")
    private Integer carWidth;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void startOpcTask() throws Exception {
        //设备一二的进片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback);
    }

    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void outOpcTask() throws Exception {
        //设备1的出片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback);
    }


    @Scheduled(fixedDelay = 300)
    public void updateInGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼进片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和出片任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在进片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .in(BigStorageCageFeedTask::getGlassId, glassIds)
                    .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
            if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass);
                List<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList());
                List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(e, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemainBySlots(inSuccessGlassSlot);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }

        }
        Date endDate = new Date();
        log.info("end:大理片笼进片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    @Scheduled(fixedDelay = 300)
    public void updateOutGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和出片任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
                for (BigStorageCageOutTask bigStorageCageOutTask : outSuccessGlass
                ) {
                    if (bigStorageCageOutTask.getEndSlot().equals(Const.ARTIFICIAL_OUT_TARGET_POSITION)) {
                        temperingGlassInfoService.update(
                                new LambdaUpdateWrapper<TemperingGlassInfo>()
                                        .set(TemperingGlassInfo::getState, Const.TEMPERING_END)
                                        .eq(TemperingGlassInfo::getGlassId, bigStorageCageOutTask.getGlassId())
                        );
                    }
                }
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getStartSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemainBySlots(outSuccessSlotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
        Date endDate = new Date();
        log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    @Scheduled(fixedDelay = 300)
    public void updateScheduleGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼调度完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和调度任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
                    .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION));
            if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) {
                log.info("3、获取调度已完成的玻璃信息id:{}", scheduleSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = scheduleSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getEndSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                List<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds);
                //更新理片笼玻璃尺寸
                List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList());
                slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList()));
                updateSlotRemainBySlots(slotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
        Date endDate = new Date();
        log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    /**
     * 处理破损表任务
     */
    @Scheduled(fixedDelay = 300)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);
        //获取进片任务表中状态为破损的数据
        List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {
            log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageFeedTask.getGlassId());
                damage.setLine(bigStorageCageFeedTask.getLine());
                damage.setWorkingProcedure("磨边");
                damage.setRemark("进笼前卧转立");
                damage.setStatus(1);
                damage.setType(bigStorageCageFeedTask.getTaskState());
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageFeedTask.getTargetSlot());
            }
            //更新格子剩余宽度
            updateSlotRemainBySlots(slotList);
            log.info("进片任务执行完成");
        }
        //获取出片任务表中状态为破损的数据
        List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
            log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            //移除钢化下片表数据
            temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
            //理片笼详情表数据状态删除
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));
            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageOutTask.getGlassId());
                damage.setLine(bigStorageCageOutTask.getEndSlot());
                damage.setWorkingProcedure("钢化");
                damage.setRemark("出片后卧转立");
                damage.setStatus(1);
                damage.setType(bigStorageCageOutTask.getTaskState());
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageOutTask.getStartSlot());
            }
            //更新格子剩余宽度
            updateSlotRemainBySlots(slotList);
            log.info("出片任务执行完成");
        }
        Date endDate = new Date();
        log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
        return;
    }

    public void updateSlotRemainBySlots(List<Integer> slotList) {
        //获取格子内所有的玻璃信息
        List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
        Map<Integer, Double> slotRemainMap = new HashMap<>();
        //是否存在有格子非空的玻璃
        if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
            //存在  将格子内的玻璃分别进行更新
            slotRemainMap = inSlotGlassList.stream()
                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
            slotRemainMap.forEach((e, v) -> {
                double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0;
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, remainWidth)
                        .eq(BigStorageCage::getSlot, e));
            });
        }
        //过滤不存在玻璃的格子 将宽度重置为原始宽度5000
        Set<Integer> remainSlotList = slotRemainMap.keySet();
        slotList.removeAll(remainSlotList);
        if (CollectionUtils.isNotEmpty(slotList)) {
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
                    .in(BigStorageCage::getSlot, slotList));
        }
    }


}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcSlicecage.java

@@ -6,12 +6,12 @@
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.common.utils.RedisUtil;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.WebSocketServer;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcStorageCageTask.java

@@ -127,21 +127,38 @@
        }
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃:  状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， （02玻璃id为空或者卧转立未启动）
        if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            if (!d01GlassId.equals(d01Id)) {
                judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks=bigStorageCageFeedTaskService.list(
              new LambdaQueryWrapper<BigStorageCageFeedTask>()
              .gt(BigStorageCageFeedTask::getTargetSlot,0)
                    .eq(BigStorageCageFeedTask::getLine,Const.A09_OUT_TARGET_POSITION)
                      .eq(BigStorageCageFeedTask::getTaskState,Const.BIG_STORAGE_IN_UP)
            );
            if(CollectionUtils.isEmpty(bigStorageCageFeedTasks)){
                if (!d01GlassId.equals(d01Id)) {
                    judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                            .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
//                d01GlassId = d01Id;
                }
            }
        }
//        状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， 卧转立未启动
        if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
            if (!d04GlassId.equals(d04Id)) {
                judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks=bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .gt(BigStorageCageFeedTask::getTargetSlot,0)
                            .eq(BigStorageCageFeedTask::getLine,Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState,Const.BIG_STORAGE_IN_UP)
            );
            if(CollectionUtils.isEmpty(bigStorageCageFeedTasks)){
                if (!d04GlassId.equals(d04Id)) {
                    judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                            .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
//                d04GlassId = d04Id;
                }
            }

        }
        Date endDate = new Date();
        log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
@@ -180,13 +197,26 @@
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            log.info("卧转立第一次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立第二次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
//        List<Integer> lines=new ArrayList<>();
//        if(REQUEST_WORD.equals(d03ToMES)){
//            lines.add(Const.A09_OUT_TARGET_POSITION);
//        }
//        if(REQUEST_WORD.equals(d05ToMES)){
//            lines.add(Const.A10_OUT_TARGET_POSITION);
//        }
        LambdaQueryWrapper<BigStorageCageFeedTask> wrapper = new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getTaskType, Const.BIG_STORAGE_IN_RUN)
                .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP);
//                .in(BigStorageCageFeedTask::getLine,lines);
        //获取可以启动卧转立的任务线路
        List<BigStorageCageFeedTask> feedTaskList = bigStorageCageFeedTaskService.list(wrapper);
        if (CollectionUtils.isNotEmpty(feedTaskList)) {
@@ -224,6 +254,8 @@
                //获取卧转立剩余宽度
                if (computeIsRun(lineFirst, lineGlassId)) {
                    computeTargetByLine(lineFirst);
                }else{
                    log.info("当前线路：{}，有扫码玻璃：{}",lineFirst,lineGlassId);
                }
            }
            Date endDate = new Date();
@@ -581,20 +613,26 @@
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
//        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
//        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        String d03ToMES = plcParameterObject.getPlcParameter("D03Request").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05Request").getValue();
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            log.info("地址：{}写入0",mesD01Address);
            S7object.getinstance().plccontrol.writeWord(mesD01Address, 0);
        }
        if (!REQUEST_WORD.equals(d04ToMES)) {
            log.info("地址：{}写入0",mesD04Address);
            S7object.getinstance().plccontrol.writeWord(mesD04Address, 0);
        }
        if (!REQUEST_WORD.equals(d03ToMES)) {
            log.info("地址：{}写入0",mesD03Address);
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
        }
        if (!REQUEST_WORD.equals(d05ToMES)) {
            log.info("地址：{}写入0",mesD05Address);
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
        }
    }
@@ -605,6 +643,8 @@
    @Scheduled(fixedDelay = 300)
    public void feedStatusUpdate() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        List<String> glassIds1 = new ArrayList<>();
        List<String> glassIds2 = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
@@ -633,12 +673,15 @@
                    .filter(glassIds1::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            log.info("D3id{},匹配id:{}",glassIds1,matchingIds1);
            if(CollectionUtils.isNotEmpty(matchingIds1)){
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
                                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                                .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                );
            }
        }
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2) && CollectionUtils.isNotEmpty(glassIds2)) {
            List<String> matchingIds2 = bigStorageCageFeedTasks2.stream()
@@ -646,14 +689,19 @@
                    .filter(glassIds2::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            log.info("D5id{},匹配id:{}",glassIds2,matchingIds2);
            if(CollectionUtils.isNotEmpty(matchingIds2)){
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
                                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                                .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                );
            }
        }
        if (CollectionUtils.isEmpty(glassIds1)) {
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
            log.info("{}线修改玻璃状态为3",Const.A09_OUT_TARGET_POSITION);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
@@ -664,6 +712,8 @@
            );
        }
        if (CollectionUtils.isEmpty(glassIds2)) {
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
            log.info("{}线修改玻璃状态为3",Const.A10_OUT_TARGET_POSITION);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
@@ -903,23 +953,54 @@
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress();
        String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address;
        List<String> returnData = new ArrayList<>();

        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            returnData.add(taskList.get(i - 1).getGlassId());
            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
        }
        int returnData = 1;
//        int returnData = 1;
        int count = 1;
        while (returnData != 0) {


        while (CollectionUtils.isNotEmpty(returnData)) {
            List<String> glassIds1 = new ArrayList<>();
            List<String> glassIds2 = new ArrayList<>();
            s7control.writeWord(outLine, 2);
            for (int i = 1; i <= 6; i++) {
                String line1GlassId = plcMesObject.getPlcParameter("D03ID" + i).getValue();
                if (StringUtils.isNotEmpty(line1GlassId)) {
                    glassIds1.add(line1GlassId);
                }
                String line2GlassId = plcMesObject.getPlcParameter("D05ID" + i).getValue();
                if (StringUtils.isNotEmpty(line2GlassId)) {
                    glassIds2.add(line2GlassId);
                }
            }
            if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
//                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
                returnData = glassIds1;
            } else {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
//                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
                returnData = glassIds2;
            }
//            returnData = s7control.readWord(outLine, 1).get(0);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, 2);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2,returnData);
        }
//        while (returnData != 0) {
//            s7control.writeWord(outLine, 2);
//            if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
////                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
//                returnData = s7control.readWord(plcMesObject.getPlcParameter("D03Request").getAddress(), 1).get(0);
//            } else {
////                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
//                returnData = s7control.readWord(plcMesObject.getPlcParameter("D05Request").getAddress(), 1).get(0);
//            }
////            returnData = s7control.readWord(outLine, 1).get(0);
//            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2,returnData);
//        }
    }

    /**

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/opccallback/BigStorageStartCallback.java

New file
@@ -0,0 +1,824 @@
package com.mes.job.opccallback;

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.mes.base.entity.BigStorageCageBaseInfo;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.S7control;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author : zhoush
 * @Date: 2024/10/28 21:22
 * @Description:
 */
@Service
@Slf4j
public class BigStorageStartCallback implements SubscriptionCallback {


    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    private GlassInfoService glassInfoService;
    @Resource
    private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
    @Resource
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private EdgGlassTaskInfoService edgGlassTaskInfoService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private DamageService damageService;

    @Resource
    private RedisUtil redisUtil;

    private static final String REQUEST_WORD = "1";

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;

    @Value("${mes.carWidth}")
    private Integer carWidth;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    @Value("${mes.inCarMaxSize}")
    private Integer inCarMaxSize;

    @Value("${mes.outCarMaxSize}")
    private Integer outCarMaxSize;

    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Value("${mes.xMaxSize}")
    private Integer xMaxSize;


    private String d01GlassId = "";
    private String d04GlassId = "";

    @Override
    public void onSubscribe(String identifier, Object value) {
        //todo:获取任务列表
        String tableName = "";
        //todo:按照表明获取伍信息
        List<BigStorageCageFeedTask> tasks = new ArrayList<>();
        if (CollectionUtils.isEmpty(tasks)) {
            log.info("卧转立上没有玻璃");
            //todo 与卧转立交互，将请求字大车请求变为0，确保订阅任务可再次执行
            return;
        }
        List<String> glassIds = tasks.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
        List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds));
        computeIsTemperingTargetByLine(glassInfos, tasks);
    }


    @Scheduled(fixedDelay = 10000)
    public void plcToHomeEdgOutTask() {
        String mesToPLCAddress = "";
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        if (CollectionUtils.isNotEmpty(outingList)) {
            log.info("有正在执行出片的任务，结束当前出片线程");
            return;
        }
        if (redisUtil.getCacheObject("temperingSwitch")) {
            //是否有正在钢化的玻璃
            List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                    .selectAll(TemperingGlassInfo.class)
                    .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                    .isNull(BigStorageCageOutTask::getGlassId)
                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                return;
            }
            //是否有人工下片任务   有直接出
//            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
//                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
                    .orderByAsc(BigStorageCageDetails::getSlot)
                    .orderByDesc(BigStorageCageDetails::getId));
            if (CollectionUtils.isNotEmpty(artificialList)) {
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
                return;
            }
            //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
            if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
                //玻璃到齐包括已出片的
                //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
                for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                    if (redisUtil.getCacheObject("temperingengineerId").equals(item.getEngineerId())) {
                        List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                                .selectAll(GlassInfo.class)
                                .select("-1 as state")
                                .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                                .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                                .eq(GlassInfo::getEngineerId, item.getEngineerId())
                                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                            temperingGlassInfoService.saveBatch(temperingGlassInfos);
                            computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                            return;
                        }
                    }
                }
            }
        }
        //执行内部调度任务
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            loop:
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                    SlotSequenceDTO first = slotSequenceList.get(i);
                    SlotSequenceDTO second = slotSequenceList.get(i + 1);
                    int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                    if (first.getMinSequence() == second.getMaxSequence() + 1
                            && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(list)) {
                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                            int serialNumber = 1;
                            for (BigStorageCageDetails item : list) {
                                outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                        item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
                            }
                            //新增调度任务
                            bigStorageCageOutTaskService.saveBatch(outTasks);
                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
                            List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                    .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));
                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
//                            todo:临时解决报错
//                            updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
                            break loop;
                        }
                    }
                }
            }
//            //向plc写入确认字
//            int returnData = 0;
//            int count = 1;
//            while (returnData == 0) {
//                log.info("已向plc第{}次送协议", count);
//                S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
//                returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
//                log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
//            }
            return;
        }
    }


    /**
     * 确认字清空
     */
    @Scheduled(fixedDelay = 300)
    public void confirmClear() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            S7object.getinstance().plccontrol.writeWord(mesD01Address, 0);
        }
        if (!REQUEST_WORD.equals(d04ToMES)) {
            S7object.getinstance().plccontrol.writeWord(mesD04Address, 0);
        }
        if (!REQUEST_WORD.equals(d03ToMES)) {
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
        }
        if (!REQUEST_WORD.equals(d05ToMES)) {
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
        }
    }

    /**
     * 进片状态修改
     */
    @Scheduled(fixedDelay = 300)
    public void feedStatusUpdate() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        List<String> glassIds1 = new ArrayList<>();
        List<String> glassIds2 = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            String line1GlassId = plcParameterObject.getPlcParameter("D03ID" + i).getValue();
            if (StringUtils.isNotEmpty(line1GlassId)) {
                glassIds1.add(line1GlassId);
            }
            String line2GlassId = plcParameterObject.getPlcParameter("D05ID" + i).getValue();
            if (StringUtils.isNotEmpty(line2GlassId)) {
                glassIds2.add(line2GlassId);
            }
        }
        List<BigStorageCageFeedTask> bigStorageCageFeedTasks1 = bigStorageCageFeedTaskService.list(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
                        .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
        );
        List<BigStorageCageFeedTask> bigStorageCageFeedTasks2 = bigStorageCageFeedTaskService.list(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
                        .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
        );
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks1) && CollectionUtils.isNotEmpty(glassIds1)) {
            List<String> matchingIds1 = bigStorageCageFeedTasks1.stream()
                    .map(BigStorageCageFeedTask::getGlassId)
                    .filter(glassIds1::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
        }
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2) && CollectionUtils.isNotEmpty(glassIds2)) {
            List<String> matchingIds2 = bigStorageCageFeedTasks2.stream()
                    .map(BigStorageCageFeedTask::getGlassId)
                    .filter(glassIds2::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
        }
        if (CollectionUtils.isEmpty(glassIds1)) {
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
            );
        }
        if (CollectionUtils.isEmpty(glassIds2)) {
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
            );
        }
    }

    /**
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
        //判断此玻璃是在笼内或已生成进片任务
        BigStorageCageFeedTask bigStorageCageFeedTask = bigStorageCageFeedTaskService.getOne(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                        .eq(BigStorageCageFeedTask::getGlassId, glassId)
        );
        BigStorageCageDetails bigStorageCageDetails = bigStorageCageDetailsService.getOne(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .eq(BigStorageCageDetails::getGlassId, glassId)
                        .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
        );
        if (bigStorageCageFeedTask != null || bigStorageCageDetails != null) {
            log.info("此玻璃存任务或已在笼内");
            return Boolean.TRUE;
        }
        //1、获取任务表中相邻玻璃
        List<EdgGlassTaskInfo> edgGlassTaskInfoList;
        edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
                .eq(EdgGlassTaskInfo::getLine, line)
                .apply("time >= (select time from edg_glass_task_info where line='" + line + "' and glass_id = '" + glassId + "' and deleted = 0)")
                .orderByAsc(EdgGlassTaskInfo::getTime));
        if (edgGlassTaskInfoList.size() == 0) {
            edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>()
                    .select("Top 1 *")
                    .eq("glass_id", glassId)
            );
            log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList);
            if (edgGlassTaskInfoList.size() == 0) {
                GlassInfo glassInfo = glassInfoService.getOne(
                        new LambdaQueryWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, glassId)
                );
                EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo();
                BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo);
                edgGlassTaskInfo.setWidth((int) glassInfo.getWidth());
                edgGlassTaskInfo.setHeight((int) glassInfo.getHeight());
                edgGlassTaskInfoList.add(edgGlassTaskInfo);
                log.info("在玻璃信息表中获取玻璃信息{}", edgGlassTaskInfoList);
            }
        }
        Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
        //2、获取卧转立剩余宽度
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
        Integer remainWidth;
        Integer glassCount;
        if (0 == sitToUpRemainWidth.getGlassCount()) {
            remainWidth = carWidth;
            glassCount = 0;
        } else {
            remainWidth = sitToUpRemainWidth.getWidth();
            glassCount = sitToUpRemainWidth.getGlassCount();
        }

        Boolean flag = Boolean.TRUE;
        //2、获取卧转立
        Integer widthFirst = Math.max(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
        Integer heightFirst = Math.min(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
        if (edgGlassTaskInfoList.size() == 1) {
            if (remainWidth >= widthFirst) {
                if (glassCount < inCarMaxSize) {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);
                } else {
                    if (glassCount < inCarMaxSize + 1) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
                    } else {
                        return Boolean.FALSE;
                    }
                }
            } else {
                flag = Boolean.FALSE;
            }
        } else {
            Integer widthSecond = Math.max(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
            Integer heightSecond = Math.min(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
            if (remainWidth >= widthFirst) {
                if (remainWidth - widthFirst - glassGap >= widthSecond) {
                    if (glassCount < inCarMaxSize) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);
                    } else {
                        if (glassCount < inCarMaxSize + 1) {
                            addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
                        } else {
                            return Boolean.FALSE;
                        }
                    }
                } else {
                    if (glassCount < inCarMaxSize + 1) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
                    } else {
                        return Boolean.FALSE;
                    }
                }
            } else {
                flag = Boolean.FALSE;
            }
        }
        //向plc发送进片确认
        if (flag) {
            //向plc写入确认字
            PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
            int returnData = 1;
            int count = 1;
            while (returnData != 0) {
                S7object.getinstance().plccontrol.writeWord(mesAddress, 1);

                if (Const.A10_OUT_TARGET_POSITION.equals(line)) {
                    returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D04ToMES").getValue());
                } else {
                    returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D01ToMES").getValue());
                }
//                returnData = S7object.getinstance().plccontrol.readWord(mesAddress, 1).get(0);
                log.info("进卧转立第{}次发送确认字完成，地址为：{},写入的内容为{}", count++, mesAddress, 1);
            }
        }
        //记录无法放下玻璃，后续判断启动
        return flag;
    }

    /**
     * 添加任务信息
     */
    private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width, Integer height) {
        BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
        bigStorageCageFeedTask.setGlassId(glassId);
        bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_IN_NEW);
        bigStorageCageFeedTask.setLine(line);
        bigStorageCageFeedTask.setTaskType(taskType);
        bigStorageCageFeedTask.setWidth(width);
        bigStorageCageFeedTask.setHeight(height);
        bigStorageCageFeedTask.setCreateTime(new Date());
        //删除理片笼表拿走/破损数据数据
        damageService.deleteByGlassId(glassId);
        Damage damage = new Damage();
        damage.setGlassId(glassId);
        damage.setWorkingProcedure("磨边");
        damage.setLine(line);
        damage.setType(1);
        damage.setRemark("进大理片");
        damageService.insertDamage(damage);
        return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask);
    }

    /**
     * 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路
     *
     * @return 需要启动的线路
     */
    public Integer getStartLine() {
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2" +
                        "and (target_slot = 0 or target_slot is null) group by line"));
        Assert.isFalse(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务");
        Map<String, Integer> taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId,
                BigStorageCageFeedTask::getLine));
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                .in(GlassInfo::getGlassId, taskMap.keySet())
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("limit 1"));
        return taskMap.get(glassInfo.getGlassId());
    }

    /**
     * 计算任务表进片线路的目标格子，并启动任务
     */
    public boolean computeTargetByLine(Integer line) {
        //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getLine, line)
                .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
                .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP_ALL)
                .orderByAsc(BigStorageCageFeedTask::getId));
        //2、去笼子内查找是否可以继续存放的笼子
        List<String> glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
        List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds));
        return computeIsTemperingTargetByLine(glassInfos, taskList);
    }

    /**
     * 是否钢化玻璃进笼目标位置
     *
     * @param glassInfos 当条线卧转立所有玻璃
     * @param taskList   当条线卧转立所有任务
     */
    private boolean computeIsTemperingTargetByLine(List<GlassInfo> glassInfos, List<BigStorageCageFeedTask> taskList) {
        //1、将玻璃信息集合转为glassid为key的map
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream()
                .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        for (BigStorageCageFeedTask e : taskList) {
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            if (info == null) {
                continue;
            }
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            //todo:2、获取目标格子信息
            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
            //3、临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）  遇到问题：无法批量更新，批量更新无法走指定从库
            e.setTargetSlot(bigStorageDTO.getSlot());
            bigStorageCageFeedTaskService.updateById(e);

            //5、将进片信息存入大理片笼详情表
            cageDetails.setSlot(bigStorageDTO.getSlot());
            cageDetails.setState(Const.GLASS_STATE_NEW);
            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
            cageDetails.setGap(glassGap);
            bigStorageCageDetailsService.save(cageDetails);

        }
        return Boolean.TRUE;
    }

    private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
        log.info("送片任务发送进片玻璃信息");
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress();
        String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address;
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
        }
        int returnData = 1;
        int count = 1;
        while (returnData != 0) {
            s7control.writeWord(outLine, 2);
            if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
            } else {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
            }
//            returnData = s7control.readWord(outLine, 1).get(0);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, 2);
        }
    }

    /**
     * 出片一次仅生成一车玻璃
     *
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param <T>
     * @return
     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        int maxX = 0;
        for (T e : list) {
            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
                break;
            }
            remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1, new Date()));
                    maxX = Math.max(maxX, e.getXCoordinate());
                } else {
                    break;
                }

            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), 0, 0, 1, new Date()));
            }
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        int returnData = 0;
        int count = 1;
        while (returnData == 0) {
            S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
            returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
            log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
        }
        return Boolean.TRUE;
    }

    /**
     * 出片一次生成一炉玻璃
     *
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param <T>
     * @return
     */
    public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        int trainNumber = 1;
        int serialNumber = 1;
        int maxX = 0;
        for (T e : list) {
            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
            if (serialNumber > outCarMaxSize || maxLength > remainWidth) {
                remainWidth = carWidth;
                trainNumber = trainNumber + 1;
                serialNumber = 1;
                maxX = 0;
            }
            remainWidth = remainWidth - maxLength - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                    maxX = Math.max(maxX, e.getXCoordinate());
                } else {
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    maxX = e.getXCoordinate();
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                }
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
            }
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        for (BigStorageCageOutTask bigStorageCageOutTask : bigStorageCageOutTaskList
        ) {
            bigStorageCageOutTaskService.save(bigStorageCageOutTask);
        }
//        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds)
                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));

        return Boolean.TRUE;
    }

    private BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {

        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
                .selectAll(BigStorageCage.class)
                .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
                .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            wrapper.eq(BigStorageCageDetails::getFlowCardId, glassInfo.getFlowCardId())
                    .eq(BigStorageCageDetails::getLayer, glassInfo.getLayer());
//            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
        } else {
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1);
        }
        BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper);
        return null;
    }

    @Scheduled(fixedDelay = 300)
    public void querySizeByEngineerTask() {
        log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 10, 8));
        log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 5, 8));

    }

    public BigStorageDTO querySizeByEngineer(String engineerId, int temperingLayoutId, int temperingFeedSequence, double thickness) {
        BigStorageDTO bigStorageDTO = null;
        BigStorageCage bigStorageCage = null;
        //获取笼内当前版图每个格子已有玻璃的最小版序 获取笼内当前版图的所有玻璃信息
        List<BigStorageCageDetails> cageDetailsList = bigStorageCageDetailsService.list(new QueryWrapper<BigStorageCageDetails>()
                .select("slot", "min(tempering_feed_sequence) as tempering_feed_sequence")
                .eq("engineer_id", engineerId).eq("tempering_layout_id", temperingLayoutId)
                .in("state", Const.GLASS_STATE_IN_ALL_ZERO).groupBy("slot").orderByAsc("min(tempering_feed_sequence)"));
        if (CollectionUtils.isNotEmpty(cageDetailsList)) {
            Integer minLength = cageDetailsList.stream().filter(e -> e.getTemperingFeedSequence() > temperingFeedSequence)
                    .mapToInt(BigStorageCageDetails::getTemperingFeedSequence).min().orElse(1000);
            List<GlassInfo> infoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>()
                    .notInSql(GlassInfo::getGlassId, "select glass_id from damage where tempering_layout_id = " + temperingLayoutId + " and engineer_id = '" + engineerId + "'")
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId).eq(GlassInfo::getEngineerId, engineerId).orderByAsc(GlassInfo::getTemperingFeedSequence));
            int remainWidth = carWidth;
            int trainNumber = 1;
            int serialNumber = 0;
            int min = 0;
            int temp = infoList.get(0).getTemperingFeedSequence();
            int slot = 0;
            int resultTrainNumber = 0;
            for (GlassInfo e : infoList) {
                int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
                if (serialNumber >= outCarMaxSize || maxLength > remainWidth || e.getTemperingFeedSequence() >= minLength) {
                    if (resultTrainNumber != 0) {
                        min = temp;
                        break;
                    }
                    temp = e.getTemperingFeedSequence();
                    remainWidth = carWidth;
                    trainNumber = trainNumber + 1;
                    serialNumber = 0;
                }
                if (temperingFeedSequence == e.getTemperingFeedSequence()) {
                    resultTrainNumber = trainNumber;
                }
                remainWidth = remainWidth - maxLength - glassGap > 0 ? remainWidth - maxLength - glassGap : 0;
                serialNumber += 1;
                log.info("{},{},{}", trainNumber, remainWidth, serialNumber);
                if (e.getTemperingFeedSequence().equals(infoList.get(infoList.size() - 1).getTemperingFeedSequence())) {
                    min = temp;
                }
            }
            for (BigStorageCageDetails item : cageDetailsList) {
                if (min <= item.getTemperingFeedSequence() && item.getTemperingFeedSequence() < minLength) {
                    slot = item.getSlot();
                    bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                            .eq(BigStorageCage::getSlot, slot).eq(BigStorageCage::getEnableState, Const.SLOT_ON));
                    break;
                }
            }
        }

        if (bigStorageCage != null) {
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        }

        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where engineer_id = '" + engineerId + "' and tempering_layout_id = " + temperingLayoutId)
                .last("limit 1"));
        if (null != bigStorageCage) {
            log.info("根据版图id找到笼子内的目标格子：{}", bigStorageCage.getSlot());
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;

        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(thickness);
        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                    .eq(BigStorageCage::getDeviceId, item)
                    .last("limit 1"));
            if (null != bigStorageCage) {
                log.info("按照存笼玻璃格子数占用最少方式获取信息格子为：{}", bigStorageCage.getSlot());
                bigStorageDTO = new BigStorageDTO();
                bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
                bigStorageDTO.setSlot(bigStorageCage.getSlot());
                bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
                return bigStorageDTO;
            }
        }
        Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
        return bigStorageDTO;
    }

}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/JsonFile/PlcCacheVerticalGlass.json

@@ -74,7 +74,7 @@
        },
        {
            "codeId": "D05ID2",
            "addressIndex": "328",
            "addressIndex": "320",
            "addressLenght": "32",
            "ratio": "1",
            "unit": ""
@@ -372,6 +372,20 @@
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        },
        {
            "codeId": "D03Request",
            "addressIndex": "898",
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        },
        {
            "codeId": "D05Request",
            "addressIndex": "900",
            "addressLenght": "2",
            "ratio": "1",
            "unit": ""
        }
    ]
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageMapper.xml

@@ -11,7 +11,7 @@
        WHERE T.MAX_THICKNESS >= #{thickness}
          AND T.ENABLE_STATE = 1
        GROUP BY T.DEVICE_ID
        ORDER BY T.MAX_THICKNESS,
        ORDER BY min(T.MAX_THICKNESS),
                 COUNT(DISTINCT T1.ENGINEER_ID), COUNT(DISTINCT T1.TEMPERING_LAYOUT_ID),
                 COUNT(DISTINCT T1.SLOT)
    </select>

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/test/java/com/mes/CacheVerticalGlassModuleApplicationTest.java

@@ -4,8 +4,10 @@
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
@@ -198,6 +200,35 @@
        damageService.deleteByGlassId("P24081203|2|5");
    }

    @Test
    public void testttt(){
        List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(6);
        List<Integer> deviceUseds = deviceUsedList;
        List<BigStorageCageDetails> engineerCount1 = bigStorageCageDetailsService.list(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 1, 5)
        );
        List<BigStorageCageDetails> engineerCount2 = bigStorageCageDetailsService.list(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE)
                        .select(BigStorageCageDetails::getEngineerId)
                        .groupBy(BigStorageCageDetails::getEngineerId)
                        .between(BigStorageCageDetails::getDeviceId, 6, 8)
        );
        if (engineerCount1.size() > engineerCount2.size()) {
            deviceUsedList.removeIf(device -> device < 6);
        } else {
            deviceUsedList.removeIf(device -> device > 5);
        }
        if (CollectionUtils.isEmpty(deviceUsedList)) {
            deviceUsedList = deviceUseds;
        }
        log.info("zhi:{}",deviceUsedList);
    }


    @Test
    public void ca(){

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/job/RawGlassTask.java

@@ -74,7 +74,7 @@
            if ("1".equals(taskWord.getValue() + "")) {
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 0));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", 0));
                miloService.writeToOpcWord(list);

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

New file
@@ -0,0 +1,222 @@
package com.mes.job;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.mes.common.config.Const;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.opctask.entity.LoadGlassDeviceTask;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.opctask.service.LoadGlassDeviceTaskHistoryService;
import com.mes.opctask.service.LoadGlassDeviceTaskService;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
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;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Author : zhoush
 * @Date: 2024/10/23 14:30
 * @Description:
 */
@Component
@Slf4j
public class OpcLoadGlassTask {

    @Resource
    private EngineeringMapper engineeringMapper;

    @Resource
    private LoadGlassDeviceTaskService loadGlassDeviceTaskService;
    @Resource
    private RawGlassStorageDetailsService rawGlassStorageDetailsService;
    @Resource
    private LoadGlassDeviceTaskHistoryService loadGlassDeviceTaskHistoryService;
    @Resource
    private UpPattenUsageMapper upPattenUsageMapper;

    private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
    private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104);


    private static final Integer LOAD_GLASS_ONE_DEVICE = 5;
    private static final Integer LOAD_GLASS_TWO_DEVICE = 6;
    private static final String LOAD_GLASS_DEVICE_ONE_TASK = "load_glass_device_one_task";

    private static final String LOAD_GLASS_DEVICE_TWO_TASK = "load_glass_device_two_task";


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

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

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

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

    private void opcLoadGlassChild(String tableName, Integer deviceId) {
        Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING).eq(Engineering::getStationCell, deviceId));
        if (null == engineering) {
            log.info("{}上片线，没有工程任务", deviceId);
            return;
        }
        //任务暂停
        LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName);
        if (task.getTaskRunning().equals(Const.ENGINEERING_RUNNING)) {
            log.info("{}上片线，有正在执行的任务，结束本地上片请求", deviceId);
            return;
        }
        List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(engineering.getEngineerId());
        log.info("按照当前获取到正在需要上片的原片信息有：{}", pattenUsageList);
        if (CollectionUtils.isEmpty(pattenUsageList)) {
            log.info("当前工程需要上片的原片信息为空，任务已结束");
            //todo：是否将工程状态改为已完成
            return;
        }
        Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
                .collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber));
        log.info("获取当前需要上片的原片数据");
        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)
                .eq(RawGlassStorageDetails::getDeviceId, deviceId));
        if (CollectionUtils.isEmpty(loadStationList)) {
            log.info("当前上片线路两个上片位都没有原片信息，结束本次上片任务，等待仓储调度任务");
            return;
        }
        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), twoLoadStation)) {
                log.info("二号上片位有架子，原片数量为0或者原片信息与待上片尺寸不一致，结束本次上片任务，等待仓储调度任务");
                return;
            }
            int number = Math.min(twoLoadStation.getRemainQuantity(), usageVOS.size());
            //生成上片任务
            task.setTotalCount(number);
            task.setTaskRunning(Const.ENGINEERING_RUNNING);
            task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
            task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
            task.setSlot(loadStation.get(1));
            loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
            saveHistoryTask(task, deviceId);
            return;
        }
        //尺寸不一样或者原片数量大于0
        if (!compareRawSize(usageVOS.get(0), oneLoadStation)) {
            log.info("一号上片位有架子，原片数量为0或者原片信息与待上片尺寸不一致，结束本次上片任务，等待仓储调度任务");
            return;
        }
        //生成上片任务
        int number = Math.min(oneLoadStation.getRemainQuantity(), usageVOS.size());
        task.setTotalCount(number);
        task.setTaskRunning(Const.ENGINEERING_RUNNING);
        task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
        task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
        task.setSlot(loadStation.get(0));
        loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
        saveHistoryTask(task, deviceId);
    }

    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("任务正在执行,结束");
            return;
        }
        //获取任务完成情况
//         已完成数量  破损数量
        Integer finishCount = task.getFinishCount();
        Integer damageCount = task.getDamageCount();

        //更新当前架子上的原片剩余情况
        rawGlassStorageDetailsService.update(new UpdateWrapper<RawGlassStorageDetails>()
                .inSql("slot", "select slot from raw_glass_storage_station where enable_state = 1")
                .eq("slot", task.getSlot())
                .eq("state", Const.RAW_GLASS_STATE_IN)
                .setSql("remain_quantity = remain_quantity - " + (finishCount + damageCount)));
        //更新工程下的原片数量 todo:sql待优化

        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));

        //todo:任务表数据情况
        task.setTaskRunning(0);
        task.setTotalCount(0);
        task.setRawGlassWidth(0);
        task.setRawGlassHeight(0);
        task.setSlot(0);
        loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
        loadGlassDeviceTaskHistoryService.update(new LambdaUpdateWrapper<LoadGlassDeviceTaskHistory>()
                .set(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS)
                .eq(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .eq(LoadGlassDeviceTaskHistory::getStation, deviceId)
        );
    }

    private boolean saveHistoryTask(LoadGlassDeviceTask task, Integer deviceId) {
        LoadGlassDeviceTaskHistory taskHistory = new LoadGlassDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
        taskHistory.setStation(deviceId);
        taskHistory.setCreateTime(new Date());
        taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW);
        loadGlassDeviceTaskHistoryService.save(taskHistory);
        return Boolean.TRUE;
    }

    /**
     * 尺寸一样并且原片数量大于0
     *
     * @param upPattenUsage
     * @param details
     * @return
     */
    private boolean compareRawSize(UpPattenUsage upPattenUsage, RawGlassStorageDetails details) {
        boolean flag = upPattenUsage.getWidth() == details.getPatternWidth() && upPattenUsage.getHeight() == details.getPatternHeight() &&
                upPattenUsage.getThickness() == details.getPatternThickness() && upPattenUsage.getFilmsId().equals(details.getFilmsId());
        return flag && details.getRemainQuantity() > 0;
    }

}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/entity/LoadGlassDeviceTask.java

New file
@@ -0,0 +1,58 @@
package com.mes.opctask.entity;

import lombok.Data;

import java.util.Date;

/**
 * (LoadGlassDeviceOneTask)表实体类
 *
 * @author makejava
 * @since 2024-11-06 16:00:10
 */
@Data
public class LoadGlassDeviceTask {
    /**
     * 任务请求 0无任务 1上片
     */
    private Integer taskRunning;
    /**
     * 原片宽
     */
    private Integer rawGlassWidth;
    /**
     * 原片高
     */
    private Integer rawGlassHeight;
    /**
     * 上片位编号
     */
    private Integer slot;
    /**
     * 任务状态 0默认空任务 1执行中 2结束任务
     */
    private Integer taskState;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;
    /**
     * 上片总数量
     */
    private Integer totalCount;
    /**
     * 已完成数量
     */
    private Integer finishCount;
    /**
     * 破损数量
     */
    private Integer damageCount;


}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/entity/LoadGlassDeviceTaskHistory.java

New file
@@ -0,0 +1,66 @@
package com.mes.opctask.entity;

import lombok.Data;

import java.util.Date;

/**
 * (LoadGlassDeviceTaskHistory)表实体类
 *
 * @author makejava
 * @since 2024-11-06 22:23:00
 */
@SuppressWarnings("serial")
@Data
public class LoadGlassDeviceTaskHistory {
    /**
     * 历史任务id
     */
    private Long id;
    /**
     * 任务请求 0无任务 1上片
     */
    private Integer taskRunning;
    /**
     * 原片宽
     */
    private Integer rawGlassWidth;
    /**
     * 原片高
     */
    private Integer rawGlassHeight;
    /**
     * 上片设备编号
     */
    private Integer station;
    /**
     * 上片位编号
     */
    private Integer slot;
    /**
     * 任务状态 0默认空任务 1执行中 2结束任务
     */
    private Integer taskState;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;
    /**
     * 上片总数量
     */
    private Integer totalCount;
    /**
     * 已完成数量
     */
    private Integer finishCount;
    /**
     * 破损数量
     */
    private Integer damageCount;

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/mapper/LoadGlassDeviceTaskHistoryDao.java

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

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;

/**
 * (LoadGlassDeviceTaskHistory)表数据库访问层
 *
 * @author makejava
 * @since 2024-11-06 22:22:59
 */
public interface LoadGlassDeviceTaskHistoryDao extends BaseMapper<LoadGlassDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/mapper/LoadGlassDeviceTaskMapper.java

New file
@@ -0,0 +1,19 @@
package com.mes.opctask.mapper;

import com.mes.opctask.entity.LoadGlassDeviceTask;
import org.apache.ibatis.annotations.Param;

/**
 * (LoadGlassDeviceOneTask)表数据库访问层
 *
 * @author makejava
 * @since 2024-11-06 16:00:09
 */
public interface LoadGlassDeviceTaskMapper {

    LoadGlassDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") LoadGlassDeviceTask loadGlassDeviceTask);

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/service/LoadGlassDeviceTaskHistoryService.java

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

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;

/**
 * (LoadGlassDeviceTaskHistory)表服务接口
 *
 * @author makejava
 * @since 2024-11-06 22:23:00
 */
public interface LoadGlassDeviceTaskHistoryService extends IService<LoadGlassDeviceTaskHistory> {

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/service/LoadGlassDeviceTaskService.java

New file
@@ -0,0 +1,20 @@
package com.mes.opctask.service;

import com.mes.opctask.entity.LoadGlassDeviceTask;
import org.apache.ibatis.annotations.Param;

/**
 * (LoadGlassDeviceOneTask)表服务接口
 *
 * @author makejava
 * @since 2024-11-06 16:00:13
 */
public interface LoadGlassDeviceTaskService {


    LoadGlassDeviceTask queryTaskMessage(String tableName);

    boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") LoadGlassDeviceTask loadGlassDeviceTask);

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/service/impl/LoadGlassDeviceOneTaskServiceImpl.java

New file
@@ -0,0 +1,32 @@
package com.mes.opctask.service.impl;

import com.mes.opctask.entity.LoadGlassDeviceTask;
import com.mes.opctask.mapper.LoadGlassDeviceTaskMapper;
import com.mes.opctask.service.LoadGlassDeviceTaskService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * (LoadGlassDeviceOneTask)表服务实现类
 *
 * @author makejava
 * @since 2024-11-06 16:00:16
 */
@Service
public class LoadGlassDeviceOneTaskServiceImpl implements LoadGlassDeviceTaskService {

    @Resource
    LoadGlassDeviceTaskMapper loadGlassDeviceTaskMapper;

    @Override
    public LoadGlassDeviceTask queryTaskMessage(String tableName) {
        return loadGlassDeviceTaskMapper.queryTaskMessage(tableName);
    }

    @Override
    public boolean updateTaskMessage(String tableName, LoadGlassDeviceTask loadGlassDeviceTask) {
        return loadGlassDeviceTaskMapper.updateTaskMessage(tableName, loadGlassDeviceTask);
    }
}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/service/impl/LoadGlassDeviceTaskHistoryServiceImpl.java

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

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.opctask.entity.LoadGlassDeviceTaskHistory;
import com.mes.opctask.mapper.LoadGlassDeviceTaskHistoryDao;
import com.mes.opctask.service.LoadGlassDeviceTaskHistoryService;
import org.springframework.stereotype.Service;

/**
 * (LoadGlassDeviceTaskHistory)表服务实现类
 *
 * @author makejava
 * @since 2024-11-06 22:23:00
 */
@Service
public class LoadGlassDeviceTaskHistoryServiceImpl extends ServiceImpl<LoadGlassDeviceTaskHistoryDao, LoadGlassDeviceTaskHistory> implements LoadGlassDeviceTaskHistoryService {

}


 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/uppattenusage/controller/UpPattenUsageController.java

@@ -2,7 +2,6 @@

import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.uppattenusage.entity.UpPattenUsage;

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/application-dev.yml

@@ -19,6 +19,9 @@
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
      druid:
        wall:
          multi-statement-allow: true
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/mapper/LoadGlassDeviceTaskMapper.xml

New file
@@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mes.opctask.mapper.LoadGlassDeviceTaskMapper">

    <resultMap id="baseMap" type="com.mes.opctask.entity.LoadGlassDeviceTask">
        <id column="task_running" property="taskRunning"/>
        <result column="raw_glass_width" property="rawGlassWidth"/>
        <result column="raw_glass_height" property="rawGlassHeight"/>
        <result column="slot" property="slot"/>
        <result column="task_state" property="taskState"/>
        <result column="create_time" property="createTime"/>
        <result column="update_time" property="updateTime"/>
        <result column="total_count" property="totalCount"/>
        <result column="finish_count" property="finishCount"/>
        <result column="damage_count" property="damageCount"/>
    </resultMap>

    <select id="queryTaskMessage" resultMap="baseMap">
        select *
        from ${tableName}
        limit 1
    </select>

    <update id="updateTaskMessage">
        UPDATE ${tableName}
        SET task_running     = #{task.taskRunning},
            raw_glass_width  = #{task.rawGlassWidth},
            raw_glass_height = #{task.rawGlassHeight},
            slot             = #{task.slot},
            total_count      = #{task.totalCount}
    </update>


</mapper>

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/TemperingTask.java

@@ -152,7 +152,7 @@
                damage.setLine(Const.TEMPERING_OUT_TARGET_POSITION);
                damage.setWorkingProcedure("钢化");
                damage.setRemark("钢化");
                damage.setStatus(0);
                damage.setStatus(1);
                damage.setType(e.getState());
                return damage;
            }).collect(Collectors.toList());

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/changelog/changelogBase.xml

@@ -6,6 +6,7 @@

    <!-- 引入第一个SQL配置文件 -->
    <include file="./changelog/changelog.sql" relativeToChangelogFile="false"/>
    <include file="./changelog/ywChangelog.sql" relativeToChangelogFile="false"/>

    <!-- 更多的include标签... -->


 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/changelog/ywChangelog.sql

New file
@@ -0,0 +1,172 @@
-- liquibase formatted sql

-- changeset zsh:20241107001
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'edg_storage_device_one_task' and table_schema = 'hangzhoumes';
CREATE TABLE edg_storage_device_one_task
(
    task_running int                DEFAULT NULL COMMENT '任务请求 0无任务 1进片 2出片 3直通',
    glass_id_in  varchar(20)        DEFAULT NULL COMMENT '进片玻璃id',
    glass_id_out varchar(20)        DEFAULT NULL COMMENT '出片玻璃id',
    glass_id     varchar(20)        DEFAULT NULL COMMENT '磨边前玻璃id',
    current_cell int                DEFAULT '0' COMMENT '当前层号',
    start_cell   int                DEFAULT '0' COMMENT '层号',
    end_cell     int                DEFAULT NULL COMMENT '预留层号',
    task_state   int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    task_type    int                DEFAULT NULL COMMENT '任务类型',
    create_time  timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time  timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    width        int                DEFAULT NULL COMMENT '宽',
    height       int                DEFAULT NULL COMMENT '高',
    thickness    int                DEFAULT NULL COMMENT '厚',
    film_remove  int                DEFAULT NULL COMMENT '是否除膜'
);
-- rollback DROP TABLE edg_storage_device_one_task;


-- changeset zsh:20241107002
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM edg_storage_device_one_task;
INSERT INTO edg_storage_device_one_task (task_running, glass_id, glass_id_in, glass_id_out, current_cell, start_cell,
                                         end_cell, task_state, task_type, width, height, thickness, film_remove)
VALUES (0, NULL, NULL, NULL, 1, 0, NULL, 0, NULL, 0, 0, 0, 0);


-- changeset zsh:20241107003
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'edg_storage_device_two_task' and table_schema = 'hangzhoumes';
CREATE TABLE edg_storage_device_two_task
(
    task_running int                DEFAULT NULL COMMENT '任务请求 0无任务 1进片 2出片 3直通',
    glass_id_in  varchar(20)        DEFAULT NULL COMMENT '进片玻璃id',
    glass_id_out varchar(20)        DEFAULT NULL COMMENT '出片玻璃id',
    glass_id     varchar(20)        DEFAULT NULL COMMENT '磨边前玻璃id',
    current_cell int                DEFAULT '0' COMMENT '当前层号',
    start_cell   int                DEFAULT '0' COMMENT '层号',
    end_cell     int                DEFAULT NULL COMMENT '预留层号',
    task_state   int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    task_type    int                DEFAULT NULL COMMENT '任务类型',
    create_time  timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time  timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    width        int                DEFAULT NULL COMMENT '宽',
    height       int                DEFAULT NULL COMMENT '高',
    thickness    int                DEFAULT NULL COMMENT '厚',
    film_remove  int                DEFAULT NULL COMMENT '是否除膜'
);
-- rollback DROP TABLE edg_storage_device_two_task;

-- changeset zsh:20241107004
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM edg_storage_device_two_task;
INSERT INTO edg_storage_device_two_task (task_running, glass_id, glass_id_in, glass_id_out, current_cell, start_cell,
                                         end_cell, task_state, task_type, width, height, thickness, film_remove)
VALUES (0, NULL, NULL, NULL, 1, 0, NULL, 0, NULL, 0, 0, 0, 0);



-- changeset zsh:20241107005
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'edg_storage_device_task_history' and table_schema = 'hangzhoumes';
CREATE TABLE edg_storage_device_task_history
(
    id           bigint    NOT NULL AUTO_INCREMENT COMMENT '工程表id',
    glass_id_in  varchar(20)        DEFAULT NULL COMMENT '进片玻璃id',
    glass_id_out varchar(20)        DEFAULT NULL COMMENT '出片玻璃id',
    current_cell int                DEFAULT '0' COMMENT '当前层号',
    start_cell   int                DEFAULT '0' COMMENT '层号',
    end_cell     int                DEFAULT NULL COMMENT '预留层号',
    task_state   int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    task_type    int                DEFAULT NULL COMMENT '任务类型',
    create_time  timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time  timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id) USING BTREE
);
-- rollback DROP TABLE edg_storage_device_task_history;

-- changeset zsh:20241107006
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'edg_glass_task_queue_info' and table_schema = 'hangzhoumes';
CREATE TABLE edg_glass_task_queue_info
(
    glass_id    varchar(20)        DEFAULT NULL COMMENT '磨边前玻璃id',
    width       int                DEFAULT NULL COMMENT '宽',
    height      int                DEFAULT NULL COMMENT '高',
    thickness   int                DEFAULT NULL COMMENT '厚',
    state       int                DEFAULT NULL COMMENT '状态',
    line        int                DEFAULT NULL COMMENT '线路',
    create_time timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
);
-- rollback DROP TABLE edg_glass_task_queue_info;

-- changeset zsh:20241107007
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'load_glass_device_one_task' and table_schema = 'hangzhoumes';
CREATE TABLE load_glass_device_one_task
(
    task_running     int                DEFAULT '0' COMMENT '任务请求 0无任务 1上片',
    raw_glass_width  int                DEFAULT '0' COMMENT '原片宽',
    raw_glass_height int                DEFAULT '0' COMMENT '原片高',
    slot             int                DEFAULT '0' COMMENT '上片位编号',
    task_state       int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    create_time      timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time      timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    total_count      int                DEFAULT '0' COMMENT '上片总数量',
    finish_count     int                DEFAULT '0' COMMENT '已完成数量',
    damage_count     int                DEFAULT '0' COMMENT '破损数量'
);
-- rollback DROP TABLE load_glass_device_one_task;

-- changeset zsh:20241107008
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM load_glass_device_one_task;
INSERT INTO load_glass_device_one_task (task_running, raw_glass_width, raw_glass_height, slot, task_state, total_count,
                                        finish_count, damage_count)
VALUES (0, 0, 0, 0, 0, 0, 0, 0);

-- changeset zsh:20241107009
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'load_glass_device_two_task' and table_schema = 'hangzhoumes';
CREATE TABLE load_glass_device_two_task
(
    task_running     int                DEFAULT '0' COMMENT '任务请求 0无任务 1上片',
    raw_glass_width  int                DEFAULT '0' COMMENT '原片宽',
    raw_glass_height int                DEFAULT '0' COMMENT '原片高',
    slot             int                DEFAULT '0' COMMENT '上片位编号',
    task_state       int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    create_time      timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time      timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    total_count      int                DEFAULT '0' COMMENT '上片总数量',
    finish_count     int                DEFAULT '0' COMMENT '已完成数量',
    damage_count     int                DEFAULT '0' COMMENT '破损数量'
);
-- rollback DROP TABLE load_glass_device_two_task;

-- changeset zsh:20241107010
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM load_glass_device_two_task;
INSERT INTO load_glass_device_two_task (task_running, raw_glass_width, raw_glass_height, slot, task_state, total_count,
                                        finish_count, damage_count)
VALUES (0, 0, 0, 0, 0, 0, 0, 0);


-- changeset zsh:20241107011
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'load_glass_device_task_history' and table_schema = 'hangzhoumes';
CREATE TABLE load_glass_device_task_history
(
    id               bigint    NOT NULL AUTO_INCREMENT COMMENT '历史任务id',
    task_running     int                DEFAULT '0' COMMENT '任务请求 0无任务 1上片',
    raw_glass_width  int                DEFAULT '0' COMMENT '原片宽',
    raw_glass_height int                DEFAULT '0' COMMENT '原片高',
    station          int                DEFAULT '0' COMMENT '上片设备编号',
    slot             int                DEFAULT '0' COMMENT '上片位编号',
    task_state       int                DEFAULT NULL COMMENT '任务状态 0默认空任务 1执行中 2结束任务',
    create_time      timestamp NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time      timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    total_count      int                DEFAULT '0' COMMENT '上片总数量',
    finish_count     int                DEFAULT '0' COMMENT '已完成数量',
    damage_count     int                DEFAULT '0' COMMENT '破损数量',
    PRIMARY KEY (id) USING BTREE
);
-- rollback DROP TABLE load_glass_device_task_history;

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downglassinfo/service/impl/DownGlassInfoServiceImpl.java

@@ -1,6 +1,5 @@
package com.mes.downglassinfo.service.impl;

import cn.smallbun.screw.core.util.CollectionUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -8,7 +7,6 @@
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.downglassinfo.entity.DownGlassInfo;
import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;
import com.mes.downglassinfo.mapper.DownGlassInfoMapper;
@@ -21,6 +19,7 @@
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.job.DownLoadCacheGlassTask;
import com.mes.pp.service.FlowCardService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -31,7 +30,6 @@
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downworkstation/controller/DownWorkstationController.java

@@ -1,11 +1,11 @@
package com.mes.downworkstation.controller;


import com.mes.common.utils.RedisUtil;
import com.mes.downworkstation.entity.DownWorkstation;
import com.mes.downworkstation.entity.request.DownWorkRequest;
import com.mes.downworkstation.service.DownWorkstationService;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.utils.RedisUtil;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downworkstation/service/impl/DownWorkstationServiceImpl.java

@@ -5,7 +5,6 @@
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.common.S7object;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
@@ -19,6 +18,7 @@
import com.mes.downworkstation.service.DownWorkstationService;
import com.mes.downworkstation.service.DownWorkstationTaskService;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/job/Downpush.java

@@ -5,7 +5,6 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.mes.common.config.Const;

import com.mes.common.utils.RedisUtil;

import com.mes.downglassinfo.entity.DownGlassInfo;

import com.mes.downglassinfo.entity.DownGlassTask;

import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;

@@ -18,23 +17,20 @@
import com.mes.glassinfo.service.GlassInfoService;

import com.mes.tools.DateUtil;

import com.mes.tools.WebSocketServer;

import com.mes.utils.RedisUtil;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.scheduling.TaskScheduler;

import org.springframework.scheduling.annotation.Async;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;



import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.*;

import java.util.stream.Collectors;



@Slf4j