义乌项目
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zhoushihao
2025-10-09 266ca8c80300d479351eed50fee5a30751a22fda 
 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassOutRelationInfoServiceImpl.java


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


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.mes.common.config.Const;


import com.mes.common.config.ConstSysConfig;


import com.mes.glassinfo.entity.GlassInfo;


import com.mes.glassinfo.service.GlassInfoService;


import com.mes.hollow.controller.HollowBigStorageCageController;


@@ -23,6 +24,8 @@


import com.mes.hollow.service.HollowGlassRelationInfoService;


import com.mes.hollowqueue.entity.HollowGlassQueueInfo;


import com.mes.hollowqueue.service.HollowGlassQueueInfoService;


import com.mes.largenscreen.entity.PieChartVO;


import com.mes.sysconfig.service.SysConfigService;


import com.mes.tools.DateUtil;


import com.mes.utils.Blank;


import com.mes.utils.RedisUtil;


@@ -32,8 +35,9 @@


import freemarker.template.Version;


import lombok.extern.slf4j.Slf4j;


import org.springframework.beans.BeanUtils;


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


import org.springframework.cache.annotation.Cacheable;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;




import javax.annotation.Resource;


import java.io.*;


@@ -61,24 +65,28 @@


    HollowFormulaDetailsService hollowFormulaDetailsService;


    @Resource


    HollowGlassRelationInfoService hollowGlassRelationInfoService;


    @Resource


    SysConfigService sysConfigService;




    @Resource


    RedisUtil redisUtil;




    @Value("${mes.glassGap}")


    private Integer glassGap;




    @Value("${mes.carWidth}")


    private Integer carWidth;


//    @Value("${mes.glassGap}")


//    private Integer glassGap;


//


//    @Value("${mes.carWidth}")


//    private Integer carWidth;




    private static final int ID_RATIO = 10;




    @Override


    @Transactional


    public HollowGlassOutRelationInfo receiveTask(HollowTaskRequest request) {


        return childrenTask(request, 0);


    }




    @Override


    @Transactional


    public HollowGlassOutRelationInfo forceOutGlass(HollowTaskRequest request) {


        return childrenTask(request, 1);


    }


@@ -87,6 +95,12 @@


    public Boolean dispatchHollowSwitch(Boolean flag) {


        redisUtil.setCacheObject("dispatchHollowSwitch", flag);


        return redisUtil.getCacheObject("dispatchHollowSwitch");


    }




    @Override


    public Boolean priorityHollowSwitch(Boolean flag) {


        redisUtil.setCacheObject("priorityHollowSwitch", flag);


        return redisUtil.getCacheObject("priorityHollowSwitch");


    }




    @Override


@@ -102,44 +116,44 @@


    }




    @Override


    public List<HollowGlassQueueInfo> appointHollowTaskDetails(String flowCardId, int cell) {


    public Map<String, List<HollowGlassQueueInfo>> appointHollowTaskDetails(int cell) {


        //按照流程卡及路线，查找对应的任务信息


        HollowGlassOutRelationInfo hollowGlassOutRelationInfo = this.getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()


        List<HollowGlassOutRelationInfo> hollowGlassOutRelationInfos = this.list(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()


                .in(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_NEW, Const.HOLLOW_FLOW_CARD_START, Const.HOLLOW_FLOW_CARD_PAUSE)


                .eq(HollowGlassOutRelationInfo::getFlowCardId, flowCardId)


                .eq(HollowGlassOutRelationInfo::getCell, cell).last("limit 1"));


        if (null == hollowGlassOutRelationInfo) {


            return new ArrayList<HollowGlassQueueInfo>();


                .eq(HollowGlassOutRelationInfo::getCell, cell));


        if (CollectionUtil.isEmpty(hollowGlassOutRelationInfos)) {


            return null;


        }


        List<Long> ids = hollowGlassOutRelationInfos.stream()


                .map(HollowGlassOutRelationInfo::getId) // 提取每个元素的id


                .collect(Collectors.toList());


        //按照任务id查询对列表中的队列信息


        return hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()


                .eq(HollowGlassQueueInfo::getRelationId, hollowGlassOutRelationInfo.getId()));


        List<HollowGlassQueueInfo> hollowGlassQueueInfos = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()


                .in(HollowGlassQueueInfo::getRelationId, ids)


                .orderByAsc(HollowGlassQueueInfo::getId));


        Map<String, List<HollowGlassQueueInfo>> groupedByFlowCardId = hollowGlassQueueInfos.stream()


                .collect(Collectors.groupingBy(


                        HollowGlassQueueInfo::getFlowCardId,


                        LinkedHashMap::new,


                        Collectors.toList()


                ));


        return groupedByFlowCardId;


    }




    @Override


    public Boolean startTask(String flowCardId, int cell) {


        log.info("查看该流程卡是否由正在执行的任务，流程卡：{}", flowCardId);


        int taskCount = this.count(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()


                .in(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_NEW, Const.HOLLOW_FLOW_CARD_START, Const.HOLLOW_FLOW_CARD_PAUSE)


                .eq(HollowGlassOutRelationInfo::getFlowCardId, flowCardId));


        if (taskCount == 0 || taskCount > 1) {


            log.info("该流程卡不存在任务或者有正在执行中，无法再次执行");


            return Boolean.FALSE;


        }


    public Boolean startTask(int cell) {


        //更新任务状态为开始


        return this.update(new LambdaUpdateWrapper<HollowGlassOutRelationInfo>()


                .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)


                .eq(HollowGlassOutRelationInfo::getFlowCardId, flowCardId)


                .ne(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS)


                .eq(HollowGlassOutRelationInfo::getCell, cell));


    }




    @Override


    public Boolean pauseTask(String flowCardId, int cell) {


    public Boolean pauseTask(int cell) {


//        更新任务状态为暂停


        return this.update(new LambdaUpdateWrapper<HollowGlassOutRelationInfo>()


                .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_PAUSE)


                .eq(HollowGlassOutRelationInfo::getFlowCardId, flowCardId)


                .ne(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS)


                .eq(HollowGlassOutRelationInfo::getCell, cell));


    }


