Merge remote-tracking branch 'origin/master'

zhoushihao

2 天以前 4e3b8155722b66e25df3c6fd42cc586b68dea391

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

@@ -6,33 +6,37 @@
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.common.collect.Lists;
import com.mes.base.entity.vo.BigStorageVO;
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.entity.dto.*;
import com.mes.bigstorage.entity.vo.BigStorageQueryVO;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask;
import com.mes.bigstoragecagetask.service.BigStorageCageHistoryTaskService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.common.config.Const;
import com.mes.common.config.ConstSysConfig;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.job.PlcStorageCageTask;
import com.mes.sysconfig.entity.SysConfig;
import com.mes.sysconfig.service.SysConfigService;
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;
@@ -70,26 +74,29 @@

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private PlcStorageCageTask plcStorageCageTask;
    private SysConfigService sysConfigService;


    @Resource
    private DamageService damageService;
    @Resource
    private RedisUtil redisUtil;

    @Value("${mes.minCount}")
    private int minCount;

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

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

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;
    @Resource
    BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService;
//
//    @Value("${mes.minCount}")
//    private int minCount;
//
//    @Value("${mes.slotWidth}")
//    private Integer slotWidth;
//
//    @Value("${mes.glassGap}")
//    private Integer glassGap;
//
//    @Value("${mes.sequence.order}")
//    private boolean sequenceOrder;


    @Override
@@ -165,7 +172,7 @@
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            if (bigStorageCageDetails.getBigStorageCageFeedTask().getTaskState() == 0) {
                carWidth = carWidth - bigStorageCageDetails.getWidth() - glassGap;
                carWidth = carWidth - bigStorageCageDetails.getWidth() - 250;
            }
        }
        return carWidth;
@@ -231,7 +238,7 @@
        if (glassInfo != null) {
            BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
            bigStorageCageDetails.setState(1);
            bigStorageCageDetails.setGap(glassGap);
            bigStorageCageDetails.setGap(250);
            bigStorageCageDetailsList = new ArrayList<>();
            bigStorageCageDetailsList.add(bigStorageCageDetails);
        }
@@ -269,6 +276,7 @@
    @Override
    public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
        BigStorageDTO bigStorageDTO = null;
        int slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
                .selectAll(BigStorageCage.class)
                .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
@@ -296,7 +304,7 @@
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
//                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where engineer_id = '" + glassInfo.getEngineerId() + "' and tempering_layout_id = " + glassInfo.getTemperingLayoutId())
@@ -337,7 +345,7 @@
        }
        for (Integer item : deviceUsedList) {
            bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getRemainWidth, slotWidth)
                    .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                    .eq(BigStorageCage::getDeviceId, item)
                    .last("limit 1"));
@@ -380,7 +388,7 @@

    @Override
    public List<TemperingLayoutDTO> queryTemperingOccupySlot() {
        return baseMapper.queryTemperingOccupySlot(minCount);
        return baseMapper.queryTemperingOccupySlot(10);
    }

    @Override
