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

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.dto.DeptBaseDTO;
import com.diagbot.dto.DeptEntryNumDTO;
import com.diagbot.dto.DeptNumDTO;
import com.diagbot.dto.HomePageNumDTO;
import com.diagbot.dto.LevelStatisticsDTO;
import com.diagbot.dto.NumDTO;
import com.diagbot.dto.QcResultShortDTO;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.SysUserUtils;
import com.diagbot.vo.FilterOrderByDeptVO;
import com.diagbot.vo.FilterPageByDeptVO;
import com.diagbot.vo.FilterVO;
import com.diagbot.vo.QcResultShortPageVO;
import com.diagbot.vo.QcresultFilterVO;
import com.google.common.collect.Lists;
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.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/5/8 17:05
 */
@Component
public class ConsoleByDeptFacade {
    @Autowired
    private BehospitalInfoFacade behospitalInfoFacade;
    @Autowired
    private QcresultInfoFacade qcresultInfoFacade;
    @Autowired
    private BasDeptInfoFacade basDeptInfoFacade;
    @Autowired
    private FilterFacade filterFacade;
    @Autowired
    private QcCasesFacade qcCasesFacade;

    /**
     * 出院人数统计-按科室
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> leaveHosCountByDept(FilterVO filterVO) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        //关联科室
        Map<String, Object> deptMap = getDeptByUser(filterVO);
        if (deptMap == null) {
            return retMap;
        }
        //出院总人数
        List<NumDTO> totleNumList = behospitalInfoFacade.leaveHosCountByDept(filterVO);
        Map<String, NumDTO> totleMap = ListUtil.isEmpty(totleNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(totleNumList, "name");
        //新生儿人数
        List<NumDTO> newBornNumList = behospitalInfoFacade.newBornCountByDept(filterVO);
        Map<String, NumDTO> newBornMap = ListUtil.isEmpty(newBornNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(newBornNumList, "name");
        //死亡人数
        List<NumDTO> deathNumList = behospitalInfoFacade.deathCountByDept(filterVO);
        Map<String, NumDTO> deathMap = ListUtil.isEmpty(deathNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(deathNumList, "name");
        //手术人数
        List<NumDTO> operationNumList = behospitalInfoFacade.operationCountByDept(filterVO);
        Map<String, NumDTO> operationMap = ListUtil.isEmpty(operationNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(operationNumList, "name");
        for (String deptName : deptMap.keySet()) {
            Map<String, Object> map = new LinkedHashMap<>();
            map.put("总人数", 0);
            map.put("死亡人数", 0);
            map.put("手术病人数", 0);

            if (totleMap.containsKey(deptName)) {
                map.put("总人数", totleMap.get(deptName).getNum());
            }
            if (deathMap.containsKey(deptName)) {
                map.put("死亡人数", deathMap.get(deptName).getNum());
            }
            if (operationMap.containsKey(deptName)) {
                map.put("手术病人数", operationMap.get(deptName).getNum());
            }
            retMap.put(deptName, map);
        }
        return retMap;
    }

    /**
     * 病历数统计-按科室
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> mrCountByDept(FilterVO filterVO) {
        DecimalFormat df = new DecimalFormat("#0.00");
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        QcresultFilterVO qcresultFilterVO = new QcresultFilterVO();
        BeanUtil.copyProperties(filterVO, qcresultFilterVO);
        //关联科室
        Map<String, Object> deptMap = getDeptByUser(filterVO);
        if (deptMap == null) {
            return retMap;
        }
        //质控病历总数
        List<NumDTO> totleNumList = qcresultInfoFacade.resultCountByDept(qcresultFilterVO);
        Map<String, NumDTO> totleMap = ListUtil.isEmpty(totleNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(totleNumList, "name");
        //甲级病历
        qcresultFilterVO.setLevel("甲");
        List<NumDTO> firstNumList = qcresultInfoFacade.resultCountByDept(qcresultFilterVO);
        Map<String, NumDTO> firstMap = ListUtil.isEmpty(firstNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(firstNumList, "name");
        //乙级病历
        qcresultFilterVO.setLevel("乙");
        List<NumDTO> secondNumList = qcresultInfoFacade.resultCountByDept(qcresultFilterVO);
        Map<String, NumDTO> secondMap = ListUtil.isEmpty(secondNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(secondNumList, "name");
        //丙级病历
        qcresultFilterVO.setLevel("丙");
        List<NumDTO> thirdNumList = qcresultInfoFacade.resultCountByDept(qcresultFilterVO);
        Map<String, NumDTO> thirdMap = ListUtil.isEmpty(thirdNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(thirdNumList, "name");
        for (String deptName : deptMap.keySet()) {
            List<NumDTO> retList = Lists.newLinkedList();
            int totleNum = 0;
            int firstLevelNum = 0;
            int secondLevelNum = 0;
            int thirdLevelNum = 0;
            if (totleMap.containsKey(deptName)) {
                totleNum = totleMap.get(deptName).getNum();
            }
            if (firstMap.containsKey(deptName)) {
                firstLevelNum = firstMap.get(deptName).getNum();
            }
            if (secondMap.containsKey(deptName)) {
                secondLevelNum = secondMap.get(deptName).getNum();
            }
            if (thirdMap.containsKey(deptName)) {
                thirdLevelNum = thirdMap.get(deptName).getNum();
            }
            //总病历数为0
            if (totleNum == 0) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            NumDTO totleNumDTO = new NumDTO();
            totleNumDTO.setName("累计质控病历数");
            totleNumDTO.setTotleNum(totleNum);
            totleNumDTO.setNum(totleNum);
            NumDTO firstLevelNumDTO = new NumDTO();
            firstLevelNumDTO.setName("甲级病历");
            firstLevelNumDTO.setNum(firstLevelNum);
            firstLevelNumDTO.setTotleNum(totleNum);
            Double firstPercent = BigDecimal.valueOf(firstLevelNum)
                    .divide(BigDecimal.valueOf(totleNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String firstPercentStr = df.format(BigDecimal.valueOf(firstPercent).multiply(BigDecimal.valueOf(100))) + "%";
            firstLevelNumDTO.setPercent(firstPercent);
            firstLevelNumDTO.setPercentStr(firstPercentStr);
            NumDTO secondLevelNumDTO = new NumDTO();
            secondLevelNumDTO.setName("乙级病历");
            secondLevelNumDTO.setNum(secondLevelNum);
            secondLevelNumDTO.setTotleNum(totleNum);
            Double secondPercent = BigDecimal.valueOf(secondLevelNum)
                    .divide(BigDecimal.valueOf(totleNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String secondPercentStr = df.format(BigDecimal.valueOf(secondPercent).multiply(BigDecimal.valueOf(100))) + "%";
            secondLevelNumDTO.setPercent(secondPercent);
            secondLevelNumDTO.setPercentStr(secondPercentStr);
            NumDTO thirdLevelNumDTO = new NumDTO();
            thirdLevelNumDTO.setName("丙级病历");
            thirdLevelNumDTO.setNum(thirdLevelNum);
            thirdLevelNumDTO.setTotleNum(totleNum);
            Double thirdPercent = BigDecimal.valueOf(thirdLevelNum)
                    .divide(BigDecimal.valueOf(totleNum), 4, RoundingMode.HALF_UP)
                    .doubleValue();
            String thirdPercentStr = df.format(BigDecimal.valueOf(thirdPercent).multiply(BigDecimal.valueOf(100))) + "%";
            thirdLevelNumDTO.setPercent(thirdPercent);
            thirdLevelNumDTO.setPercentStr(thirdPercentStr);
            retList.add(totleNumDTO);
            retList.add(firstLevelNumDTO);
            retList.add(secondLevelNumDTO);
            retList.add(thirdLevelNumDTO);
            retMap.put(deptName, retList);
        }
        return retMap;
    }

    /**
     * 各模块缺陷占比排名-按科室
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> entryCountGroupByCaseAndDept(FilterVO filterVO) {
        DecimalFormat df = new DecimalFormat("#0.00");
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        if (filterVO.getLimitCount() == null || filterVO.getLimitCount().equals(0)) {
            filterVO.setLimitCount(10);
        }
        Integer limitCount = filterVO.getLimitCount();
        QcresultFilterVO qcresultFilterVO = new QcresultFilterVO();
        BeanUtil.copyProperties(filterVO, qcresultFilterVO);
        //关联科室
        Map<String, Object> deptMap = getDeptByUser(filterVO);
        if (deptMap == null) {
            return retMap;
        }
        List<NumDTO> mrNumList = qcresultInfoFacade.resultCountByDept(qcresultFilterVO);
        Map<String, NumDTO> mrMap = ListUtil.isEmpty(mrNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(mrNumList, "name");
        List<DeptNumDTO> qcEntryNumList = qcresultInfoFacade.entryCountGroupByCaseAndDept(filterVO);
        Map<String, List<DeptNumDTO>> qcEntryMap = ListUtil.isEmpty(qcEntryNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityListMap(qcEntryNumList, "deptName");
        List<NumDTO> standardEntryNumList = qcCasesFacade.entryGroupByCase();
        Map<String, NumDTO> standardMap = ListUtil.isEmpty(standardEntryNumList)
                ? new HashMap<>()
                : EntityUtil.makeEntityMap(standardEntryNumList, "name");
        for (String deptName : deptMap.keySet()) {
            //没有质控病历
            if (!mrMap.containsKey(deptName)) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            //病历数
            Integer mrNum = mrMap.get(deptName).getNum();
            //缺陷模块条目未维护
            if (ListUtil.isEmpty(standardEntryNumList)) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            //没有缺陷
            if (!qcEntryMap.containsKey(deptName)) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            //模块缺陷
            List<DeptNumDTO> qcEntryNumByDeptList = qcEntryMap.get(deptName);
            if (ListUtil.isEmpty(qcEntryNumByDeptList)) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            List<NumDTO> retList = Lists.newLinkedList();
            retList = BeanUtil.listCopyTo(qcEntryNumByDeptList, NumDTO.class);
            retList.forEach(item -> {
                if (!standardMap.containsKey(item.getName())) {
                    item.setTotleNum(0);
                    item.setPercent(0d);
                    item.setPercentStr("0%");
                } else {
                    Integer totleNum = standardMap.get(item.getName()).getNum() * mrNum;
                    Double percent = BigDecimal.valueOf(item.getNum())
                            .divide(BigDecimal.valueOf(totleNum), 4, RoundingMode.HALF_UP)
                            .doubleValue();
                    String percentStr
                            = df.format(BigDecimal.valueOf(percent).multiply(BigDecimal.valueOf(100))) + "%";
                    item.setTotleNum(totleNum);
                    item.setPercent(percent);
                    item.setPercentStr(percentStr);
                }
            });

            //降序排序
            Collections.sort(retList, new Comparator<NumDTO>() {
                @Override
                public int compare(NumDTO o1, NumDTO o2) {
                    return o2.getPercent().compareTo(o1.getPercent());
                }
            });


            //取top10
            retList = retList
                    .stream()
                    .limit(limitCount)
                    .collect(Collectors.toList());
            retMap.put(deptName, retList);

        }
        return retMap;
    }


    /**
     * 条目缺陷占比-按科室
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> entryCountGroupByEntryAndDept(FilterVO filterVO) {
        Map<String, Object> retMap = new LinkedHashMap<>();
        filterFacade.filterVOSet(filterVO);
        Integer limitCount = filterVO.getLimitCount();
        //关联科室
        Map<String, Object> deptMap = getDeptByUser(filterVO);
        if (deptMap == null) {
            return retMap;
        }
        List<DeptNumDTO> entryList = qcresultInfoFacade.entryCountGroupByEntryAndDept(filterVO);
        Map<String, List<DeptNumDTO>> numListMap = ListUtil.isEmpty(entryList)
                ? new HashMap<>()
                : EntityUtil.makeEntityListMap(entryList, "deptName");
        for (String deptName : deptMap.keySet()) {
            if (!numListMap.containsKey(deptName)) {
                retMap.put(deptName, Lists.newLinkedList());
                continue;
            }
            List<DeptNumDTO> listByDept = numListMap.get(deptName);
            if (ListUtil.isNotEmpty(listByDept)) {
                //降序排序
                Collections.sort(listByDept, new Comparator<DeptNumDTO>() {
                    @Override
                    public int compare(DeptNumDTO o1, DeptNumDTO o2) {
                        return o2.getPercent().compareTo(o1.getPercent());
                    }
                });

                if (listByDept.size() <= limitCount) {
                    retMap.put(deptName, listByDept);
                } else {
                    retMap.put(deptName, listByDept.subList(0, limitCount));
                }
            }
        }
        return retMap;
    }

    /**
     * 用户关联科室
     *
     * @param filterVO
     * @return
     */
    public Map<String, Object> getDeptByUser(FilterVO filterVO) {
        List<DeptBaseDTO> deptList = basDeptInfoFacade.getDeptByUser(filterVO);
        if (ListUtil.isNotEmpty(deptList)) {
            return EntityUtil.makeMapWithKeyValue(deptList, "deptName", "deptId");
        } else {
            return null;
        }
    }

