Merge branch 'master' of http://10.153.19.25:10101/r/HangZhouMes

wuyouming666

2024-06-05 1ae003e21ae53ab05006ca24c8b0473f93dd6912

Merge branch 'master' of http://10.153.19.25:10101/r/HangZhouMes

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/device/PlcBitObject.java

@@ -97,8 +97,9 @@
     * @param param 参数实例
     */
    public void addPlcBit(PlcBitInfo param) {
        if (plcBitMap != null)
        if (plcBitMap != null) {
            plcBitMap.put(param.getCodeId(),param);
        }
        else {
            plcBitMap = new LinkedHashMap<String,PlcBitInfo>();
            plcBitMap.put(param.getCodeId(),param);

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/tools/CodeGet.java

@@ -22,7 +22,7 @@
        // 2、全局配置
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        gc.setOutputDir("D:\\Documents\\hangzhoumesParent3\\");
        gc.setOutputDir("D:\\Documents\\hangzhoumesParent4\\");

        gc.setServiceName("%sService");    //去掉Service接口的首字母I
        gc.setAuthor("wu");

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

@@ -1,5 +1,6 @@
package com.mes.bigstorage.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.utils.Result;
@@ -28,10 +29,11 @@
    @Autowired
    private BigStorageCageService bigStorageCageService;

    @ApiOperation("查询理片笼信息")
    @GetMapping("/bigStorageCage")
    public Result querybigStorageCageDetail(int deviceId) {
        return Result.build(200,"查询成功",bigStorageCageService.querybigStorageCageDetail(deviceId));
    @ApiOperation("理片笼启用禁用")
    @GetMapping("/updateStorageCageDisabled")
    public Result updateStorageCageDisabled(int slot,int enableState) {
        bigStorageCageService.updateStorageCageDisabled(slot,enableState);
        return Result.build(200,"启用/禁用成功",1);
    }

}

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

@@ -1,7 +1,4 @@
package com.mes.bigstorage.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.utils.Result;
@@ -30,33 +27,47 @@
    @Autowired
    private BigStorageCageDetailsService bigStorageCageDetailsService;

    @ApiOperation("理片笼详情")
    @PostMapping("/queryBigStorageCageDetails")
    public Result queryBigStorageCageDetails() {
        return Result.build(200,"查询成功",bigStorageCageDetailsService.list());

    @ApiOperation("玻璃详情查询")
    @PostMapping("/selectBigStorageCageDetails")
    public Result selectBigStorageCageDetails(String glassId) {
        BigStorageCageDetails bigStorageCageDetails=bigStorageCageDetailsService.selectBigStorageCageDetails(glassId);
        return Result.build(200,"查询成功",bigStorageCageDetails);
    }

    @ApiOperation("理片笼详情添加")
    @PostMapping("/insertBigStorageCageDetails")
    public Result insertBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetailsService.save(bigStorageCageDetails);
        bigStorageCageDetailsService.insertBigStorageCageDetails(bigStorageCageDetails);
        return Result.build(200,"添加成功",1);
    }

    @ApiOperation("理片笼详情删除")
    @PostMapping("/deleteBigStorageCageDetails")
    public Result deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetailsService.removeById(bigStorageCageDetails.getId());
        bigStorageCageDetailsService.deleteBigStorageCageDetails(bigStorageCageDetails);
        return Result.build(200,"删除成功",1);
    }

    @ApiOperation("理片笼任务查询")
    @PostMapping("/selectBigStorageCageDetails")
    public Result selectBigStorageCageDetails(int state) {
        LambdaQueryWrapper<BigStorageCageDetails> selectWrapper = new LambdaQueryWrapper<>();
        selectWrapper.eq(BigStorageCageDetails::getState,state);
        return Result.build(200,"查询成功",bigStorageCageDetailsService.list(selectWrapper));
    @ApiOperation("理片笼任务破损")
    @PostMapping("/damageBigStorageCageDetails")
    public Result damageBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetailsService.damageBigStorageCageDetails(bigStorageCageDetails.getGlassId());
        return Result.build(200,"破损成功",1);
    }

    @ApiOperation("理片笼任务完成")
    @PostMapping("/finishBigStorageCageDetails")
    public Result finishBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetailsService.finishBigStorageCageDetails(bigStorageCageDetails);
        return Result.build(200,"破损成功",1);
    }

    @ApiOperation("理片笼任务出片")
    @PostMapping("/outBigStorageCageDetails")
    public Result outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetailsService.outBigStorageCageDetails(bigStorageCageDetails);
        return Result.build(200,"破损成功",1);
    }
}


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/entity/BigStorageCage.java

@@ -49,7 +49,7 @@
     * 启用状态
     */
    @ApiModelProperty(value = "启用状态", position = 5)
    private String enableState;
    private Integer enableState;

    /**
     * 剩余宽度

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/mapper/BigStorageCageDetailsMapper.java

@@ -1,6 +1,7 @@
package com.mes.bigstorage.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import feign.Param;

@@ -13,6 +14,6 @@
 * @author zhoush
 * @since 2024-03-27
 */
public interface BigStorageCageDetailsMapper extends BaseMapper<BigStorageCageDetails> {
public interface BigStorageCageDetailsMapper extends MPJBaseMapper<BigStorageCageDetails> {

}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/mapper/BigStorageCageMapper.java

@@ -1,6 +1,7 @@
package com.mes.bigstorage.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.glassinfo.entity.GlassInfo;
@@ -16,6 +17,6 @@
 * @author zhoush
 * @since 2024-03-27
 */
public interface BigStorageCageMapper extends BaseMapper<BigStorageCage> {
public interface BigStorageCageMapper extends MPJBaseMapper<BigStorageCage> {

}

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

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

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.glassinfo.entity.GlassInfo;

import java.util.List;

@@ -18,5 +17,17 @@

    List<BigStorageCageDetails> selectTask(int taskType);

    boolean selectGetBoard(GlassInfo glassInfo, String plcFeedReqLine);
    double selectGetBoard(String plcFeedReqLine);

    void deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);

    void damageBigStorageCageDetails(String glassId);

    BigStorageCageDetails selectBigStorageCageDetails(String glassId);

    void insertBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);

    void finishBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);

    void outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);
}

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

@@ -29,5 +29,5 @@

    List<Map<String, Object>> selectBigStorageCageUsage();

    boolean selectWidthSufficient(BigStorageCageDetails layoutSlotInfo,double width);
    void updateStorageCageDisabled(int slot,int enableState);
}

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

