mrqc-sys/src/main/java/com/diagbot/facade/ConsoleFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.diagbot.aggregate.AverageStatisticsAggregate;
import com.diagbot.aggregate.MrStatisticsAggregate;
import com.diagbot.aggregate.ResultStatisticsAggregate;
import com.diagbot.dto.AverageStatisticsDTO;
import com.diagbot.dto.AverageStatisticsFeeDTO;
import com.diagbot.dto.ColumnDTO;
import com.diagbot.dto.DeptNumDTO;
import com.diagbot.dto.EntryNumDTO;
import com.diagbot.dto.EntryNumGroupDTO;
import com.diagbot.dto.EntryStatisticsDTO;
import com.diagbot.dto.HomePageImproveDTO;
import com.diagbot.dto.HomePageNumDTO;
import com.diagbot.dto.LevelStatisticsDTO;
import com.diagbot.dto.LevelStatisticsTZDTO;
import com.diagbot.dto.NumDTO;
import com.diagbot.dto.QcResultPercentDTO;
import com.diagbot.dto.QcResultShortDTO;
import com.diagbot.dto.ReBeHosDTO;
import com.diagbot.dto.ReBeHosDetailDTO;
import com.diagbot.dto.ReBeHosMergeDTO;
import com.diagbot.dto.UnModifyMRDTO;
import com.diagbot.dto.UnModifyMRDetailDTO;
import com.diagbot.entity.QcCasesEntry;
import com.diagbot.entity.SysHospitalSet;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.ClassUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.ObjectUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.EntryStatisticsVO;
import com.diagbot.vo.FilterOrderVO;
import com.diagbot.vo.FilterPageByAverageVO;
import com.diagbot.vo.FilterPageVO;
import com.diagbot.vo.FilterUnModifyMRVO;
import com.diagbot.vo.FilterVO;
import com.diagbot.vo.QcResultShortPageVO;
import com.diagbot.vo.ReBeHosPageVO;
import com.google.common.collect.Lists;
import io.github.lvyahui8.spring.aggregate.facade.DataBeanAggregateQueryFacade;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description:
 * @Author:zhaops
 * @time: 2020/4/13 16:45
 */
@Component
public class ConsoleFacade {
    @Autowired
    private FilterFacade filterFacade;
    @Autowired
    private DataBeanAggregateQueryFacade dataBeanAggregateQueryFacade;

    @Autowired
    private AverageStatisticsAggregate averageStatisticsAggregate;
    @Autowired
    private MrStatisticsAggregate mrStatisticsAggregate;
    @Autowired
    private ResultStatisticsAggregate resultStatisticsAggregate;
    @Autowired
    private QcresultInfoFacade qcresultInfoFacade;
    @Autowired
    private HomePageFacade homePageFacade;
    @Autowired
    private BehospitalInfoFacade behospitalInfoFacade;
    @Autowired
    private SysHospitalSetFacade sysHospitalSetFacade;
    @Autowired
    private QcCasesEntryFacade qcCasesEntryFacade;

    //region-----------------------聚合接口开始-------------------------------

    /**
     * 病历相关统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> mrStatistics(FilterVO filterVO) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            invokeParams.put("filterVO", filterVO);
            retMap
                    = dataBeanAggregateQueryFacade.get("setAllMr", invokeParams, Map.class);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        }
        return retMap;
    }

    /**
     * 缺陷相关统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> resultStatistics(FilterVO filterVO) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            invokeParams.put("filterVO", filterVO);
            retMap
                    = dataBeanAggregateQueryFacade.get("setAllResult", invokeParams, Map.class);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        }
        return retMap;
    }

    /**
     * 平局值相关统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> averageStatistics(FilterVO filterVO) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            invokeParams.put("filterVO", filterVO);
            retMap
                    = dataBeanAggregateQueryFacade.get("setAllAverage", invokeParams, Map.class);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        }
        return retMap;
    }

    //endregion-----------------------聚合接口结束-------------------------------

    //region-----------------------单独接口开始-------------------------------

    /**
     * 平均住院天数
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> getAverageDayNum(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<AverageStatisticsDTO> averageDayNumList = averageStatisticsAggregate.getAverageDayNum(filterVO);
        if (ListUtil.isNotEmpty(averageDayNumList)) {
            retMap.put("平均住院日", averageDayNumList);
        }
        return retMap;
    }

    /**
     * 平均住院费用
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> getAverageFee(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<AverageStatisticsDTO> averageFeeList = averageStatisticsAggregate.getAverageFee(filterVO);
        if (ListUtil.isNotEmpty(averageFeeList)) {
            retMap.put("平均住院费用", averageFeeList);
        }
        return retMap;
    }

    /**
     * 质控平均分按科室统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> getAverageScore(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<AverageStatisticsDTO> averageScoreList = averageStatisticsAggregate.getAverageScore(filterVO);
        if (ListUtil.isNotEmpty(averageScoreList)) {
            retMap.put("各科室质控平均分", averageScoreList);
        }
        return retMap;
    }

    /**
     * 各科室质控平均分（首页）-根据内外科系统统计
     *
     * @param filterVO
     * @return
     */
    public List<AverageStatisticsDTO> getAverageScoreByDeptClass(FilterVO filterVO) {
        filterFacade.filterVOSet(filterVO);
        List<AverageStatisticsDTO> retAverageScoreList = Lists.newLinkedList();
        List<AverageStatisticsDTO> averageScoreList = qcresultInfoFacade.getAverageScoreByDeptClass(filterVO);
        Integer limitCount = filterVO.getLimitCount();
        //质控平均分
        if (ListUtil.isNotEmpty(averageScoreList)) {
            retAverageScoreList = averageStatisticsAggregate.getLimitAverageList(averageScoreList, limitCount);
        }
        return retAverageScoreList;
    }