    /**
     * 获取关联科室
     *
     * @param
     * @return
     */
    public List<DeptBaseDTO> getDept() {
        FilterVO filterVO = new FilterVO();
        String hospitalId = SysUserUtils.getCurrentHospitalID();
        String userId = SysUserUtils.getCurrentPrincipleID();
        filterVO.setHospitalId(hospitalId);
        filterVO.setUserId(Long.valueOf(userId));
        List<DeptBaseDTO> deptList = basDeptInfoFacade.getDeptByUser(filterVO);
        return deptList;
    }


    /**
     * 各模块缺陷占比-科室（分页）
     *
     * @param filterPageByDeptVO
     * @return
     */
    public IPage<DeptNumDTO> entryCountGroupByCaseAndDeptPage(FilterPageByDeptVO filterPageByDeptVO) {
        if (StringUtil.isBlank(filterPageByDeptVO.getDeptName())) {
            List<DeptBaseDTO> deptList = this.getDept();
            //默认取第一个科室
            if (ListUtil.isNotEmpty(deptList)) {
                filterPageByDeptVO.setDeptName(deptList.get(0).getDeptName());
            }
        }
        filterFacade.filterPageByDeptVOSet(filterPageByDeptVO);
        IPage<DeptNumDTO> page = qcresultInfoFacade.entryCountGroupByCaseAndDeptPage(filterPageByDeptVO);
        return page;
    }

