diagbotcloud/cdssman-service/src/main/java/com/diagbot/facade/DiseaseConfigFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.CdssCoreClient;
import com.diagbot.dto.HosRelationNumDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.entity.DiseaseConfig;
import com.diagbot.enums.ConceptTypeEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.DiseaseConfigService;
import com.diagbot.util.DateUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ExcelUtils;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.UserUtils;
import com.diagbot.vo.ConceptVO;
import com.diagbot.vo.DiseaseConfigListVO;
import com.diagbot.vo.DiseaseConfigPageVO;
import com.diagbot.vo.HosRelationNumPageVO;
import com.diagbot.vo.HospitalIdVO;
import com.diagbot.vo.IdListVO;
import com.diagbot.vo.IdVO;
import com.google.common.collect.Lists;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @Description:
 * @Author:zhaops
 * @time: 2020/7/29 15:05
 */
@Component
public class DiseaseConfigFacade {
    @Autowired
    private DiseaseConfigService diseaseConfigService;
    @Autowired
    private CdssCoreClient cdssCoreClient;

    /**
     * 判断是否已存在
     *
     * @param diseaseConfig
     * @return
     */
    public Boolean isExistRecord(DiseaseConfig diseaseConfig) {
        QueryWrapper<DiseaseConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("hospital_id", diseaseConfig.getHospitalId())
                .eq("his_name", diseaseConfig.getHisName())
                .eq("unique_name", diseaseConfig.getUniqueName());
        DiseaseConfig oldRecord = diseaseConfigService.getOne(queryWrapper, false);
        if (diseaseConfig.getId() == null
                && oldRecord != null) {
            throw new CommonException(CommonErrorCode.IS_EXISTS, "该条关联已存在，无法保存");
        }
        if (diseaseConfig.getId() != null
                && oldRecord != null
                && !diseaseConfig.getId().equals(oldRecord.getId())) {
            throw new CommonException(CommonErrorCode.IS_EXISTS, "该条关联已存在，无法保存");
        }
        return false;
    }

    /**
     * 保存记录-单条
     *
     * @param diseaseConfig
     * @return
     */
    public Boolean saveOrUpdateRecord(DiseaseConfig diseaseConfig) {
        String userId = UserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();
        diseaseConfig.setModifier(userId);
        diseaseConfig.setGmtModified(now);
        QueryWrapper<DiseaseConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("hospital_id", diseaseConfig.getHospitalId())
                .eq("his_name", diseaseConfig.getHisName())
                .eq("unique_name", diseaseConfig.getUniqueName());
        DiseaseConfig oldRecord = diseaseConfigService.getOne(queryWrapper, false);
        if (diseaseConfig.getId() == null
                && oldRecord != null) {
            throw new CommonException(CommonErrorCode.IS_EXISTS, "该条关联已存在，无法保存");
        }
        if (diseaseConfig.getId() != null
                && oldRecord != null
                && !diseaseConfig.getId().equals(oldRecord.getId())) {
            throw new CommonException(CommonErrorCode.IS_EXISTS, "该条关联已存在，无法保存");
        }
        //新增数据
        if (diseaseConfig.getId() == null) {
            diseaseConfig.setCreator(userId);
            diseaseConfig.setGmtCreate(now);
        }
        if (diseaseConfig.getIsDeleted() == null) {
            diseaseConfig.setIsDeleted(IsDeleteEnum.N.getKey());
        }
        diseaseConfigService.saveOrUpdate(diseaseConfig);
        return true;
    }

    /**
     * 保存记录-批量
     *
     * @param diseaseConfigListVO
     * @return
     */
    public Boolean saveOrUpdateRecords(DiseaseConfigListVO diseaseConfigListVO) {
        if (ListUtil.isEmpty(diseaseConfigListVO.getDiseaseConfigList())) {
            return false;
        }
        return saveOrUpdateRecords(diseaseConfigListVO.getDiseaseConfigList());
    }