@@ -1,18 +1,20 @@
package com.mes.bigstorage.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.bigstorage.entity.BigStorageCage;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.mapper.BigStorageCageMapper;
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.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.glassinfo.entity.GlassInfo;
import org.springframework.beans.factory.annotation.Autowired;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
@@ -29,12 +31,18 @@
 * @since 2024-03-27
 */
@Service
public class BigStorageCageDetailsServiceImpl extends ServiceImpl<BigStorageCageDetailsMapper, BigStorageCageDetails> implements BigStorageCageDetailsService {
public class BigStorageCageDetailsServiceImpl extends MPJBaseServiceImpl<BigStorageCageDetailsMapper, BigStorageCageDetails> implements BigStorageCageDetailsService {

    @Resource
    private BigStorageCageOutTaskMapper bigStorageCageOutTaskMapper;
    @Resource
    private BigStorageCageFeedTaskMapper bigStorageCageFeedTaskMapper;
    @Resource
    private TemperingGlassInfoMapper temperingGlassInfoMapper;
    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private GlassInfoMapper glassInfoMapper;

    /**
     * 查询进/出片任务
@@ -82,13 +90,18 @@
     * 判断当前玻璃是否能上车
     */
    @Override
    public boolean selectGetBoard(GlassInfo glassInfo, String plcFeedReqLine){
    public double selectGetBoard(String plcFeedReqLine){
        double carWidth=5000;
        LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
        feedWrapper.eq(BigStorageCageDetails::getState, plcFeedReqLine);

        List<BigStorageCageDetails> bigStorageCageDetailsList=baseMapper.selectList(feedWrapper);
        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList=bigStorageCageFeedTaskMapper.selectList(null);

        LambdaQueryWrapper<BigStorageCageFeedTask> bigStorageCageFeedTaskWrapper = new LambdaQueryWrapper<>();
        bigStorageCageFeedTaskWrapper
                .eq(BigStorageCageFeedTask::getTaskState,plcFeedReqLine)
                .eq(BigStorageCageFeedTask::getLine,plcFeedReqLine);

        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList=bigStorageCageFeedTaskMapper.selectList(bigStorageCageFeedTaskWrapper);
        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
@@ -101,11 +114,96 @@
                carWidth -= Integer.parseInt(bigStorageCageDetails.getWidth().toString()) + bigStorageCageDetails.getGap();
            }
        }
        if(carWidth>=0){
            return true;
        }else{
            return false;
        return carWidth;

        }


    //栓除出片任务.更新格子宽度
    @Override
    public void deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails){
        baseMapper.deleteById(bigStorageCageDetails.getId());
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
    }

    //理片笼详情破损
    @Override
    public void damageBigStorageCageDetails(String glassId){
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper=new LambdaQueryWrapper<>();
        temperingGlassInfoWrapper.eq(TemperingGlassInfo::getGlassId,glassId);
        TemperingGlassInfo temperingGlassInfo=temperingGlassInfoMapper.selectOne(temperingGlassInfoWrapper);

        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper=new LambdaQueryWrapper<>();
        bigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getGlassId,glassId);
        BigStorageCageDetails bigStorageCageDetails=baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if(temperingGlassInfo.getState()==-2){
            temperingGlassInfoMapper.deleteById(temperingGlassInfo);
        }else{
            temperingGlassInfo.setState(5);
            temperingGlassInfoMapper.updateById(temperingGlassInfo);
        }
        baseMapper.deleteById(bigStorageCageDetails.getId());
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
        //todo:插入破损数据

    }

    //查询玻璃信息
    @Override
    public BigStorageCageDetails selectBigStorageCageDetails(String glassId){
        LambdaQueryWrapper<GlassInfo> glassInfoWrapper=new LambdaQueryWrapper<>();
        glassInfoWrapper.eq(GlassInfo::getGlassId,glassId);
        GlassInfo glassInfo=glassInfoMapper.selectOne(glassInfoWrapper);
        BigStorageCageDetails bigStorageCageDetails=new BigStorageCageDetails();
        BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
        bigStorageCageDetails.setState(0);
        bigStorageCageDetails.setGap(20);
        return bigStorageCageDetails;
    }

    //理片笼详情添加
    @Override
    public void insertBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails){
        baseMapper.insert(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
    }

    //理片笼详情完成
    @Override
    public void finishBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails){
        if(bigStorageCageDetails.getState()==1||bigStorageCageDetails.getState()==2){
            bigStorageCageDetails.setState(0);
            baseMapper.updateById(bigStorageCageDetails);
            bigStorageCageFeedTaskMapper.deleteById(bigStorageCageDetails.getBigStorageCageFeedTask().getId());
        }else{
            baseMapper.deleteById(bigStorageCageDetails.getId());
            bigStorageCageOutTaskMapper.deleteById(bigStorageCageDetails.getBigStorageCageOutTask().getId());
        }

    }

    //手动出片
    @Override
    public void outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails){
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper =new LambdaQueryWrapper<>();
        temperingGlassInfoWrapper
                .eq(TemperingGlassInfo::getGlassId,bigStorageCageDetails.getGlassId());
        TemperingGlassInfo temperingGlassInfo=temperingGlassInfoMapper.selectOne(temperingGlassInfoWrapper);
        if(temperingGlassInfo.getGlassId()==null){
            LambdaQueryWrapper<GlassInfo> glassInfoWrapper=new LambdaQueryWrapper<>();
            glassInfoWrapper
                    .eq(GlassInfo::getGlassId,bigStorageCageDetails.getGlassId());
            GlassInfo glassInfo=glassInfoMapper.selectOne(glassInfoWrapper);
            TemperingGlassInfo temperingGlassInfo1=new TemperingGlassInfo();
            BeanUtils.copyProperties(glassInfo, temperingGlassInfo1);

            if(temperingGlassInfo.getTemperingLayoutId()!=null){
                temperingGlassInfo1.setState(-1);
            }else{
                temperingGlassInfo1.setState(-2);
            }
            temperingGlassInfoMapper.insert(temperingGlassInfo1);
        }
    }
}

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

@@ -3,7 +3,10 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
@@ -36,7 +39,7 @@
 */