@@ -213,10 +227,11 @@




        //设置文件第一层列表数据


        //暂时生成笼内所有的玻璃信息（已配对和未配对的）


//        List<HollowGlassRelationInfo> hollowGlassRelationInfos = hollowGlassRelationInfoService.list(new LambdaQueryWrapper<HollowGlassRelationInfo>()


//                .eq(HollowGlassRelationInfo::getFlowCardId, flowCardId).orderByAsc(HollowGlassRelationInfo::getHollowSequence));


        List<HollowBigStorageCageDetails> hollowGlassRelationInfos = hollowBigStorageCageDetailsService.queryPairGlassList(flowCardId, relationInfo.getTotalLayer(), relationInfo.getTotalPairQuantity(), isOut);


        Map<Integer, List<HollowBigStorageCageDetails>> listMap = hollowGlassRelationInfos.stream().collect(Collectors.groupingBy(HollowBigStorageCageDetails::getHollowSequence));


        Map<Integer, List<HollowBigStorageCageDetails>> listMap = hollowGlassRelationInfos.stream()


                .collect(Collectors.groupingBy(HollowBigStorageCageDetails::getHollowSequence,


                        Collectors.collectingAndThen(Collectors.toList(),


                                list -> list.stream().sorted(Comparator.comparing(HollowBigStorageCageDetails::getLayer)).collect(Collectors.toList()))));


        Map<Integer, List<HollowBigStorageCageDetails>> sortListMap = new TreeMap<>();


        sortListMap.putAll(listMap);


        //设置间隔板数据共所有配对玻璃使用


@@ -328,6 +343,12 @@


        return this.page(page, wrapper);


    }




    @Override


    @Cacheable(value = "orderDetails", key = "#flowCardId")


    public OrderDetailsDTO queryProductNameByFlowCardId(String flowCardId) {


        log.info("查询数据库一次：{}", flowCardId);


        return baseMapper.queryProductNameByFlowCardId(flowCardId);


    }




    private HollowGlassOutRelationInfo childrenTask(HollowTaskRequest request, int isForce) {


        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getFlowCardId, request.getFlowCardId()).last("limit 1"));


@@ -357,7 +378,9 @@


                .queryOutGlassList(request.getFlowCardId(), request.getCell());


        int isPairCount = glassInfo.getTotalLayer() * request.getTotalPairQuantity();


        List<HollowGlassQueueInfo> hollowQueues = new ArrayList<>();




        Integer carWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_CAR_WIDTH);


//        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);


        Integer glassGap = hollowGlassRelationInfoService.getGlassGapByThickness(hollowBigStorageCageDetailsList.get(0).getThickness());


        if (930 == request.getCell()) {


            Map<Integer, List<HollowBigStorageCageDetails>> listMap = hollowBigStorageCageDetailsList.stream()


                    .collect(Collectors.groupingBy(HollowBigStorageCageDetails::getHollowSequence));


@@ -424,5 +447,10 @@


        queueInfo.setUpdateTime(new Date());


        return queueInfo;


    }




    @Override


    public List<PieChartVO> queryPieChart() {


        return baseMapper.queryPieChart();


    }


}