    /**
     * 批量保存
     *
     * @param diseaseConfigList
     * @return
     */
    public Boolean saveOrUpdateRecords(List<DiseaseConfig> diseaseConfigList) {
        if (ListUtil.isEmpty(diseaseConfigList)) {
            return false;
        }
        String userId = UserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();

        //数据不完整的不保存
        //过滤外部名称或公表名为空的数据
        diseaseConfigList = diseaseConfigList
                .stream()
                .filter(i -> i.getHospitalId() != null)
                .filter(i -> StringUtil.isNotBlank(i.getHisName()))
                .filter(i -> StringUtil.isNotBlank(i.getUniqueName()))
                .collect(Collectors.toList());
        if (ListUtil.isEmpty(diseaseConfigList)) {
            return false;
        }
        Long hospitalId = diseaseConfigList.get(0).getHospitalId();

        // 验证数据是否已存在，已存在的先删除
        // 没id的删除重新插入，有id的更新
        List<Long> deleteIds = Lists.newLinkedList();
        Map<String, Map<String, Long>> configMap
                = getConfigMap(hospitalId, null, null);
        diseaseConfigList.forEach(diseaseConfig -> {
            diseaseConfig.setModifier(userId);
            diseaseConfig.setGmtModified(now);
            if (diseaseConfig.getId() == null) {
                if (configMap.containsKey(diseaseConfig.getHisName())) {
                    deleteIds.add(configMap.get(diseaseConfig.getHisName()).get(diseaseConfig.getUniqueName()));
                }
                diseaseConfig.setCreator(userId);
                diseaseConfig.setGmtCreate(now);
            }
            if (diseaseConfig.getIsDeleted() == null) {
                diseaseConfig.setIsDeleted(IsDeleteEnum.N.getKey());
            }
        });
        //删除已存在映射关系
        IdListVO idListVO = new IdListVO();
        idListVO.setIds(deleteIds);
        deleteRecords(idListVO);
        diseaseConfigService.saveOrUpdateBatch(diseaseConfigList);
        return true;
    }

    /**
     * 删除记录-单条
     *
     * @param idVO
     * @return
     */
    public Boolean deleteRecord(IdVO idVO) {
        diseaseConfigService.removeById(idVO.getId());
        return true;
    }

    /**
     * 删除记录-批量
     *
     * @param idListVO
     * @return
     */
    public Boolean deleteRecords(IdListVO idListVO) {
        if (ListUtil.isEmpty(idListVO.getIds())) {
            return false;
        }
        diseaseConfigService.removeByIds(idListVO.getIds());
        return true;
    }

    /**
     * 分页查询
     *
     * @param diseaseConfigPageVO
     * @return
     */
    public IPage<DiseaseConfig> getPage(DiseaseConfigPageVO diseaseConfigPageVO) {
        return diseaseConfigService.getPage(diseaseConfigPageVO);
    }

    /**
     * 数据导入
     *
     * @param file
     * @param hospitalIdVO
     */
    public void importExcel(MultipartFile file, HospitalIdVO hospitalIdVO) {
        List<DiseaseConfig> diseaseConfigList = ExcelUtils.importExcel(file, 0, 1, DiseaseConfig.class);
        if (ListUtil.isNotEmpty(diseaseConfigList)) {
            diseaseConfigList.forEach(diseaseConfig -> {
                diseaseConfig.setHospitalId(hospitalIdVO.getHospitalId());
            });
            importExcelRecords(diseaseConfigList, hospitalIdVO);
        } else {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
        }
    }

