diagbotcloud/knowledgeman-service/src/main/java/com/diagbot/facade/DiagnoseFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.client.NeoServiceClient;
import com.diagbot.dto.ConceptBaseDTO;
import com.diagbot.dto.DiagnoseDetailSaveDTO;
import com.diagbot.dto.DiagnosePageDTO;
import com.diagbot.dto.LibraryForDiagnoseDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.VerifyDataDTO;
import com.diagbot.entity.CommonParam;
import com.diagbot.entity.Diagnose;
import com.diagbot.entity.DiagnoseDetail;
import com.diagbot.entity.DiagnoseDetailSave;
import com.diagbot.entity.DiagnoseQuestion;
import com.diagbot.entity.wrapper.DiagnoseWrapper;
import com.diagbot.enums.DiagnoseFeatureTypeEnum;
import com.diagbot.enums.DiagnoseFieldEnum;
import com.diagbot.enums.DiagnoseTypeEnum;
import com.diagbot.enums.HasQuestionEnum;
import com.diagbot.enums.InsertOrUpdateEnum;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.LexiconTypeEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.DiagnoseDetailService;
import com.diagbot.service.DiagnoseQuestionService;
import com.diagbot.service.DiagnoseService;
import com.diagbot.service.impl.DiagnoseServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.DiagnoseTypeConvertUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.util.VerifyUtil;
import com.diagbot.vo.DeleteDiagnoseVO;
import com.diagbot.vo.DiagnosePageVO;
import com.diagbot.vo.DiseaseIndexVO;
import com.diagbot.vo.GetDiagnoseDetailVO;
import com.diagbot.vo.NeoParamVO;
import com.diagbot.vo.UpdateDiagnoseVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class DiagnoseFacade extends DiagnoseServiceImpl {

    public static boolean verifyFlag = true;  // true:执行完毕，false：正在执行

    @Autowired
    ConceptFacade conceptFacade;
    @Autowired
    @Qualifier("diagnoseServiceImpl")
    DiagnoseService diagnoseService;
    @Autowired
    @Qualifier("diagnoseDetailServiceImpl")
    DiagnoseDetailService diagnoseDetailService;
    @Autowired
    @Qualifier("diagnoseQuestionServiceImpl")
    DiagnoseQuestionService diagnoseQuestionService;
    @Autowired
    DiagnoseDetailFacade diagnoseDetailFacade;
    @Autowired
    LibraryInfoFacade libraryInfoFacade;
    @Autowired
    NeoServiceClient neoServiceClient;

    /**
     * 诊断依据分页
     *
     * @param diagnosePageVO
     * @return
     */
    public IPage<DiagnosePageDTO> getListFac(DiagnosePageVO diagnosePageVO) {
        IPage<DiagnosePageDTO> res = this.getList(diagnosePageVO);
        if (res.getTotal() <= 0) {
            return res;
        }
        return res;
    }


    /**
     * 诊断依据删除
     *
     * @param deleteDiagnoseVO
     * @return
     */
    public void delete(DeleteDiagnoseVO deleteDiagnoseVO) {
        if (!(IsDeleteEnum.N.getKey().equals(deleteDiagnoseVO.getIsDeleted())
                || IsDeleteEnum.Y.getKey().equals(deleteDiagnoseVO.getIsDeleted()))) {
            throw new CommonException(CommonErrorCode.STATUS_IS_ERROR, "状态值错误【Y】或【N】");
        }

        // 删除图谱数据
        NeoParamVO neoParamVO = new NeoParamVO();
        neoParamVO.setId(deleteDiagnoseVO.getId());
        neoServiceClient.deleteNeo(neoParamVO);
        RespDTO<Boolean> respDTO = neoServiceClient.deleteNeo(neoParamVO);
        RespDTOUtil.respNGDeal(respDTO, "删除图谱数据失败【远程调用】");

        Date now = DateUtil.now();
        this.update(new Diagnose(), new UpdateWrapper<Diagnose>()
                .eq("id", deleteDiagnoseVO.getId())
                .set("gmt_modified", now)
                .set("modifier", deleteDiagnoseVO.getModifier())
                .set("is_deleted", deleteDiagnoseVO.getIsDeleted())
                .set("neo_update", now)
                .set("remark", deleteDiagnoseVO.getRemark()));

        // 删除明细（逻辑删除）
        diagnoseDetailFacade.update(new DiagnoseDetail(), new UpdateWrapper<DiagnoseDetail>()
                .eq("diagnose_id", deleteDiagnoseVO.getId())
                .set("gmt_modified", now)
                .set("modifier", deleteDiagnoseVO.getModifier())
                .set("is_deleted", deleteDiagnoseVO.getIsDeleted()));

        // 删除问题词列表（物理删除）
        diagnoseQuestionService.remove(new QueryWrapper<DiagnoseQuestion>()
                .eq("diagnose_id", deleteDiagnoseVO.getId()));
    }


    /**
     * 诊断检索，过滤已添加的诊断
     *
     * @param diseaseIndexVO
     * @return
     */
    public List<ConceptBaseDTO> indexFac(DiseaseIndexVO diseaseIndexVO) {
        // 设置量表类型
        diseaseIndexVO.setLibType(LexiconTypeEnum.DIAGNOSIS.getKey());
        return this.index(diseaseIndexVO);
    }


    /**
     * 诊断依据获取详情
     *
     * @param getDiagnoseDetailVO
     * @return
     */
    public DiagnoseDetailSaveDTO getDetail(GetDiagnoseDetailVO getDiagnoseDetailVO) {
        DiagnoseDetailSaveDTO res = new DiagnoseDetailSaveDTO();
        List<DiagnoseDetail> detailList = diagnoseDetailFacade.list(new QueryWrapper<DiagnoseDetail>()
                .eq("diagnose_id", getDiagnoseDetailVO.getId())
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .orderByAsc("order_no")
        );
        for (DiagnoseDetail detail : detailList) {
            if (DiagnoseTypeEnum.Confirmed.getKey() == detail.getType() ||
                    DiagnoseTypeEnum.Examination.getKey() == detail.getType() ||
                    DiagnoseTypeEnum.Vigilant.getKey() == detail.getType()
            ) {
                res.getDisformula().add(detail);
            } else {
                res.getDisFeature().add(detail);
            }
        }
        return res;
    }


    /**
     * 诊断依据校验数据，新增或更新主表信息，覆盖明细表和问题词表
     *
     * @param diagnoseWrapper
     */
    public VerifyDataDTO verifyData(DiagnoseWrapper diagnoseWrapper) {
        VerifyDataDTO verifyDataDTO = new VerifyDataDTO();
        CommonParam param = initCommonParam();
        param.setPerson(diagnoseWrapper.getModifier());

        // 更新主表业务(同时删除明细表和问题词表)
        Long id = insertOrUpdateDiagnose(diagnoseWrapper, param);
        diagnoseWrapper.setId(id);
        // 加载词库数据
        List<LibraryForDiagnoseDTO> libraryForDiagnoseDTOS = libraryInfoFacade.getLibraryForDiagnose();
        // 明细数据
        List<DiagnoseDetail> diagnoseDetailList = new ArrayList<>();
        List<DiagnoseDetail> disFeature = new ArrayList<>(); // 诊断特征
        List<DiagnoseDetail> disformula = new ArrayList<>(); // 诊断公式

        // 问题词数据
        List<DiagnoseQuestion> diagnoseQuestionList = new ArrayList<>();

        // 处理诊断特征业务（校验编码|标准词|关联词|结果）
        doDisFuture(diagnoseWrapper, param, libraryForDiagnoseDTOS, disFeature, diagnoseQuestionList);
        // 处理诊断公式业务（校验公式）
        doDisFormula(diagnoseWrapper, param, disformula, diagnoseQuestionList);

        diagnoseDetailList.addAll(disFeature);
        diagnoseDetailList.addAll(disformula);
        // 保存明细
        diagnoseDetailService.saveBatch(diagnoseDetailList);
        // 保存问题词
        if (ListUtil.isNotEmpty(diagnoseQuestionList)) {
            // 新增问题词数据
            diagnoseQuestionService.saveBatch(diagnoseQuestionList);
        }

        // 更新主表状态
        this.update(new UpdateWrapper<Diagnose>()
                .set("has_question", param.getFlag())
                .eq("id", diagnoseWrapper.getId())
        );
        verifyDataDTO.setHasQuestion(param.getFlag());
        verifyDataDTO.setDisFeature(disFeature);
        verifyDataDTO.setDisformula(disformula);
        return verifyDataDTO;
    }


    /**
     * 诊断依据校验全部数据（不用修改操作人和时间）
     *
     */
    public void verifyAllData() {
        if (!verifyFlag) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "其他人正在执行此操作，请稍后再试！");
        }
        try {
            verifyFlag = false;
            CommonParam param = initCommonParam();

            // 获取所有主表信息
            List<Diagnose> diagnoseListWithDB = this.list(new QueryWrapper<Diagnose>()
                    .eq("is_deleted", IsDeleteEnum.N.getKey())
            );

            // 获取所有明细信息
            List<DiagnoseDetail> diagnoseDetailWithDB = diagnoseDetailFacade.list(new QueryWrapper<DiagnoseDetail>()
                    .eq("is_deleted", IsDeleteEnum.N.getKey())
            );
            Map<String, List<DiagnoseDetail>> map = EntityUtil.makeEntityListMap(diagnoseDetailWithDB, "disName");

            // 明细数据
            List<DiagnoseDetail> diagnoseDetailList = new ArrayList<>();
            // 问题词数据
            List<DiagnoseQuestion> diagnoseQuestionList = new ArrayList<>();
            // 加载词库数据
            List<LibraryForDiagnoseDTO> libraryForDiagnoseDTOS = libraryInfoFacade.getLibraryForDiagnose();
            Boolean flag = true;

            List<Integer> typeList = new ArrayList<>();
            // 校验明细数据
            for (String key : map.keySet()) {
                List<DiagnoseDetail> detail = map.get(key);
                int j = 0;
                if (ListUtil.isNotEmpty(detail)) {
                    // 判断诊断名称是否在词库中
                    flag = verifyExist(libraryForDiagnoseDTOS, detail.get(0).getDisName(), Arrays.asList(LexiconTypeEnum.DIAGNOSIS.getKey()));
                    if (!flag) {
                        DiagnoseQuestion diagnoseQuestion1 = createDiagnoseQuestion(detail.get(0).getId(), detail.get(0).getDisName(), DiagnoseFeatureTypeEnum.Dis.getKey(),
                                detail.get(0).getDisName(), DiagnoseFieldEnum.disName.getKey(), initCommonParam(), ++j);
                        diagnoseQuestionList.add(diagnoseQuestion1);
                    }

                    for (DiagnoseDetail bean : detail) {
                        if (DiagnoseTypeEnum.Confirmed.getKey() == bean.getType() || (DiagnoseTypeEnum.Examination.getKey() == bean.getType() || (DiagnoseTypeEnum.Vigilant.getKey() == bean.getType()))) {
                            // 不需要校验公式
                        } else {
                            // 校验编码
                            if (StringUtil.isNotEmpty(bean.getCode())) {
                                flag = VerifyUtil.verifyCode(String.valueOf(bean.getType()), bean.getCode());
                                if (!flag) {
                                    bean.setVerifyCode(bean.getCode());
                                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(bean.getDiagnoseId(), bean.getDisName(), bean.getType(),
                                            bean.getCode(), DiagnoseFieldEnum.code.getKey(), param, ++j);
                                    diagnoseQuestionList.add(diagnoseQuestion);
                                } else {
                                    bean.setVerifyCode(""); // 将原值清空
                                }
                            }

                            // 校验标准词
                            if (StringUtil.isNotEmpty(bean.getStandard())) {
                                typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.standard.getKey());
                                flag = verifyExist(libraryForDiagnoseDTOS, bean.getStandard(), typeList);
                                if (!flag) {
                                    bean.setVerifyStandard(String.valueOf(bean.getStandard()));
                                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(bean.getDiagnoseId(), bean.getDisName(), bean.getType(),
                                            bean.getStandard(), DiagnoseFieldEnum.standard.getKey(), param, ++j);
                                    diagnoseQuestionList.add(diagnoseQuestion);
                                } else {
                                    bean.setVerifyStandard(""); // 将原值清空
                                }
                            }

                            // 校验关联词
                            if (StringUtil.isNotEmpty(bean.getRelation())) {
                                String[] arr = bean.getRelation().split("、");
                                StringBuffer sb = new StringBuffer();
                                for (String s : arr) {
                                    typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.relation.getKey());
                                    flag = verifyExist(libraryForDiagnoseDTOS, s.trim(), typeList);
                                    if (!flag) {
                                        sb.append(s).append("、");
                                        bean.setVerifyRelation(bean.getRelation());
                                        DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(bean.getDiagnoseId(), bean.getDisName(), bean.getType(),
                                                s.trim(), DiagnoseFieldEnum.relation.getKey(), param, ++j);
                                        diagnoseQuestionList.add(diagnoseQuestion);
                                    }
                                }
                                String errWord = sb.toString();
                                if (StringUtil.isNotEmpty(errWord)) {
                                    bean.setVerifyRelation(errWord.substring(0, errWord.length() - 1));
                                } else {
                                    bean.setVerifyRelation(""); // 将原值清空
                                }
                            }

                            // 校验结果
                            if (StringUtil.isNotEmpty(bean.getResult())) {
                                typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.result.getKey());
                                flag = verifyExist(libraryForDiagnoseDTOS, bean.getResult(), typeList);
                                if (!flag) {
                                    bean.setVerifyResult(bean.getResult());
                                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(bean.getDiagnoseId(), bean.getDisName(), bean.getType(),
                                            bean.getStandard(), DiagnoseFieldEnum.standard.getKey(), param, ++j);
                                    diagnoseQuestionList.add(diagnoseQuestion);
                                } else {
                                    bean.setVerifyResult(""); // 将原值清空
                                }
                            }
                        }
                        diagnoseDetailList.add(bean);
                    }
                }
            }

            // 更新明细
            diagnoseDetailService.saveOrUpdateBatch(diagnoseDetailList);

            // 删除全部的问题词数据
            diagnoseQuestionService.remove(new QueryWrapper<DiagnoseQuestion>());
            // 新增问题词
            if (ListUtil.isNotEmpty(diagnoseQuestionList)) {
                // 新增问题词数据
                diagnoseQuestionService.saveBatch(diagnoseQuestionList);
            }
            List<String> disNameList = diagnoseQuestionList.stream().map(row -> row.getDisName()).distinct().collect(Collectors.toList());

            // 修改问题词表的状态
            for (Diagnose diagnose : diagnoseListWithDB) {
                if (disNameList.contains(diagnose.getDisName())) {
                    diagnose.setHasQuestion(String.valueOf(HasQuestionEnum.HAS_QUESTION.getKey()));
                } else {
                    diagnose.setHasQuestion(String.valueOf(HasQuestionEnum.NO_QUESTION.getKey()));
                }
            }
            // 更新主表信息
            diagnoseService.saveOrUpdateBatch(diagnoseListWithDB);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, e.getMessage());
        } finally {
            verifyFlag = true;
        }
    }


    /**
     *  处理诊断特征业务（校验诊断名称|编码|标准词|关联词|结果）
     *
     * @param diagnoseWrapper
     * @param param
     * @return
     */
    public void doDisFuture(DiagnoseWrapper diagnoseWrapper, CommonParam param, List<LibraryForDiagnoseDTO> libraryForDiagnoseDTOS,  List<DiagnoseDetail> diagnoseDetailList,  List<DiagnoseQuestion> diagnoseQuestionList) {
        int i = param.getI();
        int j = param.getJ();

        // 判断诊断名称是否在词库中
        boolean flag = true;
        flag = verifyExist(libraryForDiagnoseDTOS, diagnoseWrapper.getDisName(), Arrays.asList(LexiconTypeEnum.DIAGNOSIS.getKey()));
        if (!flag) {
            DiagnoseQuestion diagnoseQuestion1 = createDiagnoseQuestion(diagnoseWrapper.getId(), diagnoseWrapper.getDisName(), DiagnoseFeatureTypeEnum.Dis.getKey(),
                    diagnoseWrapper.getDisName(), DiagnoseFieldEnum.disName.getKey(), initCommonParam(), ++j);
            diagnoseQuestionList.add(diagnoseQuestion1);
        }

        // 遍历诊断特征
        for (DiagnoseDetailSave bean : diagnoseWrapper.getDisFeature()) {
            DiagnoseDetail diagnoseDetail = new DiagnoseDetail();
            BeanUtil.copyProperties(bean, diagnoseDetail);
            diagnoseDetail.setDiagnoseId(diagnoseWrapper.getId());
            diagnoseDetail.setCreator(param.getPerson());
            diagnoseDetail.setGmtCreate(param.getNow());
            diagnoseDetail.setModifier(param.getPerson());
            diagnoseDetail.setGmtModified(param.getNow());
            diagnoseDetail.setDisName(diagnoseWrapper.getDisName());
            diagnoseDetail.setOrderNo(++i);
            List<Integer> typeList = new ArrayList<>();

            // 校验编码
            if (StringUtil.isNotEmpty(bean.getCode())) {
                flag = VerifyUtil.verifyCode(String.valueOf(bean.getType()), bean.getCode());
                if (!flag) {
                    diagnoseDetail.setVerifyCode(bean.getCode());
                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(diagnoseWrapper.getId(), diagnoseWrapper.getDisName(), bean.getType(),
                            bean.getCode(), DiagnoseFieldEnum.code.getKey(), param, ++j);
                    diagnoseQuestionList.add(diagnoseQuestion);
                }
            }

            // 校验标准词
            if (StringUtil.isNotEmpty(bean.getStandard())) {
                typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.standard.getKey());
                flag = verifyExist(libraryForDiagnoseDTOS, bean.getStandard(), typeList);
                if (!flag) {
                    diagnoseDetail.setVerifyStandard(bean.getStandard());
                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(diagnoseWrapper.getId(), diagnoseWrapper.getDisName(), bean.getType(),
                            bean.getStandard(), DiagnoseFieldEnum.standard.getKey(), param, ++j);
                    diagnoseQuestionList.add(diagnoseQuestion);
                }
            }

            // 校验关联词
            if (StringUtil.isNotEmpty(bean.getRelation())) {
                String[] arr = bean.getRelation().split("、");
                StringBuffer sb = new StringBuffer();
                for (String s : arr) {
                    typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.relation.getKey());
                    flag = verifyExist(libraryForDiagnoseDTOS, s.trim(), typeList);
                    if (!flag) {
                        sb.append(s).append("、");
                        DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(diagnoseWrapper.getId(), diagnoseWrapper.getDisName(), bean.getType(),
                                s.trim(), DiagnoseFieldEnum.relation.getKey(), param, ++j);
                        diagnoseQuestionList.add(diagnoseQuestion);
                    }
                }
                String errWord = sb.toString();
                if (StringUtil.isNotEmpty(errWord)) {
                    diagnoseDetail.setVerifyRelation(errWord.substring(0, errWord.length()-1));
                }
            }

            // 校验结果
            if (StringUtil.isNotEmpty(bean.getResult())) {
                typeList = DiagnoseTypeConvertUtil.diagnoseType2LibType(bean.getType(), DiagnoseFieldEnum.result.getKey());
                flag = verifyExist(libraryForDiagnoseDTOS, bean.getResult(), typeList);
                if (!flag) {
                    diagnoseDetail.setVerifyResult(bean.getResult());
                    DiagnoseQuestion diagnoseQuestion = createDiagnoseQuestion(diagnoseWrapper.getId(), diagnoseWrapper.getDisName(), bean.getType(),
                            bean.getStandard(), DiagnoseFieldEnum.standard.getKey(), param, ++j);
                    diagnoseQuestionList.add(diagnoseQuestion);
                }
            }
            diagnoseDetailList.add(diagnoseDetail);
        }
        param.setI(i);
        param.setJ(j);
        if (ListUtil.isNotEmpty(diagnoseQuestionList)) {
            param.setFlag(HasQuestionEnum.HAS_QUESTION.getKey());
        }
    }


    /**
     *  处理诊断公式业务（校验公式）
     *
     * @param diagnoseWrapper
     * @param param
     * @return
     */
    public void doDisFormula(DiagnoseWrapper diagnoseWrapper, CommonParam param, List<DiagnoseDetail> diagnoseDetailList, List<DiagnoseQuestion> diagnoseQuestionList) {
        List<String> codeList = diagnoseWrapper.getDisFeature().stream().map(row -> row.getCode()).distinct().collect(Collectors.toList());
        int i = param.getI();
        int j = param.getJ();
        // 遍历诊断公式
        for (DiagnoseDetailSave bean : diagnoseWrapper.getDisformula()) {
            DiagnoseDetail diagnoseDetail = new DiagnoseDetail();
            BeanUtil.copyProperties(bean, diagnoseDetail);
            diagnoseDetail.setDiagnoseId(diagnoseWrapper.getId());
            diagnoseDetail.setCreator(param.getPerson());
            diagnoseDetail.setGmtCreate(param.getNow());
            diagnoseDetail.setModifier(param.getPerson());
            diagnoseDetail.setGmtModified(param.getNow());
            diagnoseDetail.setDisName(diagnoseWrapper.getDisName());
            diagnoseDetail.setOrderNo(++i);
            // 校验公式
            String errMsg = VerifyUtil.verifyFormula(codeList, bean.getFormula());
            if (StringUtil.isNotEmpty(errMsg)) {
                diagnoseDetail.setVerifyFormula(errMsg);
                param.setFlag(HasQuestionEnum.HAS_QUESTION.getKey());
            } else {
                diagnoseDetail.setVerifyFormula("");
            }
            diagnoseDetailList.add(diagnoseDetail);
        }
        param.setI(i);
        param.setJ(j);
    }


    /**
     *  更新主表业务(同时删除明细表和问题词表)
     *
     * @param diagnoseWrapper
     * @param param
     * @return
     */
    public Long insertOrUpdateDiagnose(DiagnoseWrapper diagnoseWrapper, CommonParam param) {
        Diagnose diagnose = new Diagnose();
        BeanUtil.copyProperties(diagnoseWrapper, diagnose);
        if (diagnoseWrapper.getId() == null) { //新增
            diagnose.setCreator(param.getPerson());
            diagnose.setGmtCreate(param.getNow());
        } else { // 修改
            // 明细删除
            diagnoseDetailService.remove(new QueryWrapper<DiagnoseDetail>()
                    .eq("diagnose_id", diagnoseWrapper.getId())
            );
            // 删除问题词
            diagnoseQuestionService.remove(new QueryWrapper<DiagnoseQuestion>()
                    .eq("diagnose_id", diagnoseWrapper.getId())
            );
            param.setInsertOrUpdate(InsertOrUpdateEnum.Update.getKey());
        }
        diagnose.setGmtModified(param.getNow());
        this.saveOrUpdate(diagnose);
        return diagnose.getId();
    }


    /**
     * 更新图谱(先校验，再更新)
     *
     * @param updateDiagnoseVO
     * @return
     */
    public void  updateNeo(UpdateDiagnoseVO updateDiagnoseVO) {
//        VerifyDataDTO verifyDataDTO = verifyData(diagnoseWrapper);
//        if (HasQuestionEnum.HAS_QUESTION.getKey() == verifyDataDTO.getHasQuestion()) {
//            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "有问题词存在或公式错误，不能更新图谱");
//        }

        // 更新图谱对接接口
        NeoParamVO neoParamVO = new NeoParamVO();
        neoParamVO.setId(updateDiagnoseVO.getId());
        RespDTO<Boolean> respDTO = neoServiceClient.updateNeo(neoParamVO);
        RespDTOUtil.respNGDeal(respDTO, "更新图谱数据失败【远程调用】");

        // 更新时间
        this.update(new UpdateWrapper<Diagnose>()
                .eq("id", updateDiagnoseVO.getId())
                .set("modifier", updateDiagnoseVO.getModifier())
                .set("neo_update", new Date())
        );
    }


    /**
     * 初始化参数
     *
     * @return
     */
    public CommonParam initCommonParam() {
        CommonParam param = new CommonParam();
        param.setNow(DateUtil.now());
        param.setInsertOrUpdate(InsertOrUpdateEnum.Insert.getKey());
        return param;
    }


    /**
     *  校验词库中是否存在
     *
     * @param library 词库数据
     * @param name 界面输入
     * @param type 转换类型
     * @return 校验结果
     */
    public boolean verifyExist(List<LibraryForDiagnoseDTO> library, String name, List<Integer> type) {
        for(Integer integer : type) {
            LibraryForDiagnoseDTO libraryForDiagnoseDTO = new LibraryForDiagnoseDTO();
            libraryForDiagnoseDTO.setName(name);
            libraryForDiagnoseDTO.setTypeId(integer);
            if (library.contains(libraryForDiagnoseDTO)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 生成问题词
     *
     * @param disName
     * @param type
     * @param questionName
     * @param commonParam
     * @return
     */
    public DiagnoseQuestion createDiagnoseQuestion(Long diagnoseId, String disName, Integer type, String questionName, Integer questionType, CommonParam commonParam, Integer orderNo) {
        DiagnoseQuestion dq = new DiagnoseQuestion();
        dq.setCreator(commonParam.getPerson());
        dq.setGmtCreate(commonParam.getNow());
        dq.setModifier(commonParam.getPerson());
        dq.setGmtModified(commonParam.getNow());
        dq.setDisName(disName);
        dq.setDiagnoseId(diagnoseId);
        dq.setType(type);
        dq.setQuestionName(questionName);
        dq.setQuestionType(questionType);
        dq.setOrderNo(orderNo);
        return dq;
    }

}