工控网新分支
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
Lius
2025-03-31 943d055689b2df81fa5c60bed5f40dae6135f713 
 lxzn-module-mdc/src/main/java/org/jeecg/modules/mdc/service/impl/MdcEfficiencyReportServiceImpl.java


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


import org.apache.commons.lang3.StringUtils;


import org.jeecg.common.constant.CommonConstant;


import org.jeecg.common.exception.JeecgBootException;


import org.jeecg.common.system.vo.DictModel;


import org.jeecg.modules.mdc.dto.*;


import org.jeecg.modules.mdc.entity.*;


import org.jeecg.modules.mdc.mapper.MdcEfficiencyReportMapper;


@@ -15,6 +16,8 @@


import org.jeecg.modules.system.entity.SysDepart;


import org.jeecg.modules.system.service.IMdcProductionService;


import org.jeecg.modules.system.service.ISysDepartService;


import org.jeecg.modules.system.service.ISysDictService;


import org.jeecg.modules.system.vo.MdcProOptionsVo;


import org.springframework.stereotype.Service;




import javax.annotation.Resource;


@@ -24,6 +27,7 @@


import java.time.format.DateTimeFormatter;


import java.time.temporal.ChronoUnit;


import java.util.*;


import java.util.function.Function;


import java.util.stream.Collectors;




