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

wangfei

2024-08-23 051613aa73be3e75af5a6dfdb86a722bcb5af094

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

@@ -1,75 +1,296 @@
package com.mes.bigstorage.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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.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;
import com.mes.bigstorage.mapper.BigStorageCageMapper;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.uppattenusage.entity.GlassInfo;
import org.springframework.beans.factory.annotation.Autowired;
import com.mes.common.config.Const;
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 lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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


/**
 * <p>
 *  服务实现类
 * 服务实现类
 * </p>
 *
 * @author zhoush
 * @since 2024-03-27
 */
@Service
public class BigStorageCageServiceImpl extends ServiceImpl<BigStorageCageMapper, BigStorageCage> implements BigStorageCageService {
    @Autowired
@Slf4j
public class BigStorageCageServiceImpl extends MPJBaseServiceImpl<BigStorageCageMapper, BigStorageCage> implements BigStorageCageService {
    @Resource
    private BigStorageCageMapper bigStorageCageMapper;
    @Autowired

    @Resource
    private BigStorageCageDetailsMapper bigStorageCageDetailsMapper;

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private GlassInfoService glassInfoService;

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

    //进片逻辑
    @Override
    public BigStorageCageDetails FeedGlass(GlassInfo glassInfo, BigStorageCageDetails bigStorageCageDetails) {
    public BigStorageCageDetails feedGlass(GlassInfo glassInfo, BigStorageCageDetails bigStorageCageDetails) {
        BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
        //玻璃不钢化时
        if (glassInfo.getTemperingLayoutId() == null) {

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

        //获取同钢化版图id可进片的格子
        BigStorageCageDetails layoutSlotInfo =bigStorageCageMapper.SelectTemperingFeedSlot(glassInfo);
        //有符合条件的格子时
        if (layoutSlotInfo!=null) {
            //将玻璃信息填入理片笼详情表
            bigStorageCageDetails.setSlot(layoutSlotInfo.getSlot());
        }else{
            //获取不到时：

            //获取可进片格子信息
            BigStorageCageDetails EmptySlotInfo=bigStorageCageMapper.SelectEmptyFeedSlot();
            if (EmptySlotInfo!=null){
                bigStorageCageDetails.setSlot(EmptySlotInfo.getSlot());
            }else{
                //获取其他笼格子-
                BigStorageCageDetails OtherSlotInfo=bigStorageCageMapper.SelectOtherFeedSlot();
                bigStorageCageDetails.setSlot(OtherSlotInfo.getSlot());
            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是否存在理片笼内");

                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 bigStorageCages = bigStorageCageSlot(bigStorageCage.getDeviceId());
                    bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                    bigStorageCageDetails.setDeviceId(bigStorageCages.getDeviceId());
                } else {
                    log.info("5、获取每个笼子版图id的个数");
                    QueryWrapper<BigStorageCageDetails> queryWrapper = new QueryWrapper<>();
                    queryWrapper.select("a.device_id", "COUNT(DISTINCT b.tempering_layout_id) AS layoutCount")
                            .groupBy("a.device_id")
                            .apply("LEFT JOIN (SELECT device_id, tempering_layout_id FROM big_storage_cage_details) b ON a.device_id = b.device_id AND a.slot = b.slot")
                            .orderByAsc("layoutCount")
                            .orderByAsc("a.device_id");
                    List<Map<String, Object>> bigStorageCageDetailsCount = bigStorageCageDetailsMapper.selectMaps(queryWrapper);

                    log.info("5、查询笼子内是否有合适的格子");
                    boolean found = false;
                    for (Map<String, Object> map : bigStorageCageDetailsCount) {
                        for (Map.Entry<String, Object> entry : map.entrySet()) {
                            int deviceId = Integer.parseInt(entry.getKey());
                            BigStorageCage bigStorageCages = bigStorageCageSlot(deviceId);
                            if (bigStorageCage != null) {
                                bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                                bigStorageCageDetails.setDeviceId(deviceId);
                                found = true;
                                break;
                            }
                        }
                        if (found) {
                            break;
                        }
                    }
                }
            }
        }

        updateRemainWidth(bigStorageCageDetails.getSlot());

        if (bigStorageCageDetails.getSlot() != null) {
            log.info("6、当找到合适的格子时添加玻璃到笼子表");
            bigStorageCageDetails.setState(0);
            bigStorageCageDetailsMapper.insert(bigStorageCageDetails);
            updateRemainWidth(bigStorageCageDetails.getSlot());
        }
        return bigStorageCageDetails;
    }

    //修改格子剩余宽度
    @Override
    public void updateRemainWidth(int Slot){
        //获取该格子内玻璃信息
        int width=5000;
        List<BigStorageCageDetails> bigStorageCageDetailsList= Collections.singletonList(bigStorageCageDetailsMapper.selectById(Slot));
        for (BigStorageCageDetails bigStorageCageDetails:bigStorageCageDetailsList
        ) {
            width-=Integer.parseInt(bigStorageCageDetails.getWidth().toString())+bigStorageCageDetails.getGap();
        }
        //修改格子剩余宽度
        bigStorageCageMapper.UpdateRemainWidth(Slot,width);
    //获取笼子内的空格子
    private BigStorageCage bigStorageCageSlot(Integer deviceId) {
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper = new LambdaQueryWrapper<>();
        bigStorageCageWrapper
                .eq(BigStorageCage::getRemainWidth, "5000")
                .eq(BigStorageCage::getEnableState, "0")
                .eq(BigStorageCage::getDeviceId, deviceId)
                .orderByAsc(BigStorageCage::getSlot)
                .last("LIMIT 1");
        return bigStorageCageMapper.selectOne(bigStorageCageWrapper);
    }

    //出片逻辑
    @Override
    public boolean outGlass() {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoWrapper.eq(TemperingGlassInfo::getState, -1);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(temperingGlassInfoWrapper);
        log.info("1、查询钢化小片任务表是否有待出玻璃" + temperingGlassInfoList.size());
        if (temperingGlassInfoList.size() > 0) {
            temperingGlassInfoService.addOutTask(temperingGlassInfoList);
            log.info("2、添加任务到任务表");
            return true;
        } else {
            log.info("3、没有可出的玻璃时获取是否有小片到齐的版图");

            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.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;
                    }
                }
            }
        }
        return false;
    }