    /**
     * 数据导入
     *
     * @param diseaseConfigList
     * @return
     */
    public Boolean importExcelRecords(List<DiseaseConfig> diseaseConfigList, HospitalIdVO hospitalIdVO) {
        Long hospitalId = hospitalIdVO.getHospitalId();
        String userId = UserUtils.getCurrentPrincipleID();
        Date now = DateUtil.now();

        //1、数据完整性校验
        //2、去除前后空格
        //过滤空数据，保留重复数据，方便计行
        diseaseConfigList = diseaseConfigList.stream()
                .filter(i -> StringUtil.isNotBlank(i.getHisName())
                        || StringUtil.isNotBlank(i.getIcdCode())
                        || StringUtil.isNotBlank(i.getUniqueName()))
                .collect(Collectors.toList());
        if (ListUtil.isEmpty(diseaseConfigList)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
        }
        List<String> emptyNumList = Lists.newLinkedList();
        for (int i = 0; i < diseaseConfigList.size(); i++) {
            if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
                    || StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())) {
                emptyNumList.add(String.valueOf(i + 2));
            }
            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getHisName())) {
                diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
            }
            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getUniqueName())) {
                diseaseConfigList.get(i).setUniqueName(diseaseConfigList.get(i).getUniqueName().trim());
            }
            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getIcdCode())) {
                diseaseConfigList.get(i).setIcdCode(diseaseConfigList.get(i).getIcdCode().trim());
            } else {
                diseaseConfigList.get(i).setIcdCode(null);
            }
        }

        if (ListUtil.isNotEmpty(emptyNumList)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                    + emptyNumList.stream().collect(Collectors.joining("、"))
                    + "。导入取消，请修改后再试。\n");
        }


        // 验证数据是否已存在，已存在的先删除
        // 没id的删除重新插入，有id的更新
        List<Long> deleteIds = Lists.newLinkedList();
        Map<String, Map<String, Long>> configMap
                = getConfigMap(Long.valueOf(hospitalId), null, null);
        diseaseConfigList.forEach(diseaseConfig -> {
            diseaseConfig.setHospitalId(Long.valueOf(hospitalId));
            diseaseConfig.setModifier(userId);
            diseaseConfig.setGmtModified(now);
            if (diseaseConfig.getId() == null) {
                if (configMap.containsKey(diseaseConfig.getHisName())) {
                    deleteIds.add(configMap.get(diseaseConfig.getHisName()).get(diseaseConfig.getUniqueName()));
                }
                diseaseConfig.setCreator(userId);
                diseaseConfig.setGmtCreate(now);
            }
            if (diseaseConfig.getIsDeleted() == null) {
                diseaseConfig.setIsDeleted(IsDeleteEnum.N.getKey());
            }
        });

        //标准术语校验
        List<String> errorNumList = Lists.newLinkedList();
        List<String> uniqueNames = diseaseConfigList.stream()
                .map(i -> i.getUniqueName())
                .distinct()
                .collect(Collectors.toList());
        ConceptVO conceptVO = new ConceptVO();
        conceptVO.setNames(uniqueNames);
        conceptVO.setType(ConceptTypeEnum.Disease.getKey());
        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
        List<String> names = respDTO.data;
        for (int i = 0; i < diseaseConfigList.size(); i++) {
            if (!names.contains(diseaseConfigList.get(i).getUniqueName())) {
                errorNumList.add(String.valueOf(i + 2));
            }
        }
        if (ListUtil.isNotEmpty(errorNumList)) {
            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                            + errorNumList.stream().collect(Collectors.joining("、"))
                            + "。导入取消，请修改后再试。");
        }

        //重复数据过滤
        diseaseConfigList = diseaseConfigList
                .stream()
                .distinct()
                .collect(Collectors.toList());

        //删除已存在映射关系
        IdListVO idListVO = new IdListVO();
        idListVO.setIds(deleteIds);
        deleteRecords(idListVO);
        diseaseConfigService.saveOrUpdateBatch(diseaseConfigList);
        return true;
    }

    /**
     * 获取映射关系-公表名
     *
     * @param hospitalId
     * @param hisNames
     * @param uniqueNames
     * @return
     */
    public Map<String, Map<String, Long>> getConfigMap(Long hospitalId, List<String> hisNames, List<String> uniqueNames) {
        Map<String, Map<String, Long>> retMap = new HashMap<>();
        QueryWrapper<DiseaseConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("hospital_id", hospitalId);
        if (ListUtil.isNotEmpty(hisNames)) {
            queryWrapper.in("his_name", hisNames);
        }
        if (ListUtil.isNotEmpty(uniqueNames)) {
            queryWrapper.in("unique_name", uniqueNames);
        }
        List<DiseaseConfig> records = diseaseConfigService.list(queryWrapper);
        if (ListUtil.isEmpty(records)) {
            return retMap;
        }
        Map<String, List<DiseaseConfig>> configMap = EntityUtil.makeEntityListMap(records, "hisName");
        for (Map.Entry<String, List<DiseaseConfig>> entry : configMap.entrySet()) {
            if (ListUtil.isNotEmpty(entry.getValue())) {
                retMap.put(entry.getKey(), EntityUtil.makeMapWithKeyValue(entry.getValue(), "uniqueName", "id"));
            }
        }
        return retMap;
    }

    /**
     * 数据导出
     *
     * @param response
     * @param hospitalIdVO
     */
    public void exportExcel(HttpServletResponse response, HospitalIdVO hospitalIdVO) {
        QueryWrapper<DiseaseConfig> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("hospital_id", hospitalIdVO.getHospitalId())
                .orderByDesc("gmt_modified");
        List<DiseaseConfig> records = diseaseConfigService.list(queryWrapper);
        String fileName = "疾病映射.xls";
        ExcelUtils.exportExcel(records, null, "sheet1", DiseaseConfig.class, fileName, response, 12.8f);
    }

    /**
     * 各医院映射关系数列表
     *
     * @param hosRelationNumPageVO
     * @return
     */
    public IPage<HosRelationNumDTO> getRelationNumPage(HosRelationNumPageVO hosRelationNumPageVO) {
        return diseaseConfigService.getRelationNumPage(hosRelationNumPageVO);
    }

    /**
     * 数据导入模板导出
     *
     * @param response
     */
    public void exportExcelModule(HttpServletResponse response) {
        String fileName = "疾病映射模板.xls";
        ExcelUtils.exportExcel(new ArrayList<>(), null, "sheet1", DiseaseConfig.class, fileName, response, 12.8f);
    }

    /**
     * 导入数据预匹配
     * @param file
     * @param response
     */
    public void precDataMatch(MultipartFile file,HttpServletResponse response) {
        List<DiseaseConfig> retList = Lists.newLinkedList();
        List<DiseaseConfig> originList = ExcelUtils.importExcel(file, 0, 1, DiseaseConfig.class);

        Map<String, List<DiseaseConfig>> allMap = getAll();
        if (ListUtil.isNotEmpty(originList)) {
            for (DiseaseConfig originItem : originList) {
                if (allMap.containsKey(originItem.getHisName())) {
                    retList.addAll(allMap.get(originItem.getHisName()));
                } else {
                    retList.add(originItem);
                }
            }
        }

        String fileName = "诊断关联数据（预匹配）.xls";
        ExcelUtils.exportExcel(retList, null, "sheet1", DiseaseConfig.class, fileName, response, 12.8f);
    }

    /**
     * 获取所有医院映射数据
     * @return
     */
    public Map<String,List<DiseaseConfig>> getAll() {
        Map<String, List<DiseaseConfig>> retMap = new HashMap<>();
        List<DiseaseConfig> records = diseaseConfigService.list();
        if (ListUtil.isEmpty(records)) {
            return retMap;
        }
        records.forEach(record -> {
            record.setHospitalId(null);
            record.setId(null);
            record.setIcdCode(StringUtils.isBlank(record.getIcdCode()) ? null : record.getIcdCode());
        });

        records = records
                .stream()
                .filter(record -> record.getIsDeleted().equals(IsDeleteEnum.N.getKey()))
                .distinct()
                .collect(Collectors.toList());

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

        retMap = EntityUtil.makeEntityListMap(records, "hisName");

        return retMap;
    }
}