/**


@@ -53,6 +57,9 @@




    @Resource


    private IMdcEquipmentRunningSectionService mdcEquipmentRunningSectionService;




    @Resource


    private ISysDictService sysDictService;




    /**


     * 利用率报表


@@ -1739,28 +1746,214 @@


    /**


     * 班组各设备综合利用率


     *


     * @param teamEquEffVo


     * @param equEffVo


     * @return


     */


    @Override


    public Map<String, Object> teamEquipmentEfficiencyAnalyze(TeamEquEffVo teamEquEffVo) {


    public Map<String, Object> equipmentEfficiencyAnalyze(String userId, EquEffVo equEffVo) {


        Map<String, Object> result = new HashMap<>();


        List<String> mdcProductionIds = new ArrayList<>();


        if (StringUtils.isEmpty(teamEquEffVo.getProductionIds())) {


            mdcProductionIds.add(teamEquEffVo.getProductionId());


        if (StringUtils.isBlank(equEffVo.getProductionIds())) {


            mdcProductionIds.add(equEffVo.getProductionId());


        } else {


            mdcProductionIds.addAll(Arrays.asList(teamEquEffVo.getProductionIds().split(",")));


            mdcProductionIds.addAll(Arrays.asList(equEffVo.getProductionIds().split(",")));


        }


        List<String> allProductionIds = mdcProductionService.findChildren(mdcProductionIds);


        //数据权限过滤


        allProductionIds = mdcProductionService.findProIdsByUId(userId, allProductionIds);


        List<MdcEquipment> equipmentList = mdcEquipmentService.findByProductionIds(allProductionIds);


        if (equipmentList != null && !equipmentList.isEmpty()) {


            List<String> equipmentIdList = equipmentList.stream().map(MdcEquipment::getEquipmentId).collect(Collectors.toList());


            List<TeamEquipmentEfficiencyAnalyzeDto> dataList = mdcEfficiencyReportMapper.teamEquipmentEfficiencyAnalyze(equipmentIdList, teamEquEffVo.getMonth());


            List<EquipmentEfficiencyAnalyzeDto> dataList = mdcEfficiencyReportMapper.equipmentEfficiencyAnalyze(equipmentIdList, equEffVo.getMonth());


            result.put("dataList", dataList);


            List<String> equipmentNameList = dataList.stream().map(TeamEquipmentEfficiencyAnalyzeDto::getEquipmentName).collect(Collectors.toList());


            List<String> equipmentNameList = dataList.stream().map(EquipmentEfficiencyAnalyzeDto::getEquipmentName).collect(Collectors.toList());


            result.put("equipmentNameList", equipmentNameList);


        }


        return result;


    }




    @Override


    public Map<String, Object> teamEquipmentEfficiencyAnalyze(String userId, EquEffVo equEffVo) {


        Map<String, Object> result = new HashMap<>();


        // 1. 处理生产ID


        List<String> mdcProductionIds = StringUtils.isBlank(equEffVo.getProductionIds())


                ? Collections.singletonList(equEffVo.getProductionId())


                : Arrays.asList(equEffVo.getProductionIds().split(","));




        List<String> allProductionIds = mdcProductionService.findChildren(mdcProductionIds);


        if (allProductionIds.isEmpty()) {


            return result; // 提前返回空结果


        }


        //数据权限过滤


        allProductionIds = mdcProductionService.findProIdsByUId(userId, allProductionIds);


        // 2. 获取设备列表


        List<MdcEquipment> equipmentList = StringUtils.isNotBlank(equEffVo.getTeamCodes())


                ? mdcEquipmentService.findByProIdsAndTeamCode(allProductionIds, Arrays.asList(equEffVo.getTeamCodes().split(",")))


                : mdcEquipmentService.findByProductionIds(allProductionIds);




        if (equipmentList.isEmpty()) {


            return result;


        }




        // 3. 数据处理


        List<String> equipmentIdList = equipmentList.stream()


                .map(MdcEquipment::getEquipmentId)


                .collect(Collectors.toList());




        List<TeamEquEffDto> dataList = mdcEfficiencyReportMapper


                .teamEquipmentEfficiencyAnalyze(equipmentIdList, equEffVo.getMonth());




        if (dataList.isEmpty()) {


            return result;


        }




        // 4. 分组计算平均值


        Map<String, TeamEquEffDto> grouped = dataList.stream()


                .collect(Collectors.groupingBy(


                        TeamEquEffDto::getTeamCode,


                        Collectors.collectingAndThen(


                                Collectors.toList(),


                                this::calculateAverages // 提取计算方法


                        )));




        // 5. 字典转换


        Map<String, String> dictMap = sysDictService.queryEnableDictItemsByCode(CommonConstant.DICT_MDC_STAFF_TEAM)


                .stream()


                .collect(Collectors.toMap(DictModel::getValue, DictModel::getText));




        List<TeamEquEffDto> resultList = grouped.entrySet().stream()


                .map(entry -> buildResultDto(entry, dictMap))// 提取构建方法


                .sorted(Comparator.comparing(TeamEquEffDto::getUtilizationRate).reversed())


                .collect(Collectors.toList());




        result.put("dataList", resultList);


        result.put("teamCodeList", resultList.stream()


                .map(TeamEquEffDto::getTeamCode)


                .collect(Collectors.toList()));




        return result;




    }




    @Override


    public Map<String, Object> teamEfficiencyAnalyzeByMonth(String userId, EquEffVo equEffVo) {


        Map<String, Object> result = new HashMap<>();




        // 1. 日期处理


        LocalDate now = LocalDate.now();


        Date start = DateUtils.toDate(now.plusMonths(-6).toString(), DateUtils.STR_DATE);


        Date end = DateUtils.toDate(now.plusMonths(-1).toString(), DateUtils.STR_DATE);




        List<String> monthBetween = DateUtils.getMonthBetween(start, end);


        List<String> dateList = monthBetween.stream()


                .map(date -> date.substring(date.lastIndexOf("-") + 1).replaceFirst("^0*", "") + "月")


                .collect(Collectors.toList());


        result.put("dateList", dateList);




        // 2. 获取产线数据


        List<MdcProduction> mdcProductions = mdcProductionService.findMdcPros(userId, equEffVo.getProductionId());




        // 3. 初始化结果集


        List<TeamEquEffMonthDto> utilizationRateList = new ArrayList<>();


        List<TeamEquEffMonthDto> shiftUtilizationRateList = new ArrayList<>();


        List<TeamEquEffMonthDto> amendUtilizationRateList = new ArrayList<>();




        // 4. 处理每个产线


        mdcProductions.forEach(mdcProduction -> {


            // 4.1 获取下级产线并过滤


            List<String> allProductionIds = mdcProductionService.recursionChildren(mdcProduction.getId());


            // 数据权限过滤


            allProductionIds = mdcProductionService.findProIdsByUId(userId, allProductionIds);


            // 4.2 获取设备列表


            List<MdcEquipment> equipmentList = mdcEquipmentService.findByProductionIds(allProductionIds);


            if (equipmentList == null || equipmentList.isEmpty()) {


                return;


            }


            //提取id集合


            List<String> equipmentIdList = equipmentList.stream()


                    .map(MdcEquipment::getEquipmentId)


                    .collect(Collectors.toList());




            TeamEquEffMonthDto urDto = new TeamEquEffMonthDto();


            TeamEquEffMonthDto surDto = new TeamEquEffMonthDto();


            TeamEquEffMonthDto aurDto = new TeamEquEffMonthDto();


            urDto.setProductionName(mdcProduction.getProductionName());


            surDto.setProductionName(mdcProduction.getProductionName());


            aurDto.setProductionName(mdcProduction.getProductionName());


            List<TeamEquEffMonthChildDto> urDataList = new ArrayList<>();


            List<TeamEquEffMonthChildDto> surDataList = new ArrayList<>();


            List<TeamEquEffMonthChildDto> aurDataList = new ArrayList<>();




            monthBetween.forEach(date -> {


                TeamEquEffMonthChildDto urCDto = new TeamEquEffMonthChildDto();


                TeamEquEffMonthChildDto surCDto = new TeamEquEffMonthChildDto();


                TeamEquEffMonthChildDto aurCDto = new TeamEquEffMonthChildDto();


                String month = date.substring(date.lastIndexOf("-") + 1).replaceFirst("^0*", "") + "月";


                urCDto.setMonth(month);


                surCDto.setMonth(month);


                aurCDto.setMonth(month);


                List<TeamEquEffDto> dataList = mdcEfficiencyReportMapper.teamEquipmentEfficiencyAnalyze(equipmentIdList, date.replaceAll("-", ""));


                if (dataList != null && !dataList.isEmpty()) {


                    // 计算平均值


                    BigDecimal ur = dataList.stream()


                            .map(TeamEquEffDto::getUtilizationRate)


                            .reduce(BigDecimal.ZERO, BigDecimal::add)


                            .divide(BigDecimal.valueOf(dataList.size()), 2, RoundingMode.HALF_UP);


                    //利用率


                    urCDto.setUtilizationRate(ur);


                    //班次利用率


                    BigDecimal sur = dataList.stream()


                            .map(TeamEquEffDto::getShiftUtilizationRate)


                            .reduce(BigDecimal.ZERO, BigDecimal::add)


                            .divide(BigDecimal.valueOf(dataList.size()), 2, RoundingMode.HALF_UP);


                    surCDto.setUtilizationRate(sur);


                    //去除故障24小时利用率


                    BigDecimal aur = dataList.stream()


                            .map(TeamEquEffDto::getAmendUtilizationRate)


                            .reduce(BigDecimal.ZERO, BigDecimal::add)


                            .divide(BigDecimal.valueOf(dataList.size()), 2, RoundingMode.HALF_UP);


                    aurCDto.setUtilizationRate(aur);


                }


                urDataList.add(urCDto);


                surDataList.add(surCDto);


                aurDataList.add(aurCDto);


            });


            urDto.setDataList(urDataList);


            surDto.setDataList(surDataList);


            aurDto.setDataList(aurDataList);


            utilizationRateList.add(urDto);


            shiftUtilizationRateList.add(surDto);


            amendUtilizationRateList.add(aurDto);


        });


        result.put("utilizationRateList", utilizationRateList);


        result.put("shiftUtilizationRateList", shiftUtilizationRateList);


        result.put("amendUtilizationRateList", amendUtilizationRateList);


        return result;


    }




    // 提取的平均值计算方法


    private TeamEquEffDto calculateAverages(List<TeamEquEffDto> items) {


        BigDecimal size = new BigDecimal(items.size());


        return new TeamEquEffDto(


                calculateAverage(items, TeamEquEffDto::getUtilizationRate, size),


                calculateAverage(items, TeamEquEffDto::getShiftUtilizationRate, size),


                calculateAverage(items, TeamEquEffDto::getAmendUtilizationRate, size)


        );


    }




    // 通用的平均值计算


    private BigDecimal calculateAverage(List<TeamEquEffDto> items, Function<TeamEquEffDto, BigDecimal> mapper, BigDecimal size) {


        return items.stream()


                .map(mapper)


                .reduce(BigDecimal.ZERO, BigDecimal::add)


                .divide(size, 2, RoundingMode.HALF_UP);


    }




    // 构建结果DTO


    private TeamEquEffDto buildResultDto(Map.Entry<String, TeamEquEffDto> entry, Map<String, String> dictMap) {


        TeamEquEffDto dto = entry.getValue();


        dto.setTeamCode(dictMap.getOrDefault(entry.getKey(), entry.getKey()));


        return dto;


    }




    private MdcUtilizationResultDto utilizationRate(String equipmentId, String equipmentName, String equipmentType, Date startTime, Date endTime, String date, List<MdcUtilizationRate> mdcUtilizationRateList) {


@@ -1787,7 +1980,7 @@


                }


            }


            BigDecimal totalLong = new BigDecimal(DateUtils.differentSecond(startTime, endTime));


            BigDecimal utilizationRate = processLong.divide(totalLong, 6, BigDecimal.ROUND_HALF_UP);


            BigDecimal utilizationRate = processLong.divide(totalLong, 6, RoundingMode.HALF_UP);


            dto.setUtilizationRate(utilizationRate);


        } else {


            dto.setUtilizationRate(new BigDecimal("0"));