@@ -391,24 +399,36 @@
    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId, String temperingFeedSequence) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        SysConfig sysConfig = sysConfigService.queryConfigById(ConstSysConfig.CACHE_SEQUENCE_ORDER_TRUE);
        boolean sequenceOrder = Boolean.parseBoolean(sysConfig.getConfigValue());
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        int dispatchCount = bigStorageCageHistoryTaskService.count(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_DISPATCH));

        if (temperingGlassInfoList.size() == 0) {
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
                    .select("-1 as state")
                    .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));

                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence);
            if (dispatchCount > 0) {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);
            } else {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            }
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, wrapper);
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                if ("0".equals(temperingFeedSequence)) {
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, "");
//                        plcStorageCageTask.computeOutMoreGlassInfo(temperingGlassInfos, Boolean.FALSE, "");
                    }
                } else {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
@@ -421,14 +441,62 @@


    @Override
    public List<Map<String, Object>> selectTemperingGlass() {
        List<Map<String, Object>> temperingGlass = baseMapper.selectTemperingGlassCount();
        return temperingGlass;
    public List<TemperingGlassCountDTO> selectTemperingGlass(int isTempering) {
        return baseMapper.selectTemperingGlassCount(isTempering);
    }

    @Override
    public void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state) {
        baseMapper.updateBySlot(glassList, state);
    }

    @Override
    public String dispatchSwitch(Boolean flag) {
        redisUtil.setCacheObject("dispatchSwitch", flag);
        return "success";
    }

    @Override
    public List<GlassInfoLackDTO> queryLackGlassInfo(BigStorageQueryVO bigStorageQueryVO) {
        return baseMapper.queryLackGlassInfo(bigStorageQueryVO);
    }

    @Override
    public List<BigStorageCageDetails> queryRealGlassInfo(BigStorageQueryVO bigStorageQueryVO) {
        return this.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getEngineerId, bigStorageQueryVO.getEngineerId())
                .eq(BigStorageCageDetails::getTemperingLayoutId, bigStorageQueryVO.getTemperingLayoutId())
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).orderByAsc(BigStorageCageDetails::getTemperingFeedSequence));
    }

    @Override
    public Map<Integer, List<BigStorageVO>> querybigStorageCageDetail() {
        List<BigStorageVO> bigStorageCages = baseMapper.querybigStorageCageDetail();
        return bigStorageCages.stream().collect(Collectors.groupingBy(item -> item.getDeviceId()));
    }

    @Override
    public boolean cancelTemperingTask() {
        //当前正在执行的出片任务
        List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTargetSlot, Const.TEMPERING_OUT_TARGET_POSITION));
        //不存在出片任务，直接删除钢化小片表未出片的任务
        if (CollectionUtils.isEmpty(historyTaskList)) {
            temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
            return Boolean.TRUE;
        }
        //存在出片任务，删除钢化小片表
        List<String> glassIdList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList)
                .orderByDesc(GlassInfo::getTemperingFeedSequence).last("limit 1"));
        temperingGlassInfoMapper.delete(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getEngineerId, glassInfo.getEngineerId())
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .ge(TemperingGlassInfo::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(TemperingGlassInfo::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence())
        );
        return Boolean.TRUE;
    }

    @Override
@@ -438,7 +506,66 @@
    }

    @Override
    public void appointEngineerId(String engineerId) {
        redisUtil.setCacheObject("temperingengineerId", engineerId);
    public boolean appointTemperingEngineerId(String engineerId) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        int dispatchCount = bigStorageCageHistoryTaskService.count(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                .eq(BigStorageCageHistoryTask::getTaskState, Const.GLASS_STATE_NEW)
                .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_DISPATCH));

        if (temperingGlassInfoList.size() == 0) {
            MPJLambdaWrapper<GlassInfo> wrapper = JoinWrappers.lambda(GlassInfo.class)
                    .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                            ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                            "t.angle,t1.slot,t.engineer_id")
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .ne(GlassInfo::getTemperingLayoutId, 0)
                    .orderByAsc(BigStorageCageDetails::getTemperingLayoutId)
                    .orderByAsc(BigStorageCageDetails::getTemperingFeedSequence);
            if (dispatchCount > 0) {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);
            } else {
                wrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            }
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, wrapper);

            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                //避免大量数据插入导致sqlserver数据库异常，分批次每调存储依次
                List<List<TemperingGlassInfo>> temperingGlassInfoLists = Lists.partition(temperingGlassInfos, 50);
                for (List<TemperingGlassInfo> item : temperingGlassInfoLists) {
                    temperingGlassInfoService.saveBatch(item);
                }
                return true;
            }
        }
        return false;
    }

    @Override
    public List<BigStorageRelationDTO> queryIsAllNeedDispatchVirtualSlot() {
        return baseMapper.queryIsAllNeedDispatchVirtualSlot();
    }

    @Override
    public List<BigStorageSequenceDTO> dispatchBigStorageGlassInfo(BigStorageRelationDTO bigStorageRelationDTO) {
        return baseMapper.queryNeedDispatchSlot(bigStorageRelationDTO);
    }

    @Override
    public String bigStorageGlassDamageByGlassId(String glassId) {
        Damage damage = new Damage();
        damage.setGlassId(glassId);
        damage.setType(Const.GLASS_STATE_DAMAGE);
        damageService.insertDamage(damage);
        return "success";
    }

    @Override
    public void updateDeviceIdBySlot(List<Integer> slotList) {
        baseMapper.updateDeviceIdBySlot(slotList);
    }
}