    /**
     * 缺陷详情-科室（分页）
     *
     * @param filterPageByDeptVO
     * @return
     */
    public IPage<DeptEntryNumDTO> entryCountGroupByEntryAndDeptPage(FilterPageByDeptVO filterPageByDeptVO) {
        if (StringUtil.isBlank(filterPageByDeptVO.getDeptName())) {
            List<DeptBaseDTO> deptList = this.getDept();
            //默认取第一个科室
            if (ListUtil.isNotEmpty(deptList)) {
                filterPageByDeptVO.setDeptName(deptList.get(0).getDeptName());
            }
        }
        if (filterPageByDeptVO.getDeptName().equals(filterPageByDeptVO.getDoctorName())) {
            filterPageByDeptVO.setDoctorName("");
        }
        filterFacade.filterPageByDeptVOSet(filterPageByDeptVO);
        IPage<DeptEntryNumDTO> page = qcresultInfoFacade.entryCountGroupByEntryAndDeptPage(filterPageByDeptVO);
        return page;
    }

    /**
     * 缺陷明细-科室（分页）
     *
     * @param filterPageByDeptVO
     * @return
     */
    public IPage<DeptNumDTO> resultStatisticsByDeptAndDoctorPage(FilterPageByDeptVO filterPageByDeptVO) {
        if (StringUtil.isBlank(filterPageByDeptVO.getDeptName())) {
            List<DeptBaseDTO> deptList = this.getDept();
            //默认取第一个科室
            if (ListUtil.isNotEmpty(deptList)) {
                filterPageByDeptVO.setDeptName(deptList.get(0).getDeptName());
            }
        }
        filterFacade.filterPageByDeptVOSet(filterPageByDeptVO);
        IPage<DeptNumDTO> page = behospitalInfoFacade.resultStatisticsByDeptAndDoctorPage(filterPageByDeptVO);
        return page;
    }