@Service
@Slf4j
public class BigStorageCageServiceImpl extends ServiceImpl<BigStorageCageMapper, BigStorageCage> implements BigStorageCageService {
public class BigStorageCageServiceImpl extends MPJBaseServiceImpl<BigStorageCageMapper, BigStorageCage> implements BigStorageCageService {
    @Resource
    private BigStorageCageMapper bigStorageCageMapper;

@@ -52,29 +55,61 @@
    //进片逻辑
    @Override
    public BigStorageCageDetails feedGlass(GlassInfo glassInfo, BigStorageCageDetails bigStorageCageDetails) {

        LambdaQueryWrapper<BigStorageCageDetails> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1);
        BigStorageCageDetails layoutSlotInfo;
        layoutSlotInfo= bigStorageCageDetailsMapper.selectOne(wrapper);
        log.info("1、查询理片笼内片序-1等于当前玻璃片序的玻璃"+layoutSlotInfo);
        BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
        //玻璃不钢化时
        if(glassInfo.getTemperingLayoutId()==null){

        log.info("2、查询理片笼内片序-1等于当前玻璃片序的玻璃的结果不为空时"+layoutSlotInfo.getSlot());
        if (layoutSlotInfo.getSlot() != null&&selectWidthSufficient(layoutSlotInfo,bigStorageCageDetails.getWidth())) {
            bigStorageCageDetails.setSlot(layoutSlotInfo.getSlot());
            BigStorageCage bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                    .selectAll(BigStorageCage.class)
                    .leftJoin(BigStorageCageDetails.class, on -> on
                            .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                            .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                    .isNull(BigStorageCageDetails::getTemperingLayoutId)
                    .gt(BigStorageCage::getRemainWidth, 2000)
                    .orderByAsc(BigStorageCage::getDeviceId, BigStorageCage::getSlot)
                    .last("limit 1")
            );

            if(bigStorageCage.getSlot()!=null){
                bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                bigStorageCageDetails.setDeviceId(bigStorageCage.getDeviceId());
            }
        }else{
            //玻璃钢化时
            BigStorageCage bigStorageCage=new BigStorageCage();

            bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                    .selectAll(BigStorageCage.class)
                    .leftJoin(BigStorageCageDetails.class, on -> on
                            .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                            .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                    .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                    .eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1)
                    .gt(BigStorageCage::getRemainWidth, glassInfo.getWidth())
            );
            log.info("1、查询理片笼内片序-1等于当前玻璃片序的玻璃"+bigStorageCage);

            log.info("2、查询理片笼内片序-1等于当前玻璃片序的玻璃的结果不为空时"+bigStorageCage.getSlot());
            if (bigStorageCage.getSlot() != null) {
                bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                bigStorageCageDetails.setDeviceId(bigStorageCage.getDeviceId());
        } else {
            log.info("3、查询理片笼内片序-1等于当前玻璃片序的玻璃的结果为空时获取当前玻璃版图id是否存在理片笼内");
            LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailslambdaQueryWrapper = new LambdaQueryWrapper<>();
            bigStorageCageDetailslambdaQueryWrapper
                    .select(BigStorageCageDetails::getTemperingLayoutId);
            layoutSlotInfo = bigStorageCageDetailsMapper.selectOne(bigStorageCageDetailslambdaQueryWrapper);

            if(layoutSlotInfo != null&&selectWidthSufficient(layoutSlotInfo,bigStorageCageDetails.getWidth())){
                bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                        .selectAll(BigStorageCage.class)
                        .leftJoin(BigStorageCageDetails.class, on -> on
                                .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                                .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                        .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                        .gt(BigStorageCage::getRemainWidth, glassInfo.getWidth())
                );

                if(bigStorageCage != null){
                log.info("4、获取笼子内适合的格子");
                BigStorageCage bigStorageCage=bigStorageCageSlot(layoutSlotInfo.getDeviceId());
                bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                    BigStorageCage bigStorageCages=bigStorageCageSlot(bigStorageCage.getDeviceId());
                    bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                    bigStorageCageDetails.setDeviceId(bigStorageCages.getDeviceId());
            }else{
                log.info("5、获取每个笼子版图id的个数");
                QueryWrapper<BigStorageCageDetails> queryWrapper = new QueryWrapper<>();
@@ -90,9 +125,10 @@
                for (Map<String, Object> map : bigStorageCageDetailsCount) {
                    for (Map.Entry<String, Object> entry : map.entrySet()) {
                        int deviceId = Integer.parseInt(entry.getKey());
                        BigStorageCage bigStorageCage=bigStorageCageSlot(deviceId);
                            BigStorageCage bigStorageCages=bigStorageCageSlot(deviceId);
                        if(bigStorageCage!=null){
                            bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                                bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                                bigStorageCageDetails.setDeviceId(deviceId);
                            found=true;
                            break;
                        }
@@ -103,6 +139,9 @@
                }
            }
        }
        }



        if (bigStorageCageDetails.getSlot() != null) {
            log.info("6、当找到合适的格子时添加玻璃到笼子表");
@@ -138,27 +177,34 @@
            return true;
        }else{
            log.info("3、没有可出的玻璃时获取是否有小片到齐的版图");
            LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailslambdaQueryWrapper = new LambdaQueryWrapper<>();
            bigStorageCageDetailslambdaQueryWrapper
                    .select(BigStorageCageDetails::getTemperingLayoutId)
                    .groupBy(BigStorageCageDetails::getTemperingLayoutId);
            List<Map<String, Object>> temperingLayoutIdList = bigStorageCageDetailsMapper.selectMaps(bigStorageCageDetailslambdaQueryWrapper);
            for (Map<String, Object> map : temperingLayoutIdList) {
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    String layoutId = entry.getKey().substring(0, entry.getKey().indexOf('-'));
                    String layoutNum = entry.getKey().substring(entry.getKey().indexOf('-') + 1);
                    if (layoutNum.equals(entry.getValue())) {
                        log.info("4、添加此钢化版图id所有小片小片到钢化小片表");

            QueryWrapper<BigStorageCageDetails> wrapper = Wrappers.query();
            wrapper.select("tempering_layout_id", "count(tempering_layout_id)")
                    .groupBy("tempering_layout_id");
            List<Map<String, Object>> temperingLayoutIdList = bigStorageCageDetailsMapper.selectMaps(wrapper);

            boolean key=false;
            for (Map<String, Object> row : temperingLayoutIdList) {
                for (Map.Entry<String, Object> entry : row.entrySet()) {
                    String temperingId = entry.getKey();
                    Object temperingNo = entry.getValue();

                        LambdaQueryWrapper<GlassInfo> glassInfoWrapper=new LambdaQueryWrapper<>();
                        glassInfoWrapper.select(GlassInfo::getTemperingLayoutId)
                        glassInfoWrapper.eq(GlassInfo::getTemperingLayoutId,temperingId)
                                .orderByDesc(GlassInfo::getTemperingFeedSequence);
                        List<GlassInfo> glassInfoList= glassInfoService.list(glassInfoWrapper);
                        if(glassInfoList.size()==Integer.parseInt(temperingNo.toString())){
                        for (GlassInfo glassInfo:glassInfoList
                             ) {

                            TemperingGlassInfo temperingGlassInfo=new TemperingGlassInfo();
                            BeanUtils.copyProperties(glassInfo, temperingGlassInfo);
                            temperingGlassInfoService.save(temperingGlassInfo);

                        }
                            key=true;
                        }
                    if(key){
                        return false;
                    }
                }
@@ -188,17 +234,17 @@
    //查询大理片信息，前端展示用
    @Override
    public List<BigStorageCage> querybigStorageCageDetail(int deviceId) {
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper =new LambdaQueryWrapper<>();
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper =new LambdaQueryWrapper<>();
        if(deviceId!=0){
            bigStorageCageWrapper.eq(BigStorageCage::getDeviceId,deviceId);
            bigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getDeviceId,deviceId);
        }

        LambdaQueryWrapper<BigStorageCage> BigStorageCageWrapper =new LambdaQueryWrapper<>();
        BigStorageCageWrapper.eq(BigStorageCage::getSlot,deviceId);

        LambdaQueryWrapper<BigStorageCageDetails> BigStorageCageDetailsWrapper =new LambdaQueryWrapper<>();
        BigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getSlot,deviceId);

        List<BigStorageCage> bigStorageCages = bigStorageCageMapper.selectList(BigStorageCageWrapper);
        List<BigStorageCage> bigStorageCages = bigStorageCageMapper.selectList(bigStorageCageWrapper);
        log.info("1、获取大理片笼信息完成，获取到的数据{}", bigStorageCages.size());

        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(BigStorageCageDetailsWrapper);
        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);

        Map<Integer, List<BigStorageCageDetails>> listMap = bigStorageCageDetailsList.stream().collect(Collectors.groupingBy(BigStorageCageDetails::getSlot));
        for (BigStorageCage bigStorageCage : bigStorageCages) {
@@ -212,24 +258,21 @@
    @Override
    public List<Map<String, Object>> selectBigStorageCageUsage() {
        QueryWrapper<BigStorageCage> wrapper = new QueryWrapper<>();
        wrapper.select("device_id")
                .select("ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2) AS percentage")
                .select("COUNT(device_id) - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")
        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2) AS percentage,COUNT(device_id) - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")

                .groupBy("device_id");
        List<Map<String, Object>> bigStorageCageUsages=baseMapper.selectMaps(wrapper);

        return bigStorageCageUsages;
    }

    //判断笼子剩余宽度是否足够
    //笼子的启用/禁用
    @Override
    public boolean selectWidthSufficient(BigStorageCageDetails layoutSlotInfo,double width) {
        LambdaQueryWrapper<BigStorageCage> BigStorageCageWrapper = new LambdaQueryWrapper<>();
        BigStorageCageWrapper.eq(BigStorageCage::getSlot,layoutSlotInfo.getSlot());
        BigStorageCage bigStorageCage=baseMapper.selectOne(BigStorageCageWrapper);
        if(bigStorageCage.getRemainWidth()>width){
            return true;
        }else{
            return false;
        }
    public void updateStorageCageDisabled(int slot,int enableState){
        BigStorageCage bigStorageCage=new BigStorageCage();
        bigStorageCage.setEnableState(enableState);
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper = new LambdaQueryWrapper<>();
        bigStorageCageWrapper.eq(BigStorageCage::getSlot,slot);
        baseMapper.update(bigStorageCage,bigStorageCageWrapper);
    }
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragetask/controller/BigStorageCageFeedTaskController.java

@@ -27,10 +27,10 @@

    @Autowired
    private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
    @ApiOperation("进片任务信息")
    @GetMapping("/querybigStorageCageTask")
    public List<BigStorageCageFeedTask> querybigStorageCageFeedTask(int taskState) {
        return bigStorageCageFeedTaskService.querybigStorageCageFeedTask(taskState);
    }
//    @ApiOperation("进片任务信息")
//    @GetMapping("/querybigStorageCageFeedTask")
//    public List<BigStorageCageFeedTask> querybigStorageCageFeedTask(int taskState) {
//        return bigStorageCageFeedTaskService.querybigStorageCageFeedTask(taskState);
//    }
}


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragetask/controller/BigStorageCageOutTaskController.java

@@ -27,11 +27,11 @@

    @Autowired
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @ApiOperation("进片任务信息")
    @GetMapping("/querybigStorageCageTask")
    public List<BigStorageCageOutTask> querybigStorageCageOutTask(int taskState) {
        return bigStorageCageOutTaskService.querybigStorageCageOutTask(taskState);
    }
//    @ApiOperation("出片任务信息")
//    @GetMapping("/querybigStorageCageOutTask")
//    public List<BigStorageCageOutTask> querybigStorageCageOutTask(int taskState) {
//        return bigStorageCageOutTaskService.querybigStorageCageOutTask(taskState);
//    }

}


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragetask/entity/BigStorageCageFeedTask.java

@@ -17,7 +17,7 @@
 * @author zhoush
 * @since 2024-04-16
 */
@ApiModel(description = "<p>  </p>")
@ApiModel(description = "<p> 理片进笼任务 </p>")
@Data
@EqualsAndHashCode(callSuper = false)
public class BigStorageCageFeedTask implements Serializable {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragetask/entity/BigStorageCageOutTask.java

@@ -17,7 +17,7 @@
 * @author zhoush
 * @since 2024-04-16
 */
@ApiModel(description = "<p>  </p>")
@ApiModel(description = "<p> 理片出笼任务 </p>")
@Data
@EqualsAndHashCode(callSuper = false)
public class BigStorageCageOutTask implements Serializable {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/edgglasstask/entity/EdgGlassTaskInfo.java

@@ -1,9 +1,11 @@
package com.mes.edgglasstask.entity;

import cn.hutool.core.date.DateTime;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import net.sf.jsqlparser.expression.DateTimeLiteralExpression;

import java.io.Serializable;

@@ -67,5 +69,10 @@
    @ApiModelProperty(value = "线路", position = 8)
    private Integer line;

    /**
     * 线路
     */
    @ApiModelProperty(value = "时间", position = 9)
    private DateTime time;

}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/edgglasstask/service/EdgGlassTaskInfoService.java

@@ -13,4 +13,7 @@
 */
public interface EdgGlassTaskInfoService extends IService<EdgGlassTaskInfo> {

    int judgeTasktype(String plcFeedReqLine);

    int startTask();
}

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

@@ -1,10 +1,16 @@
package com.mes.edgglasstask.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.mapper.EdgGlassTaskInfoMapper;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import org.springframework.stereotype.Service;

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

/**
 * <p>
@@ -17,4 +23,62 @@
@Service
public class EdgGlassTaskInfoServiceImpl extends ServiceImpl<EdgGlassTaskInfoMapper, EdgGlassTaskInfo> implements EdgGlassTaskInfoService {

    @Resource
    BigStorageCageDetailsService bigStorageCageDetailsService;
    @Override
    public int judgeTasktype(String plcFeedReqLine){
        LambdaQueryWrapper<EdgGlassTaskInfo> edgGlassTaskInfoWrapper=new LambdaQueryWrapper<>();
        edgGlassTaskInfoWrapper
                .eq(EdgGlassTaskInfo::getLine,plcFeedReqLine)
                .orderByDesc(EdgGlassTaskInfo::getTime);
        EdgGlassTaskInfo edgGlassTaskInfo=baseMapper.selectOne(edgGlassTaskInfoWrapper);
        double width=bigStorageCageDetailsService.selectGetBoard(plcFeedReqLine);
        if(edgGlassTaskInfo.getWidth()<width){
            return 0;
        }else{
            return 1;
        }
    }

    @Override
    public int startTask(){

        double line1Width=bigStorageCageDetailsService.selectGetBoard("1");
        double line2Width=bigStorageCageDetailsService.selectGetBoard("2");

        LambdaQueryWrapper<EdgGlassTaskInfo> edgGlassTaskInfoWrapper=new LambdaQueryWrapper<>();
        edgGlassTaskInfoWrapper
                .eq(EdgGlassTaskInfo::getLine,1)
                .orderByDesc(EdgGlassTaskInfo::getTime);
        List<EdgGlassTaskInfo> edgGlassTaskInfoList1=baseMapper.selectList(edgGlassTaskInfoWrapper);
        int i=0;
        for (EdgGlassTaskInfo edgGlassTaskInfo:edgGlassTaskInfoList1
             ) {
            if(edgGlassTaskInfo.getWidth()<line1Width){
                i+=1;
                line1Width-=edgGlassTaskInfo.getWidth()+20;
            }
        }
        if(i==2){
            return 2;
        }

        edgGlassTaskInfoWrapper
                .eq(EdgGlassTaskInfo::getLine,2)
                .orderByDesc(EdgGlassTaskInfo::getTime);
        List<EdgGlassTaskInfo> edgGlassTaskInfoList2=baseMapper.selectList(edgGlassTaskInfoWrapper);
        i=0;
        for (EdgGlassTaskInfo edgGlassTaskInfo:edgGlassTaskInfoList2
        ) {
            if(edgGlassTaskInfo.getWidth()<line2Width){
                i+=1;
                line2Width-=edgGlassTaskInfo.getWidth()+20;
            }
        }
        if(i==2) {
            return 1;
        }else{
            return 2;
        }
    }
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/edgstoragetask/service/TaskCacheService.java

@@ -13,5 +13,4 @@
 */
public interface TaskCacheService extends IService<TaskCache> {

    int judgeTasktype();
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/edgstoragetask/service/impl/TaskCacheServiceImpl.java

@@ -24,30 +24,6 @@
@Qualifier("")
@Service
public class TaskCacheServiceImpl extends ServiceImpl<TaskCacheMapper, TaskCache> implements TaskCacheService {
    @Resource
    private BigStorageCageFeedTaskMapper bigStorageCageFeedTaskMapper;
    @Override
    public int judgeTasktype(){
        //判断根据当前卧转立任务与磨边线任务判断是否启动卧转立
//        for (int i=1;i<=2;i++){
//            //查询卧转立当前任务
//            int width=5000;
//            int num=0;
//            List<BigStorageCageFeedTask> bgStorageCageFeedTask =bigStorageCageFeedTaskMapper.();
//            //查询磨边线当前任务
//            LambdaQueryWrapper<TaskCache> taskCacheWrapper=new LambdaQueryWrapper<>();
//            taskCacheWrapper.eq(TaskCache::getTaskStauts,"0");
//            List<TaskCache> taskCacheList=taskCacheService.list(taskCacheWrapper);
//            //判断当前线路还需要再上几片才能满足小车宽度
//            for (TaskCache taskCache:taskCacheList
//            ) {
//                if(taskCache.getId().equals("1")){
//                    //进片车宽度减去小片宽度
//                }
//            }
//            //片数小于等于2时另一条线卧转立启动
//            log.info("发送卧转立启动信号");
//        }
        return 0;
    }


}

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

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

import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.device.PlcParameterObject;
import com.mes.edgstoragetask.service.TaskCacheService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.menu.service.SysMenuService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.WebSocketServer;
@@ -29,6 +18,9 @@
import java.util.List;
import java.util.Map;

/**
 * @author SNG-015
 */
@Component
@Slf4j
public class PlcSlicecage {
@@ -40,7 +32,6 @@
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
@@ -78,7 +69,11 @@
            //报警信息
            jsonObject.append("bigStorageCageFullAlarm", PlcStorageCageTask.bigStorageCageFullAlarm);

            ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("Home");
            //理片笼表格信息
            jsonObject.append("bigStorageCageInfo", bigStorageCageService.querybigStorageCageDetail(0));


            ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("slicecage");
            if (sendwServer != null) {
                for (WebSocketServer webserver : sendwServer) {
                    if (webserver != null) {

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

@@ -8,9 +8,11 @@
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.device.PlcParameterObject;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.edgstoragetask.service.TaskCacheService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@@ -18,6 +20,9 @@
import javax.annotation.Resource;
import java.util.List;

/**
 * @author SNG-015
 */
@Component
@Slf4j
public class PlcStorageCageTask {
@@ -33,11 +38,17 @@
    @Resource
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private TaskCacheService taskCacheService;
    private EdgGlassTaskInfoService edgGlassTaskInfoService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;

    public static boolean bigStorageCageFullAlarm = false;

    private int line1Time=0;
    private int line2Time=0;

    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
@@ -56,16 +67,18 @@
                plcFeedReqLine = "2";
                plcFeedGlassid=plcParameterObject.getPlcParameter("D04ID1").getValue();
            }
            line1Time+=1;
            line2Time+=1;

            if (!("0".equals(plcFeedReqLine))) {
                log.info("1、Plc进片请求时");
                BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
                GlassInfo glassInfo = glassInfoService.getById(plcFeedGlassid);
                log.info("2、根据玻璃id获取玻璃信息" + glassInfo);
                if(bigStorageCageDetailsService.selectGetBoard(glassInfo,plcFeedReqLine)){
                if(bigStorageCageDetailsService.selectGetBoard(plcFeedReqLine)>=0){
                    BigStorageCageDetails slotInfo = bigStorageCageService.feedGlass(glassInfo, bigStorageCageDetails);
                    if (slotInfo != null) {
                        int taskType = taskCacheService.judgeTasktype();
                        int taskType = edgGlassTaskInfoService.judgeTasktype(plcFeedReqLine);
                        log.info("3、查询任务表判断当前任务类型为上车等到还是上车启动" + taskType);
                        bigStorageCageFeedTaskService.addFeedTask(slotInfo, Integer.parseInt(plcFeedReqLine), taskType);
                        log.info("4、添加任务到任务表");
@@ -94,17 +107,39 @@
                    bigStorageCageFeedTaskService.removeById(bigStorageCageFeedTask);
                    log.info("7、删除已经完成的进片任务");
                }
                //启动阈值
                if(line1Time>=300){
                    if("0".equals(plcParameterObject.getPlcParameter("D05Go").getValue())){
                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
                    }
                }
                if(line2Time>=300){
                    if("0".equals(plcParameterObject.getPlcParameter("D02Go").getValue())){
                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
                    }
                }
            }

            //查询出片表是否有任务未完成的任务
            List<BigStorageCageOutTask> bigStorageCageOutTask=bigStorageCageOutTaskService.querybigStorageCageOutTask(0);
            if(bigStorageCageOutTask.size()==0){
                bigStorageCageService.outGlass();
                boolean result=bigStorageCageService.outGlass();
                log.info("8、没有未完成任务时调用出片接口");
                if (result==false){
                    temperingGlassInfoService.schedulingTask();
                }
            }
            bigStorageCageOutTaskService.updateOutTask();
            log.info("9、根据任务表状态修改钢化小片表任务状态");

            //来不及送时直接走
            String line=Integer.toString(edgGlassTaskInfoService.startTask());

            if(!(line.equals(plcFeedReqLine))){
                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
            }else{
                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
            }


        } catch (Exception e) {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/temperingglass/controller/TemperingGlassInfoController.java

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


import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
@@ -32,18 +33,21 @@

    @Autowired
    private TemperingGlassInfoService temperingGlassInfoService;
    @Autowired
    private BigStorageCageDetailsService bigStorageCageDetailsService;

    @ApiOperation("钢化小片信息")
    @GetMapping("/queryTemperingGlassInfo")
    public Result queryTemperingGlassInfo() {
        return Result.build(200,"查询成功",temperingGlassInfoService.list());
    @ApiOperation("出片任务删除")
    @PostMapping("/deleteTemperingGlassInfo")
    public Result deleteTemperingGlassInfo(TemperingGlassInfo temperingGlassInfo) {
        temperingGlassInfoService.removeById(temperingGlassInfo);
        return Result.build(200,"删除成功",1);
    }

    @ApiOperation("手动添加出片任务")
    @PostMapping("/insertTemperingGlassInfo")
    public Result insertBigStorageCageDetail(TemperingGlassInfo temperingGlassInfo) {
        temperingGlassInfoService.save(temperingGlassInfo);
        return Result.build(200,"添加成功",1);
    @ApiOperation("出片任务破损")
    @PostMapping("/damageTemperingGlassInfo")
    public Result damageTemperingGlassInfo(TemperingGlassInfo temperingGlassInfo) {
        bigStorageCageDetailsService.damageBigStorageCageDetails(temperingGlassInfo.getGlassId());
        return Result.build(200,"破损成功",1);
    }
}


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/temperingglass/service/TemperingGlassInfoService.java

@@ -17,4 +17,5 @@

    public void addOutTask(List<TemperingGlassInfo> temperingGlassInfoList);

    void schedulingTask();
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/temperingglass/service/impl/TemperingGlassInfoServiceImpl.java

@@ -1,14 +1,26 @@
package com.mes.temperingglass.service.impl;

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.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.mapper.BigStorageCageMapper;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

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

/**
 * <p>
@@ -22,6 +34,11 @@
@Service
public class TemperingGlassInfoServiceImpl extends ServiceImpl<TemperingGlassInfoMapper, TemperingGlassInfo> implements TemperingGlassInfoService {

    @Resource
    private BigStorageCageDetailsMapper bigStorageCageDetailsMapper;
    @Resource
    private BigStorageCageMapper bigStorageCageMapper;

    @Override
    public void addOutTask(List<TemperingGlassInfo> temperingGlassInfoList) {
        double carWidth=5000;
@@ -33,7 +50,7 @@
            if((carWidth-temperingGlassInfo.getWidth())>0){
                carWidth-=temperingGlassInfo.getWidth()+gap;
                log.info("2、添加钢化小片表信息到任务表");
                temperingGlassInfo.setState(0);
                temperingGlassInfo.setState(-1);
                baseMapper.updateById(temperingGlassInfo);
                log.info("3、修改钢化小片表任务状态");
                BigStorageCageOutTask bigStorageCageOutTask =new BigStorageCageOutTask();
@@ -44,4 +61,68 @@
        }
    }

    //调度
    @Override
    public void schedulingTask(){
        QueryWrapper<BigStorageCageDetails> detailsWrapper1 = Wrappers.query();
        detailsWrapper1.select("tempering_layout_id", "count(distinct slot)")
                .groupBy("tempering_layout_id");
        List<Map<String, Object>> temperingLayoutIdList = bigStorageCageDetailsMapper.selectMaps(detailsWrapper1);

        boolean key=false;
        for (Map<String, Object> row : temperingLayoutIdList) {
            for (Map.Entry<String, Object> entry : row.entrySet()) {
                String temperingId = entry.getKey();
                int temperingNo = Integer.parseInt(entry.getValue().toString());
                if(temperingNo>8){
                    QueryWrapper<BigStorageCageDetails> detailsWrapper2 = Wrappers.query();
                    detailsWrapper2.select("tempering_layout_id", "slot")
                            .select("max(tempering_feed_sequence) as max_sequence", "min(tempering_feed_sequence) as min_sequence")
                            .groupBy("tempering_layout_id", "slot")
                            .orderByAsc("tempering_layout_id")
                            .orderByDesc("min_sequence");

                    List<Map<String, Object>> result = bigStorageCageDetailsMapper.selectMaps(detailsWrapper2);
                    for (Map<String, Object> rows : result) {
                        // 获取每行的值
                        Object temperingLayoutId = rows.get("tempering_layout_id");
                        int slot = Integer.parseInt(rows.get("slot").toString());
                        int maxSequence = Integer.parseInt(rows.get("max_sequence").toString());
                        int minSequence = Integer.parseInt(rows.get("min_sequence").toString());

                        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper=new LambdaQueryWrapper<>();
                        bigStorageCageWrapper.eq(BigStorageCage::getSlot,slot);
                        BigStorageCage bigStorageCage=bigStorageCageMapper.selectOne(bigStorageCageWrapper);
                        Integer remainWidth=5000-bigStorageCage.getRemainWidth();

                        BigStorageCage bigStorageCages=bigStorageCageMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                                .selectAll(BigStorageCage.class)
                                .leftJoin(BigStorageCageDetails.class, on -> on
                                        .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                                        .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                                .gt(BigStorageCage::getRemainWidth,remainWidth)
                                .eq(BigStorageCageDetails::getTemperingLayoutId,temperingLayoutId)
                                .eq(BigStorageCageDetails::getTemperingFeedSequence,minSequence-1)
                        );

                        if(bigStorageCages.getSlot()!=null){
                            LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper=new LambdaQueryWrapper<>();
                            bigStorageCageDetailsWrapper
                                    .eq(BigStorageCageDetails::getSlot,slot)
                                    .orderByDesc(BigStorageCageDetails::getTemperingFeedSequence);
                            List<BigStorageCageDetails> bigStorageCageDetailsList=bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);
                            for (BigStorageCageDetails bigStorageCageDetails:bigStorageCageDetailsList
                                 ) {
                                BigStorageCageOutTask bigStorageCageOutTask=new BigStorageCageOutTask();
                                bigStorageCageOutTask.setTaskState(-3);
                                bigStorageCageOutTask.setStartSlot(slot);
                                bigStorageCageOutTask.setEndSlot(bigStorageCages.getSlot());
                            }
                            return;
                        }
                    }
                }
            }
        }
    }
}

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

@@ -37,7 +37,7 @@
    @Autowired
    private OptimizeProjectService optimizeProjectService;
    @ApiOperation("开始/暂停任务/传递工程号和状态,开始是1 暂停是0")
    @PostMapping("/pauseTask") //调用上片任务
    @PostMapping("/pauseTask") //暂停上片任务
    @ResponseBody
    public  Result <List<UpPattenUsage>> pauseTask(@RequestBody Engineering engineering) {
        boolean work=engineeringService.changeTask(engineering.getEngineerId(),engineering.getState());
@@ -46,6 +46,16 @@
        return Result.build(200, engineering.getEngineerId(),glass);
    }

    @ApiOperation("暂停")
    @PostMapping("/pause") //暂停上片任务
    @ResponseBody
    public  Result <List<UpPattenUsage>> pause(@RequestBody Engineering engineering) {
        boolean work=engineeringService.changeTask(engineering.getEngineerId(),engineering.getState());
        List<UpPattenUsage> glass = upPattenUsageService.prioritylist();
        log.info("StartorStop:{},{}", work,engineering);
        return Result.build(200, engineering.getEngineerId(),glass);
    }

    @ApiOperation("开始上片")
    @PostMapping("/changeTask") //调用上片任务
    @ResponseBody

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/TemperingGlassModuleApplication.java

@@ -5,6 +5,7 @@
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.scheduling.annotation.EnableScheduling;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
@@ -16,6 +17,7 @@
@SpringBootApplication
@EnableSwagger2
@EnableDiscoveryClient
@EnableScheduling
@MapperScan(basePackages = "com.mes.*.mapper")
public class TemperingGlassModuleApplication {
    public static void main(String[] args) {

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

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

import cn.hutool.json.JSONObject;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingAgoService;
import com.mes.tools.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * @author SNG-010
 */
@Component
@Slf4j
public class PlcTemperingGlassTask {

    @Autowired
    private TemperingAgoService temperingAgoService;
    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */

    @Scheduled(fixedDelay = 1000)
    public void loadGlassHome(){
        JSONObject jsonObject = new JSONObject();
        //正在等待进片的玻璃
        List<TemperingGlassInfo> waitingGlass = temperingAgoService.selectWaitingGlass();
        jsonObject.append("waitingGlass", waitingGlass);
        //进炉中的玻璃
        List<TemperingGlassInfo> intoGlass = temperingAgoService.selectIntoGlass();
        jsonObject.append("intoGlass", intoGlass);
        //出炉后的玻璃
        List<TemperingGlassInfo> outGlass = temperingAgoService.selectOutGlass();
        jsonObject.append("outGlass", outGlass);
        //过旋转台钢化后的玻璃
        TemperingGlassInfo overGlass = temperingAgoService.selectOverGlass();
        jsonObject.append("overGlass", overGlass);

        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("temperingGlass");
        if (sendwServer != null) {
            for (WebSocketServer webserver : sendwServer) {
                if (webserver != null) {
                    webserver.sendMessage(jsonObject.toString());
                } else {
                    log.info("Home is closed");
                }
            }
        }
    }

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/temperingglass/controller/TemperingGlassInfoController.java

@@ -25,8 +25,6 @@
    @Autowired
    TemperingService temperingService;
    @Autowired
    private TemperingOverService temperingOverService;
    @Autowired
    private TemperingAgoService temperingAgoService;

    @ApiOperation("查询钢化等片中的版图信息,状态为1的为已到,状态为0的为等待中")
@@ -46,7 +44,7 @@
    @ApiOperation("//钢化后显示出炉的版图信息。")
    @GetMapping("/selectOutGlass") //钢化后显示出炉的版图信息
    public Result <List<TemperingGlassInfo>> selectOutGlass() {
        List<TemperingGlassInfo> glass = temperingAgoService.SelectOutGlass();
        List<TemperingGlassInfo> glass = temperingAgoService.selectOutGlass();
        log.info("钢化出炉后的玻璃信息{}",glass);
        return Result.build(200, "", glass);
    }

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/temperingglass/mapper/TemperingGlassInfoMapper.java

@@ -1,5 +1,6 @@
package com.mes.temperingglass.mapper;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.temperingglass.entity.TemperingGlassInfo;
@@ -12,6 +13,7 @@
 * @author zhoush
 * @since 2024-04-07
 */
@DS("salve_hangzhoumes")
public interface TemperingGlassInfoMapper extends BaseMapper<TemperingGlassInfo>, MPJBaseMapper<TemperingGlassInfo> {

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/temperingglass/mapper/TemperingMapper.java

@@ -1,5 +1,6 @@
package com.mes.temperingglass.mapper;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import org.apache.ibatis.annotations.Mapper;
@@ -8,27 +9,7 @@
import java.util.List;

@Mapper
@DS("salve_hangzhoumes")
public interface TemperingMapper extends BaseMapper<TemperingGlassInfo> {


    //查询该玻璃的尺寸和坐标
//@Select("select *from glass_info where id=#{glassid};")
//GlassInfo SelectGlass(String glassid);
//是否可以发送进炉信号
    @Select("select count(*) from glass_info where id=#{glassid};")
    int SelectTempering(String glassid);

    //查询等待中的钢化版图玻璃信息
    @Select("select*from tempering_glass_info a left join (select flowcard_id,count(state)state from tempering_glass_info GROUP BY flowcard_id,state)b on a.flowcard_id=b.flowcard_id where b.state=2")
    List<TemperingGlassInfo> SelectWaitingGlass();

    //查询进炉中的钢化版图玻璃信息
    @Select("select*from tempering_glass_info a left join (select flowcard_id,min(state)state1 from tempering_glass_info GROUP BY flowcard_id having state1=1)b on a.flowcard_id=b.flowcard_id where b.state1=1")
    List<TemperingGlassInfo> SelectInGlass();

    //查询钢化后的钢化版图信息
    @Select("select*from tempering_glass_info a left join (select flowcard_id,min(state)state1 from tempering_glass_info GROUP BY flowcard_id having state1=2)b on a.flowcard_id=b.flowcard_id where b.state1=2")
    List<TemperingGlassInfo> SelectOutGlass();


}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/temperingglass/service/TemperingAgoService.java

@@ -1,6 +1,4 @@
package com.mes.temperingglass.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.github.yulichang.base.MPJBaseService;
import java.util.List;
@@ -19,5 +17,7 @@

    List<TemperingGlassInfo> selectIntoGlass();

    List<TemperingGlassInfo> SelectOutGlass();
    List<TemperingGlassInfo> selectOutGlass();

    TemperingGlassInfo selectOverGlass();
}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/temperingglass/service/impl/TemperingAgoServiceImpl.java

@@ -1,9 +1,7 @@
package com.mes.temperingglass.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.mapper.TemperingMapper;
@@ -11,8 +9,6 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.github.yulichang.base.MPJBaseServiceImpl;

import java.util.Collections;
import java.util.List;

/**
@@ -24,6 +20,7 @@
 * @since 2024-04-07
 */
@Service
@DS("salve_hangzhoumes")
public class TemperingAgoServiceImpl extends MPJBaseServiceImpl<TemperingGlassInfoMapper, TemperingGlassInfo> implements TemperingAgoService {
    @Autowired
    TemperingMapper temperingMapper;
@@ -32,7 +29,8 @@
    public List<TemperingGlassInfo> selectWaitingGlass() {
        //获取等待进炉中的玻璃信息
        QueryWrapper<TemperingGlassInfo> wrapper = new QueryWrapper<>();
        wrapper.inSql("flowcard_id", "select flowcard_id from tempering_glass_info GROUP BY flowcard_id,state having count(state) = 2");
        //wrapper.eq("state",1);
        wrapper.in("state",1,0);
        return temperingMapper.selectList(wrapper);
    }

@@ -40,16 +38,27 @@
    public List<TemperingGlassInfo> selectIntoGlass() {
        //获取进炉中的玻璃信息
        QueryWrapper<TemperingGlassInfo> wrapper = new QueryWrapper<>();
        wrapper.inSql("flowcard_id", "select flowcard_id from tempering_glass_info where state=1 GROUP BY flowcard_id,state having count(state) = 1");

        wrapper.eq("state",2)
                .orderByAsc("tempering_layout_id","tempering_feed_sequence");
        return temperingMapper.selectList(wrapper);
    }

    @Override
    public List<TemperingGlassInfo> SelectOutGlass() {
    public List<TemperingGlassInfo> selectOutGlass() {
        //获取出炉中的玻璃信息
        QueryWrapper<TemperingGlassInfo> wapper = new QueryWrapper<>();
        wapper.eq("state", 3);
        wapper.eq("state", 3)
                .orderByAsc("tempering_layout_id","tempering_feed_sequence");
        return temperingMapper.selectList(wapper);
    }

    @Override
    public TemperingGlassInfo selectOverGlass() {
        //获取过旋转台的玻璃
        QueryWrapper<TemperingGlassInfo> wapper = new QueryWrapper<>();
        wapper.select("top 1 *").eq("state", 4)
                .orderByAsc("tempering_layout_id")
                .orderByDesc("tempering_feed_sequence");
        return temperingMapper.selectOne(wapper);
    }
}

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

@@ -9,6 +9,11 @@
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        salve_hangzhoumes:
          url: jdbc:sqlserver://127.0.0.1:1433;databasename=hangzhoumes
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/application-loc.yml

@@ -9,6 +9,12 @@
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver

        salve_hangzhoumes:
            url: jdbc:sqlserver://127.0.0.1:1433;databasename=hangzhoumes
            username: sa
            password: beibo.123/
            driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/application-prod.yml

@@ -9,6 +9,12 @@
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver

        salve_hangzhoumes:
            url: jdbc:sqlserver://10.153.19.150:1433;databasename=hangzhoumes
            username: sa
            password: beibo.123/
            driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/TemperingGlassModule/src/test/java/com/mes/TemperingApplicationTest.java

@@ -10,7 +10,6 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
@@ -25,12 +24,8 @@
@SpringBootTest(classes = TemperingGlassModuleApplication.class)
public class TemperingApplicationTest {

    @Resource
    private OptimizeProjectMapper optimizeProjectMapper;
    @Autowired
    private TemperingAgoService temperingAgoService;
    @Autowired
    private GlassInfoService glassInfoService;


    @Test
@@ -40,7 +35,7 @@
    }
    @Test
    public void testFindPa2() {
        List<TemperingGlassInfo> glass = temperingAgoService.SelectOutGlass();
        List<TemperingGlassInfo> glass = temperingAgoService.selectOutGlass();
        log.info("已出中的玻璃：{}", Arrays.asList(glass));
    }

@@ -49,4 +44,9 @@
        List<TemperingGlassInfo> glass = temperingAgoService.selectWaitingGlass();
        log.info("等待中的玻璃：{}", Arrays.asList(glass));
    }
    @Test
    public void testFindPa4() {
        TemperingGlassInfo glass = temperingAgoService.selectOverGlass();
        log.info("等待中的玻璃：{}", Arrays.asList(glass));
    }
}