    /**
     * 各科室甲级病历占比
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> getLevelResultDept(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<QcResultPercentDTO> levelResults = mrStatisticsAggregate.getLevelResultDept(filterVO);
        if (ListUtil.isNotEmpty(levelResults)) {
            retMap.put("各科室甲级病历占比", levelResults);
        }
        return retMap;
    }

    /**
     * 出院人数统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> leaveHosCount(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        Map<String, Object> leaveHosMap = new HashMap<>();
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            invokeParams.put("filterVO", filterVO);
            leaveHosMap
                    = dataBeanAggregateQueryFacade.get("setAllLeaveHos", invokeParams, Map.class);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        }
        if (leaveHosMap != null) {
            retMap.put("出院人数统计", leaveHosMap);
        }
        return retMap;
    }

    /**
     * 质控病历统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> mrCount(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> mrCountList = mrStatisticsAggregate.mrCount(filterVO);
        if (ListUtil.isNotEmpty(mrCountList)) {
            retMap.put("病历数统计", mrCountList);
        }
        return retMap;
    }

    /**
     * 各模块缺陷占比排行
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> entryCountGroupByCase(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> caseList = resultStatisticsAggregate.entryCountGroupByCase(filterVO);
        if (ListUtil.isNotEmpty(caseList)) {
            retMap.put("各模块缺陷占比排行", caseList);
        }
        return retMap;
    }

    /**
     * 条目缺陷占比
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> entryCountGroupByEntry(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> entryList = resultStatisticsAggregate.entryCountGroupByEntry(filterVO);
        if (ListUtil.isNotEmpty(entryList)) {
            retMap.put("条目缺陷占比", entryList);
        }
        return retMap;
    }

    /**
     * 单项否决缺陷占比
     *
     * @param filterVO
     * @return
     */
    public List<EntryNumDTO> entryRejectPercent(FilterVO filterVO) {
        List<EntryNumDTO> retList = Lists.newLinkedList();
        filterFacade.filterVOSet(filterVO);
        Integer limitCount = filterVO.getLimitCount();
        List<EntryNumDTO> numDTOList = qcresultInfoFacade.entryRejectPercent(filterVO);
        if (ListUtil.isNotEmpty(numDTOList)) {
            if (numDTOList.size() <= limitCount) {
                retList = numDTOList;
            } else {
                retList = numDTOList.subList(0, limitCount);
            }
        }
        return retList;
    }