    //计算格子剩余宽度
    @Override
    public void updateRemainWidth(int slot) {
        log.info("获取该格子内玻璃信息，计算格子剩余宽度");
        double width = 5000;
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper();
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getSlot, slot)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL);

        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            double widths = bigStorageCageDetails.getWidth();
            width = width - widths - glassGap;
        }
        //修改格子剩余宽度
        BigStorageCage bigStorageCage = new BigStorageCage();
        bigStorageCage.setRemainWidth((int) width);
        UpdateWrapper<BigStorageCage> bigStorageCageWrapper = new UpdateWrapper<>();
        bigStorageCageWrapper.eq("slot", slot);
        bigStorageCageMapper.update(bigStorageCage, bigStorageCageWrapper);
    }

    //查询大理片信息，前端展示用
    @Override
    public List<BigStorageCage> querybigStorageCageDetailAll() {
        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);
        return bigStorageCageMapper.selectJoinList(BigStorageCage.class, wrapper);
    }

    //查询大理片信息，前端展示用
    @Override
    public Map<Integer, List<BigStorageCage>> querybigStorageCageDetail() {

        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));
        List<BigStorageCage> bigStorageCages = bigStorageCageMapper.selectJoinList(BigStorageCage.class, wrapper);
        Map<Integer, List<BigStorageCage>> listMap = bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
        return listMap;
    }

    //笼子使用情况，界面展示用
    @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) AS percentage,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 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);
    }

    @Override
    public List<Integer> queryFreeDeviceByUsed(double thickness) {
        return baseMapper.queryFreeDeviceByUsed(thickness);
    }

    @Override
    public List<Integer> queryFreeDeviceByNotUsed(double thickness) {
        return baseMapper.queryFreeDeviceByNotUsed(thickness);
    }
}