    /**
     * 条目缺陷占比-科室（内页）
     *
     * @param filterPageByDeptVO
     * @return
     */
    public IPage<DeptEntryNumDTO> entryGroupByEntryAndDeptInnerPage(FilterPageByDeptVO filterPageByDeptVO) {
        if (StringUtil.isBlank(filterPageByDeptVO.getDeptName())) {
            List<DeptBaseDTO> deptList = this.getDept();
            //默认取第一个科室
            if (ListUtil.isNotEmpty(deptList)) {
                filterPageByDeptVO.setDeptName(deptList.get(0).getDeptName());
            }
        }
        filterFacade.filterPageByDeptVOSet(filterPageByDeptVO);
        IPage<DeptEntryNumDTO> page = qcresultInfoFacade.entryGroupByEntryAndDeptInnerPage(filterPageByDeptVO);
        return page;
    }

    /**
     * 各科室缺陷占比（组合）
     *
     * @param filterOrderByDeptVO
     * @return
     */
    public List<LevelStatisticsDTO> levelStatisticsByDept(FilterOrderByDeptVO filterOrderByDeptVO) {
        List<DeptBaseDTO> deptList = getDept();
        if (ListUtil.isEmpty(deptList)) {
            return null;
        }
        if (StringUtil.isBlank(filterOrderByDeptVO.getDeptName())) {
            filterOrderByDeptVO.setDeptName(deptList.get(0).getDeptName());
        }
        filterFacade.filterOrderByDeptVOSet(filterOrderByDeptVO);
        List<LevelStatisticsDTO> records = behospitalInfoFacade.levelStatisticsByDept(filterOrderByDeptVO);
        return records;
    }