    /**
     * 各科室甲/乙/丙级病历占比
     *
     * @param filterVO
     * @return
     */
    public List<DeptNumDTO> qcResultLevelPercent(FilterVO filterVO) {
        if (StringUtil.isBlank(filterVO.getLevel())) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "请输入病历等级");
        }
        List<DeptNumDTO> retList = Lists.newLinkedList();
        filterFacade.filterVOSet(filterVO);
        Integer limitCount = filterVO.getLimitCount();
        List<DeptNumDTO> numDTOList = qcresultInfoFacade.qcResultLevelPercent(filterVO);
        if (ListUtil.isNotEmpty(numDTOList)) {
            if (numDTOList.size() <= limitCount) {
                retList = numDTOList;
            } else {
                retList = numDTOList.subList(0, limitCount);
            }
        }
        return retList;
    }

    /**
     * 各科室缺陷占比
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> entryByDept(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> deptList = resultStatisticsAggregate.entryByDept(filterVO);
        if (ListUtil.isNotEmpty(deptList)) {
            retMap.put("各科室缺陷占比", deptList);
        }
        return retMap;
    }
    //endregion-----------------------单独接口结束-------------------------------

    //region_______________________分页接口开始-------------------------------


    /**
     * 各模块缺陷占比（分页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<NumDTO> entryCountGroupByCasePage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        IPage<NumDTO> page = qcresultInfoFacade.entryCountGroupByCasePage(filterPageVO);
        return page;
    }

    /**
     * 缺陷详情（分页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<EntryNumGroupDTO> entryCountGroupByEntryPage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        if (filterPageVO.getDeptName().equals("全院")) {
            filterPageVO.setDeptName("");
        }
        IPage<EntryNumGroupDTO> page = qcresultInfoFacade.entryCountGroupByEntryPage(filterPageVO);
        return page;
    }

    /**
     * 按科室统计平均住院天数（分页）
     *
     * @param filterPageByAverageVO
     * @return
     */
    public IPage<AverageStatisticsDTO> getAverageDayNumPage(FilterPageByAverageVO filterPageByAverageVO) {
        filterFacade.filterPageByAverageVOSet(filterPageByAverageVO);
        IPage<AverageStatisticsDTO> page = homePageFacade.getAverageDayNumPage(filterPageByAverageVO);
        return page;
    }

    /**
     * 按科室统计平均住院费用（分页）
     *
     * @param filterPageByAverageVO
     * @return
     */
    public IPage<AverageStatisticsFeeDTO> getAverageFeePage(FilterPageByAverageVO filterPageByAverageVO) {
        filterFacade.filterPageByAverageVOSet(filterPageByAverageVO);
        IPage<AverageStatisticsFeeDTO> page = homePageFacade.getAverageFeePage(filterPageByAverageVO);
        return page;
    }

    /**
     * 各科室质控平均分（分页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<AverageStatisticsDTO> getAverageScoreByDeptPage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        IPage<AverageStatisticsDTO> page = qcresultInfoFacade.getAverageScoreByDeptPage(filterPageVO);
        return page;
    }

    /**
     * 各科室缺陷占比排行（分页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<NumDTO> resultStatisticsByDeptPage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        IPage<NumDTO> page = behospitalInfoFacade.resultStatisticsByDeptPage(filterPageVO);
        return page;
    }

    /**
     * 各科室甲级病历占比排行（分页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<QcResultPercentDTO> levelPercentGroupByDeptPage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        IPage<QcResultPercentDTO> page = qcresultInfoFacade.levelPercentGroupByDeptPage(filterPageVO);
        return page;
    }

    /**
     * 条目缺陷占比（内页）
     *
     * @param filterPageVO
     * @return
     */
    public IPage<EntryNumDTO> entryGroupByEntryInnerPage(FilterPageVO filterPageVO) {
        filterFacade.filterPageVOSet(filterPageVO);
        IPage<EntryNumDTO> page = qcresultInfoFacade.entryGroupByEntryInnerPage(filterPageVO);
        return page;
    }
    //endregion-----------------------分页接口结束-------------------------------

    /**
     * 各科室缺陷占比（组合）
     *
     * @param filterOrderVO
     * @return
     */
    public List<LevelStatisticsDTO> levelStatistics(FilterOrderVO filterOrderVO) {
        filterFacade.filterOrderVOSet(filterOrderVO);
        List<LevelStatisticsDTO> records = behospitalInfoFacade.levelStatistics(filterOrderVO);
        return records;
    }

    /**
     * 各科室缺陷占比（组合）-全院-根据内外科系统统计（台州）
     *
     * @param filterOrderVO
     * @return
     */
    public List<LevelStatisticsTZDTO> levelStatisticsByDeptClass_TZ(FilterOrderVO filterOrderVO) {
        filterFacade.filterOrderVOSet(filterOrderVO);
        List<LevelStatisticsTZDTO> records = behospitalInfoFacade.levelStatisticsByDeptClass_TZ(filterOrderVO);
        return records;
    }

    /**
     * 病案首页合格率占比
     *
     * @param filterOrderVO
     * @return
     */
    public List<HomePageNumDTO> homePageLevelStatistics(FilterOrderVO filterOrderVO) {
        filterFacade.filterOrderVOSet(filterOrderVO);
        List<HomePageNumDTO> records = behospitalInfoFacade.homePageLevelStatistics(filterOrderVO);
        //没有科室过滤时增加全院数据
        if (StringUtil.isBlank(filterOrderVO.getName()) || filterOrderVO.getName().equals("全院")) {
            HomePageNumDTO item = getGlobleRecord(records);
            if (item != null) {
                records.add(0, item);
            }
        }
        return records;
    }

    /**
     * 病案首页合格率占比
     *
     * @param filterOrderVO
     * @return
     */
    public List<HomePageNumDTO> homePageLevelLimit(FilterOrderVO filterOrderVO) {
        filterFacade.filterOrderVOSet(filterOrderVO);
        List<HomePageNumDTO> records = behospitalInfoFacade.homePageLevelStatistics(filterOrderVO);
        HomePageNumDTO item = getGlobleRecord(records);
        if (item != null) {
            records.add(0, item);
        }
        records = records
                .stream()
                .limit(filterOrderVO.getLimitCount())
                .collect(Collectors.toList());
        return records;
    }

    /**
     * 增加全院记录
     *
     * @param records
     * @return
     */
    public HomePageNumDTO getGlobleRecord(List<HomePageNumDTO> records) {
        DecimalFormat df = new DecimalFormat("#0.00");
        HomePageNumDTO item = new HomePageNumDTO();

        if (ListUtil.isEmpty(records)) {
            return null;
        }

        //总病历数
        Integer mrNum = records
                .stream()
                .map(HomePageNumDTO::getMrNum)
                .reduce(0, Integer::sum);
        if (mrNum == null || mrNum == 0) {
            return null;
        }
        //总缺陷数
        Integer entryNum = records
                .stream()
                .map(HomePageNumDTO::getEntryNum)
                .reduce(0, Integer::sum);
        //总分
        Double totleValue = records
                .stream()
                .map(i -> BigDecimal.valueOf(i.getTotleValue()))
                .reduce(BigDecimal.ZERO, BigDecimal::add)
                .doubleValue();
        //平均分
        Double averageValue = BigDecimal.valueOf(totleValue)
                .divide(BigDecimal.valueOf(mrNum), 2, RoundingMode.HALF_UP)
                .doubleValue();
        //合格病历总数
        Integer firstLevelNum = records
                .stream()
                .map(HomePageNumDTO::getFirstLevelNum)
                .reduce(0, Integer::sum);
        //合格病历占比
        Double firstLevelPercent = BigDecimal.valueOf(firstLevelNum)
                .divide(BigDecimal.valueOf(mrNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String firstLevelPercentStr
                = df.format(BigDecimal.valueOf(firstLevelPercent).multiply(BigDecimal.valueOf(100))) + "%";
        //不合格病历数
        Integer secondLevelNum = records
                .stream()
                .map(HomePageNumDTO::getSecondLevelNum)
                .reduce(0, Integer::sum);
        //不合格病历占比
        Double secondLevelPercent = BigDecimal.valueOf(secondLevelNum)
                .divide(BigDecimal.valueOf(mrNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String secondLevelPercentStr
                = df.format(BigDecimal.valueOf(secondLevelPercent).multiply(BigDecimal.valueOf(100))) + "%";
        //条目缺陷总数（模块下条目*病历数）
        Integer entryTotleNum = records
                .stream()
                .map(HomePageNumDTO::getEntryTotleNum)
                .reduce(0, Integer::sum);
        //空项总数
        Integer emptyNum = records
                .stream()
                .map(HomePageNumDTO::getEmptyNum)
                .reduce(0, Integer::sum);
        Double emptyPercent = BigDecimal.valueOf(entryTotleNum - emptyNum)
                .divide(BigDecimal.valueOf(entryTotleNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String emptyPercentStr
                = df.format(BigDecimal.valueOf(emptyPercent).multiply(BigDecimal.valueOf(100))) + "%";
        //错误项总数
        Integer errorNum = records
                .stream()
                .map(HomePageNumDTO::getErrorNum)
                .reduce(0, Integer::sum);
        Double errorPercent = BigDecimal.valueOf(entryTotleNum - errorNum)
                .divide(BigDecimal.valueOf(entryTotleNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String errorPercentStr
                = df.format(BigDecimal.valueOf(errorPercent).multiply(BigDecimal.valueOf(100))) + "%";

        item.setDeptName("全院");
        item.setEntryNum(entryNum);
        item.setMrNum(mrNum);
        item.setTotleValue(totleValue);
        item.setAverageValue(averageValue);
        item.setFirstLevelNum(firstLevelNum);
        item.setFirstLevelPercent(firstLevelPercent);
        item.setFirstLevelPercentStr(firstLevelPercentStr);
        item.setSecondLevelNum(secondLevelNum);
        item.setSecondLevelPercent(secondLevelPercent);
        item.setSecondLevelPercentStr(secondLevelPercentStr);
        item.setEntryTotleNum(entryTotleNum);
        item.setEmptyNum(emptyNum);
        item.setEmptyPercent(emptyPercent);
        item.setEmptyPercentStr(emptyPercentStr);
        item.setErrorNum(errorNum);
        item.setErrorPercent(errorPercent);
        item.setErrorPercentStr(errorPercentStr);
        return item;
    }

    /**
     * 条目缺陷质控评分页（内页）
     *
     * @param qcResultShortPageVO
     * @return
     */
    public IPage<QcResultShortDTO> qcResultShortPage(QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        IPage<QcResultShortDTO> page = behospitalInfoFacade.qcResultShortPage(qcResultShortPageVO);
        return page;
    }

    /**
     * 关键条目缺陷占比统计
     *
     * @param entryStatisticsVO
     * @return
     */
    public List<EntryStatisticsDTO> entryStatistics(EntryStatisticsVO entryStatisticsVO) {
        filterFacade.entryStatisticsVOSet(entryStatisticsVO);
        if (entryStatisticsVO.getDeptName().equals("全院")) {
            entryStatisticsVO.setDeptName("");
        }
        List<EntryStatisticsDTO> records = behospitalInfoFacade.entryStatistics(entryStatisticsVO);
        //增加全院数据
        if (entryStatisticsVO.getDeptName().equals("")) {
            EntryStatisticsDTO record = getEntryGlobleRecord(records);
            if (record != null) {
                records.add(0, record);
            }
        }
        return records;
    }

    /**
     * 关键条目缺陷占比统计增加全院记录
     *
     * @param records
     * @return
     */
    private EntryStatisticsDTO getEntryGlobleRecord(List<EntryStatisticsDTO> records) {
        DecimalFormat df = new DecimalFormat("#0.00");
        if (ListUtil.isEmpty(records)) {
            return null;
        }

        EntryStatisticsDTO record = new EntryStatisticsDTO();
        record.setDeptName("全院");
        //未在24小时内完成会诊
        Integer consultationNum = records
                .stream()
                .map(EntryStatisticsDTO::getConsultationNum)
                .reduce(0, Integer::sum);
        record.setConsultationNum(consultationNum);
        record.setConsultationEntryId(records.get(0).getConsultationEntryId());
        Integer consultationMRNum = records
                .stream()
                .map(EntryStatisticsDTO::getConsultationMRNum)
                .reduce(0, Integer::sum);
        record.setConsultationMRNum(consultationMRNum);
        if (consultationMRNum != null && !consultationMRNum.equals(0)) {
            Double consultationPercent = BigDecimal.valueOf(consultationNum)
                    .divide(BigDecimal.valueOf(consultationMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String consultationPercentStr
                    = df.format(BigDecimal.valueOf(consultationPercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setConsultationPercent(consultationPercent);
            record.setConsultationPercentStr(consultationPercentStr);
        }
        //手术记录名称不匹配
        Integer operationNameNum = records
                .stream()
                .map(EntryStatisticsDTO::getOperationNameNum)
                .reduce(0, Integer::sum);
        record.setOperationNameNum(operationNameNum);
        record.setOperationNameEntryId(records.get(0).getOperationNameEntryId());
        Integer operationMRNum = records
                .stream()
                .map(EntryStatisticsDTO::getOperationMRNum)
                .reduce(0, Integer::sum);
        record.setOperationMRNum(operationMRNum);
        if (operationMRNum != null && !operationMRNum.equals(0)) {
            Double operationNamePercent = BigDecimal.valueOf(operationNameNum)
                    .divide(BigDecimal.valueOf(operationMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String operationNamePercentStr
                    = df.format(BigDecimal.valueOf(operationNamePercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setOperationNamePercent(operationNamePercent);
            record.setOperationNamePercentStr(operationNamePercentStr);
        }
        //术后首程未在15分钟内完成
        Integer operation15MinuteNum = records
                .stream()
                .map(EntryStatisticsDTO::getOperation15MinuteNum)
                .reduce(0, Integer::sum);
        record.setOperation15MinuteNum(operation15MinuteNum);
        record.setOperation15MinuteEntryId(records.get(0).getOperation15MinuteEntryId());
        if (operationMRNum != null && !operationMRNum.equals(0)) {
            Double operation15MinutePercent = BigDecimal.valueOf(operation15MinuteNum)
                    .divide(BigDecimal.valueOf(operationMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String operation15MinutePercentStr
                    = df.format(BigDecimal.valueOf(operation15MinutePercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setOperation15MinutePercent(operation15MinutePercent);
            record.setOperation15MinutePercentStr(operation15MinutePercentStr);
        }
        //病案首页手术时间不匹配
        Integer operationTimeNum = records
                .stream()
                .map(EntryStatisticsDTO::getOperationTimeNum)
                .reduce(0, Integer::sum);
        record.setOperationTimeNum(operationTimeNum);
        record.setOperationTimeEntryId(records.get(0).getOperationTimeEntryId());
        if (operationMRNum != null && !operationMRNum.equals(0)) {
            Double operationTimePercent = BigDecimal.valueOf(operationTimeNum)
                    .divide(BigDecimal.valueOf(operationMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String operationTimePercentStr
                    = df.format(BigDecimal.valueOf(operationTimePercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setOperationTimePercent(operationTimePercent);
            record.setOperationTimePercentStr(operationTimePercentStr);
        }
        //未在6小时内书写危机值记录
        Integer crisisNum = records
                .stream()
                .map(EntryStatisticsDTO::getCrisisNum)
                .reduce(0, Integer::sum);
        record.setCrisisNum(crisisNum);
        record.setCrisisEntryId(records.get(0).getCrisisEntryId());
        Integer crisisMRNum = records
                .stream()
                .map(EntryStatisticsDTO::getCrisisMRNum)
                .reduce(0, Integer::sum);
        record.setCrisisMRNum(crisisMRNum);
        if (crisisMRNum != null && !crisisMRNum.equals(0)) {
            Double crisisPercent = BigDecimal.valueOf(crisisNum)
                    .divide(BigDecimal.valueOf(crisisMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String crisisPercentStr
                    = df.format(BigDecimal.valueOf(crisisPercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setCrisisPercent(crisisPercent);
            record.setCrisisPercentStr(crisisPercentStr);
        }
        //病人住院超过30天，阶段小节书写
        Integer stageSummaryNum = records
                .stream()
                .map(EntryStatisticsDTO::getStageSummaryNum)
                .reduce(0, Integer::sum);
        record.setStageSummaryNum(stageSummaryNum);
        record.setStageSummaryEntryId(records.get(0).getStageSummaryEntryId());
        Integer stageSummaryMRNum = records
                .stream()
                .map(EntryStatisticsDTO::getStageSummaryMRNum)
                .reduce(0, Integer::sum);
        record.setStageSummaryMRNum(stageSummaryMRNum);
        if (stageSummaryMRNum != null && !stageSummaryMRNum.equals(0)) {
            Double stageSummaryPercent = BigDecimal.valueOf(stageSummaryNum)
                    .divide(BigDecimal.valueOf(stageSummaryMRNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String stageSummaryPercentStr
                    = df.format(BigDecimal.valueOf(stageSummaryPercent).multiply(BigDecimal.valueOf(100))) + "%";
            record.setStageSummaryPercent(stageSummaryPercent);
            record.setStageSummaryPercentStr(stageSummaryPercentStr);
        }
        //住院超过31日病人数
        Integer beHosGT31DaysMRNum = records
                .stream()
                .map(EntryStatisticsDTO::getBeHosGT31DaysMRNum)
                .reduce(0, Integer::sum);
        record.setBeHosGT31DaysMRNum(beHosGT31DaysMRNum);

        return record;
    }

    /**
     * 病案首页合格率、完整率、改善率统计
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> homePageMRCount(FilterVO filterVO) {
        Map<String, Object> retMap = new HashMap<>();
        retMap.put("合格率", null);
        retMap.put("不合格率", null);
        retMap.put("完整率", null);
        retMap.put("改善率", null);
        filterFacade.filterVOSet(filterVO);
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            invokeParams.put("filterVO", filterVO);
            retMap
                    = dataBeanAggregateQueryFacade.get("setAllHomePage", invokeParams, Map.class);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR);
        }
        return retMap;
    }

    /**
     * 离院病人质控评分详情页
     *
     * @param qcResultShortPageVO
     * @return
     */
    public IPage<QcResultShortDTO> leaveHosMRPage(QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        IPage<QcResultShortDTO> page = behospitalInfoFacade.leaveHosMRPage(qcResultShortPageVO);
        return page;
    }

    /**
     * 质控核查统计（内页）
     *
     * @param filterOrderVO
     * @return
     */
    public List<HomePageImproveDTO> qcCheckStatistics(FilterOrderVO filterOrderVO) {
        filterFacade.filterOrderVOSet(filterOrderVO);
        List<HomePageImproveDTO> records = behospitalInfoFacade.qcCheckStatistics(filterOrderVO);
        //增加全院数据
        if (StringUtil.isBlank(filterOrderVO.getName()) || filterOrderVO.getName().equals("全院")) {
            HomePageImproveDTO item = getGlobleRecord_improve(records);
            if (item != null) {
                records.add(0, item);
            }
        }
        return records;
    }

    /**
     * 增加全院记录
     *
     * @param records
     * @return
     */
    public HomePageImproveDTO getGlobleRecord_improve(List<HomePageImproveDTO> records) {
        DecimalFormat df = new DecimalFormat("#0.00");
        HomePageImproveDTO item = new HomePageImproveDTO();

        if (ListUtil.isEmpty(records)) {
            return null;
        }

        item.setDeptName("全院");

        //总病历数
        Integer mrNum = records
                .stream()
                .map(HomePageImproveDTO::getMrNum)
                .reduce(0, Integer::sum);
        if (mrNum == null || mrNum == 0) {
            return null;
        }
        item.setMrNum(mrNum);
        //核查病历数
        Integer checkedNum = records
                .stream()
                .map(HomePageImproveDTO::getCheckedNum)
                .reduce(0, Integer::sum);
        item.setCheckedNum(checkedNum);
        if (mrNum != null && !mrNum.equals(0)) {
            //核查病历占比
            Double checkedPercent = BigDecimal.valueOf(checkedNum)
                    .divide(BigDecimal.valueOf(mrNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String checkedPercentStr
                    = df.format(BigDecimal.valueOf(checkedPercent).multiply(BigDecimal.valueOf(100))) + "%";
            item.setCheckedPercent(checkedPercent);
            item.setCheckedPercentStr(checkedPercentStr);
        }
        //带病案首页的病历数
        Integer homePageMRNum = records
                .stream()
                .map(HomePageImproveDTO::getHomePageMRNum)
                .reduce(0, Integer::sum);
        item.setHomePageMRNum(homePageMRNum);
        if (homePageMRNum == null || homePageMRNum.equals(0)) {
            return item;
        }
        //改善病历数
        Integer improveNum = records
                .stream()
                .map(HomePageImproveDTO::getImproveNum)
                .reduce(0, Integer::sum);
        //改善率
        Double improvePercent = BigDecimal.valueOf(improveNum)
                .divide(BigDecimal.valueOf(homePageMRNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String improvePercentStr
                = df.format(BigDecimal.valueOf(improvePercent).multiply(BigDecimal.valueOf(100))) + "%";
        //改善至合格病历数
        Integer improveToPassNum = records
                .stream()
                .map(HomePageImproveDTO::getImproveToPassNum)
                .reduce(0, Integer::sum);
        //改善至合格占比
        Double improveToPassPercent = BigDecimal.valueOf(improveToPassNum)
                .divide(BigDecimal.valueOf(homePageMRNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String improveToPassPercentStr
                = df.format(BigDecimal.valueOf(improveToPassPercent).multiply(BigDecimal.valueOf(100))) + "%";
        //改善至满分病历数
        Integer improveToFullNum = records
                .stream()
                .map(HomePageImproveDTO::getImproveToFullNum)
                .reduce(0, Integer::sum);
        //改善至满分占比
        Double improveToFullPercent = BigDecimal.valueOf(improveToFullNum)
                .divide(BigDecimal.valueOf(homePageMRNum), 4, RoundingMode.HALF_UP)
                .doubleValue();
        String improveToFullPercentStr
                = df.format(BigDecimal.valueOf(improveToFullPercent).multiply(BigDecimal.valueOf(100))) + "%";

        item.setImproveNum(improveNum);
        item.setImprovePercent(improvePercent);
        item.setImprovePercentStr(improvePercentStr);
        item.setImproveToPassNum(improveToPassNum);
        item.setImproveToPassPercent(improveToPassPercent);
        item.setImproveToPassPercentStr(improveToPassPercentStr);
        item.setImproveToFullNum(improveToFullNum);
        item.setImproveToFullPercent(improveToFullPercent);
        item.setImproveToFullPercentStr(improveToFullPercentStr);
        return item;
    }

    /**
     * 未整改病历统计
     *
     * @param filterUnModifyMRVO
     * @return
     */
    public UnModifyMRDTO unModifyMRStatistics(FilterUnModifyMRVO filterUnModifyMRVO) {
        UnModifyMRDTO unModifyMRDTO = new UnModifyMRDTO();
        List<Object> retList = Lists.newLinkedList();
        filterFacade.filterUnModifyMRVOSet(filterUnModifyMRVO);

        //colums
        QueryWrapper<SysHospitalSet> hospitalSetQueryWrapper = new QueryWrapper<>();
        hospitalSetQueryWrapper.eq("is_deleted", 'N')
                .eq("hospital_id", filterUnModifyMRVO.getHospitalId())
                .eq("code", "unmodify_mr_entry");
        SysHospitalSet hospitalSet = sysHospitalSetFacade.getOne(hospitalSetQueryWrapper);
        if (hospitalSet == null || StringUtil.isBlank(hospitalSet.getValue())) {
            return unModifyMRDTO;
        }

        //表头生成
        List<String> columnSet = Arrays.asList(hospitalSet.getValue().split(","));
        List<ColumnDTO> columns = Lists.newLinkedList();
        Integer orderNo = 1;
        ColumnDTO columnDeptId = new ColumnDTO();
        columnDeptId.setOrderNo(orderNo);
        columnDeptId.setFieldName("deptId");
        columnDeptId.setColumnName("科室编码");
        columnDeptId.setIsShow(0);
        columns.add(columnDeptId);
        orderNo++;
        ColumnDTO columnDeptName = new ColumnDTO();
        columnDeptName.setOrderNo(orderNo);
        columnDeptName.setFieldName("deptName");
        columnDeptName.setColumnName("科室名称");
        columnDeptName.setIsShow(1);
        columns.add(columnDeptName);
        orderNo++;
        List<Long> casesEntryIds = Lists.newArrayList();
        for (String valueStr : columnSet) {
            if (StringUtil.isBlank(valueStr)) {
                continue;
            }
            String[] keyValue = valueStr.split("--");
            if (keyValue != null || keyValue.length > 1) {
                casesEntryIds.add(Long.valueOf(keyValue[0]));
                ColumnDTO columnId = new ColumnDTO();
                columnId.setOrderNo(orderNo);
                columnId.setId(Long.valueOf(keyValue[0]));
                columnId.setFieldName("entry_" + keyValue[0] + "_id");
                columnId.setColumnName(keyValue[1] + "id");
                columnId.setIsShow(0);
                columns.add(columnId);
                orderNo++;
                ColumnDTO columnName = new ColumnDTO();
                columnName.setOrderNo(orderNo);
                columnName.setId(Long.valueOf(keyValue[0]));
                columnName.setFieldName("entry_" + keyValue[0] + "_name");
                columnName.setColumnName(keyValue[1] + "name");
                columnName.setIsShow(0);
                columns.add(columnName);
                orderNo++;
                ColumnDTO columnNum = new ColumnDTO();
                columnNum.setOrderNo(orderNo);
                columnNum.setId(Long.valueOf(keyValue[0]));
                columnNum.setFieldName("entry_" + keyValue[0] + "_num");
                columnNum.setColumnName(keyValue[1]);
                columnNum.setIsShow(1);
                columns.add(columnNum);
                orderNo++;
            }
        }
        //条目未维护
        if (ListUtil.isEmpty(casesEntryIds)) {
            return unModifyMRDTO;
        }

        //casesEntryIds
        filterUnModifyMRVO.setCasesEntryIds(casesEntryIds);
        QueryWrapper<QcCasesEntry> qcCasesEntryQueryWrapper = new QueryWrapper<>();
        qcCasesEntryQueryWrapper.eq("is_deleted", "N")
                .in("id", casesEntryIds);
        List<QcCasesEntry> casesEntryList = qcCasesEntryFacade.list(qcCasesEntryQueryWrapper);
        Map<Long, String> basCasesEntryMap = EntityUtil.makeMapWithKeyValue(casesEntryList, "id", "name");

        List<UnModifyMRDetailDTO> records = behospitalInfoFacade.unModifyMRStatistics(filterUnModifyMRVO);
        Map<String, List<UnModifyMRDetailDTO>> deptMap = EntityUtil.makeEntityListMap(records, "deptName");
        Map<String, String> deptInfoMap = EntityUtil.makeMapWithKeyValue(records, "deptName", "deptId");
        Map<String, Map<Long, UnModifyMRDetailDTO>> deptEntryMap = new LinkedHashMap<>();
        for (Map.Entry<String, List<UnModifyMRDetailDTO>> entry : deptMap.entrySet()) {
            Map<Long, UnModifyMRDetailDTO> entryMap = EntityUtil.makeEntityMap(entry.getValue(), "casesEntryId");
            deptEntryMap.put(entry.getKey(), entryMap);
        }

        try {
            for (Map.Entry<String, Map<Long, UnModifyMRDetailDTO>> entry : deptEntryMap.entrySet()) {
                Object obj = new Object();
                HashMap addMap = new HashMap();
                HashMap addValMap = new HashMap();

                addMap.put("deptName", Class.forName("java.lang.String"));
                addValMap.put("deptName", entry.getKey());
                addMap.put("deptId", Class.forName("java.lang.String"));
                addValMap.put("deptId", deptInfoMap.get(entry.getKey()));

                for (ColumnDTO item : columns) {
                    if (item.getFieldName().lastIndexOf("_id") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.Long"));
                        if (item.getId() != null) {
                            addValMap.put(item.getFieldName(), item.getId());
                        } else {
                            addValMap.put(item.getFieldName(), null);
                        }
                    } else if (item.getFieldName().lastIndexOf("_name") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.String"));
                        if (basCasesEntryMap.containsKey(item.getId())) {
                            addValMap.put(item.getFieldName(), basCasesEntryMap.get(item.getId()));
                        } else {
                            addValMap.put(item.getFieldName(), "");
                        }
                    } else if (item.getFieldName().lastIndexOf("_num") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.Integer"));
                        if (entry.getValue().containsKey(item.getId())) {
                            addValMap.put(item.getFieldName(), entry.getValue().get(item.getId()).getCasesEntryNum());
                        } else {
                            addValMap.put(item.getFieldName(), 0);
                        }
                    }
                }
                obj = new ClassUtil().dynamicClass(obj, addMap, addValMap);
                retList.add(obj);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        //排序
        Collections.sort(retList, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {

                if (StringUtil.isNotBlank(filterUnModifyMRVO.getAsc())) {
                    //升序
                    Object o1Val = ObjectUtil.getValueByKey(o1, filterUnModifyMRVO.getAsc());
                    Object o2Val = ObjectUtil.getValueByKey(o2, filterUnModifyMRVO.getAsc());
                    if (filterUnModifyMRVO.getAsc().lastIndexOf("_num") > 1) {
                        return ((Integer) o1Val).compareTo((Integer) o2Val);
                    }
                    if (filterUnModifyMRVO.getAsc().lastIndexOf("_id") > 1) {
                        return ((Long) o1Val).compareTo((Long) o2Val);
                    } else {
                        return ((String) o1Val).compareTo((String) o2Val);
                    }
                } else if (StringUtil.isNotBlank(filterUnModifyMRVO.getDesc())) {
                    //降序
                    Object o1Val = ObjectUtil.getValueByKey(o1, filterUnModifyMRVO.getDesc());
                    Object o2Val = ObjectUtil.getValueByKey(o2, filterUnModifyMRVO.getDesc());
                    if (filterUnModifyMRVO.getDesc().lastIndexOf("_num") > 1) {
                        return ((Integer) o2Val).compareTo((Integer) o1Val);
                    }
                    if (filterUnModifyMRVO.getDesc().lastIndexOf("_id") > 1) {
                        return ((Long) o2Val).compareTo((Long) o1Val);
                    } else {
                        return ((String) o2Val).compareTo((String) o1Val);
                    }
                } else {
                    return 0;
                }
            }
        });
        //增加全院数据
        if (ListUtil.isNotEmpty(retList) &&
                (StringUtil.isBlank(filterUnModifyMRVO.getName())
                        || filterUnModifyMRVO.getName().equals("全院"))) {
            try {

                Object globleObj = new Object();
                HashMap addMap = new HashMap();
                HashMap addValMap = new HashMap();
                addMap.put("deptId", Class.forName("java.lang.String"));
                addValMap.put("deptId", "");
                addMap.put("deptName", Class.forName("java.lang.String"));
                addValMap.put("deptName", "全院");

                for (ColumnDTO item : columns) {
                    if (item.getFieldName().lastIndexOf("_id") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.Long"));
                        if (item.getId() != null) {
                            addValMap.put(item.getFieldName(), item.getId());
                        } else {
                            addValMap.put(item.getFieldName(), null);
                        }

                    } else if (item.getFieldName().lastIndexOf("_name") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.String"));
                        if (basCasesEntryMap.containsKey(item.getId())) {
                            addValMap.put(item.getFieldName(), basCasesEntryMap.get(item.getId()));
                        } else {
                            addValMap.put(item.getFieldName(), "");
                        }

                    } else if (item.getFieldName().lastIndexOf("_num") > 0) {
                        addMap.put(item.getFieldName(), Class.forName("java.lang.Integer"));
                        Integer entryNum = retList
                                .stream()
                                .map(i -> ObjectUtil.getValueByKey(i, item.getFieldName()))
                                .filter(i -> i != null)
                                .map(i -> (Integer) i)
                                .reduce(0, Integer::sum);
                        addValMap.put(item.getFieldName(), entryNum);
                    }
                }
                globleObj = new ClassUtil().dynamicClass(globleObj, addMap, addValMap);
                retList.add(0, globleObj);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        unModifyMRDTO.setColumns(columns);
        unModifyMRDTO.setData(retList);
        return unModifyMRDTO;
    }


    /**
     * 未整改病历质控评分页（内页）
     *
     * @param qcResultShortPageVO
     * @return
     */
    public IPage<QcResultShortDTO> unModifyMRPage(QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        return behospitalInfoFacade.unModifyMRPage(qcResultShortPageVO);
    }

    /**
     * 31天再入院详情页
     *
     * @param reBeHosPageVO
     * @return
     */
    public IPage<ReBeHosDTO> reHos31DaysPage(ReBeHosPageVO reBeHosPageVO) {
        filterFacade.reBeHosPageVOSet(reBeHosPageVO);
        IPage<ReBeHosMergeDTO> page = behospitalInfoFacade.reHos31DaysPage(reBeHosPageVO);
        List<ReBeHosMergeDTO> records = page.getRecords();
        IPage<ReBeHosDTO> retPage = new Page<>();
        BeanUtil.copyProperties(page, retPage);
        List<ReBeHosDTO> retRecords = Lists.newLinkedList();
        if (ListUtil.isNotEmpty(records)) {
            for (ReBeHosMergeDTO record : records) {
                ReBeHosDTO retRecord = new ReBeHosDTO();
                BeanUtil.copyProperties(record, retRecord);
                List<ReBeHosDetailDTO> details = Lists.newLinkedList();
                ReBeHosDetailDTO detailRecord = new ReBeHosDetailDTO();
                BeanUtil.copyProperties(record, detailRecord);
                details.add(detailRecord);
                ReBeHosDetailDTO lastDetailRecord = new ReBeHosDetailDTO();
                lastDetailRecord.setName(record.getName());
                lastDetailRecord.setBehDeptId(record.getLastBehDeptId());
                lastDetailRecord.setBehDeptName(record.getBehDeptName());
                lastDetailRecord.setBehospitalCode(record.getLastBehospitalCode());
                lastDetailRecord.setBehospitalDate(record.getLastBehospitalDate());
                lastDetailRecord.setLeaveHospitalDate(record.getLastLeaveHospitalDate());
                lastDetailRecord.setLevel(record.getLastLevel());
                lastDetailRecord.setScoreRes(record.getLastScoreRes());
                lastDetailRecord.setBehospitalDayNum(record.getLastBehospitalDayNum());
                lastDetailRecord.setTotleFee(record.getLastTotleFee());
                details.add(lastDetailRecord);
                retRecord.setDetails(details);
                retRecords.add(retRecord);
            }
        }
        retPage.setRecords(retRecords);
        return retPage;
    }

    /**
     * 入院人数统计（首页）
     *
     * @param filterVO
     * @return
     */
    public List<NumDTO> beHosCount(FilterVO filterVO) {
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> records = behospitalInfoFacade.beHosCount(filterVO);

        if (ListUtil.isNotEmpty(records)) {
            NumDTO globleRecord = new NumDTO();
            globleRecord.setName("全院");
            Integer num = records.stream()
                    .map(NumDTO::getNum)
                    .reduce(0, Integer::sum);
            globleRecord.setNum(num);
            records.add(0, globleRecord);
        }

        if (ListUtil.isNotEmpty(records) && records.size() > filterVO.getLimitCount()) {
            records = records.subList(0, 10);
        }
        return records;
    }

    /**
     * 单条条目缺陷统计（首页）
     *
     * @param filterVO
     * @return
     */
    public List<NumDTO> casesEntryStatisticsById(FilterVO filterVO) {
        filterFacade.filterVOSet(filterVO);
        List<NumDTO> records = behospitalInfoFacade.casesEntryStatisticsById(filterVO);

        if (ListUtil.isNotEmpty(records)) {
            NumDTO globleRecord = new NumDTO();
            globleRecord.setName("全院");
            Integer num = records.stream()
                    .map(NumDTO::getNum)
                    .reduce(0, Integer::sum);
            globleRecord.setNum(num);
            records.add(0, globleRecord);
        }

        if (ListUtil.isNotEmpty(records) && records.size() > filterVO.getLimitCount()) {
            records = records.subList(0, 10);
        }
        return records;
    }

    /**
     * 病案首页改善率质控评分页（内页）
     *
     * @param qcResultShortPageVO
     * @return
     */
    public IPage<QcResultShortDTO> hmImproveMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        return behospitalInfoFacade.hmImproveMRPage(qcResultShortPageVO);
    }

    /**
     * 质控核查质控评分页（内页）
     *
     * @param qcResultShortPageVO
     * @return
     */
    public IPage<QcResultShortDTO> qcCheckMRPage(@Param("qcResultShortPageVO") QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        return behospitalInfoFacade.qcCheckMRPage(qcResultShortPageVO);
    }
}