    /**
     * 病案首页合格率占比
     *
     * @param filterOrderByDeptVO
     * @return
     */
    public List<HomePageNumDTO> homePageLevelStatisticsByDept(FilterOrderByDeptVO filterOrderByDeptVO) {
        List<DeptBaseDTO> deptList = getDept();
        if (ListUtil.isEmpty(deptList)) {
            return null;
        }
        if (StringUtil.isBlank(filterOrderByDeptVO.getDeptName())) {
            filterOrderByDeptVO.setDeptName(deptList.get(0).getDeptName());
        }
        filterFacade.filterOrderByDeptVOSet(filterOrderByDeptVO);
        List<HomePageNumDTO> records = behospitalInfoFacade.homePageLevelStatisticsByDept(filterOrderByDeptVO);
        //没有医生过滤时增加全科室数据
        if (StringUtil.isBlank(filterOrderByDeptVO.getDeptName())
                || filterOrderByDeptVO.getDeptName().equals(filterOrderByDeptVO.getDeptName())) {
            HomePageNumDTO item = getGlobleRecord(records, filterOrderByDeptVO.getDeptName());
            if (item != null) {
                records.add(0, item);
            }
        }
        return records;
    }

    /**
     * 病案首页合格率占比（首页）
     *
     * @param filterOrderByDeptVO
     * @return
     */
    public List<HomePageNumDTO> homePageLevelByDeptLimit(FilterOrderByDeptVO filterOrderByDeptVO) {

        List<DeptBaseDTO> deptList = getDept();
        if (ListUtil.isEmpty(deptList)) {
            return null;
        }
        if (StringUtil.isBlank(filterOrderByDeptVO.getDeptName())) {
            filterOrderByDeptVO.setDeptName(deptList.get(0).getDeptName());
        }
        filterFacade.filterOrderByDeptVOSet(filterOrderByDeptVO);
        if (filterOrderByDeptVO.getLimitCount() == null || filterOrderByDeptVO.getLimitCount().equals(0)) {
            filterOrderByDeptVO.setLimitCount(10);
        }
        List<HomePageNumDTO> records = behospitalInfoFacade.homePageLevelStatisticsByDept(filterOrderByDeptVO);
        HomePageNumDTO item = getGlobleRecord(records, filterOrderByDeptVO.getDeptName());
        if (item != null) {
            records.add(0, item);
        }

        records = records
                .stream()
                .limit(filterOrderByDeptVO.getLimitCount())
                .collect(Collectors.toList());

        return records;
    }

    /**
     * 获取某个科室全科室数据
     *
     * @param records
     * @param deptName
     * @return
     */
    public HomePageNumDTO getGlobleRecord(List<HomePageNumDTO> records, String deptName) {
        DecimalFormat df = new DecimalFormat("#0.00");
        HomePageNumDTO item = new HomePageNumDTO();
        //总病历数
        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.setDoctorName(deptName);
        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> qcResultShortByDeptPage(QcResultShortPageVO qcResultShortPageVO) {
        filterFacade.qcResultShortPageVOSet(qcResultShortPageVO);
        IPage<QcResultShortDTO> page = behospitalInfoFacade.qcResultShortByDeptPage(qcResultShortPageVO);
        return page;
    }
}