medical-java/jeecg-module-system/jeecg-system-start/src/test/java/org/jeecg/MidAuditDataTest.java

package org.jeecg;

import cn.hutool.core.collection.CollectionUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.util.DateUtils;
import org.jeecg.modules.medical.Constant;
import org.jeecg.modules.medical.entity.AfterwardsAudit;
import org.jeecg.modules.medical.entity.AfterwardsAuditDetail;
import org.jeecg.modules.medical.entity.AfterwardsIncidentAuditDiagnose;
import org.jeecg.modules.medical.entity.MedicalInsRuleInfo;
import org.jeecg.modules.medical.entity.MidIncidentAudit;
import org.jeecg.modules.medical.entity.MidIncidentAuditDetail;
import org.jeecg.modules.medical.entity.MidIncidentAuditDiagnose;
import org.jeecg.modules.medical.entity.SttlMasterBill;
import org.jeecg.modules.medical.entity.SttlMasterDetailBill;
import org.jeecg.modules.medical.job.AfterWaringLogTestJob;
import org.jeecg.modules.medical.ruleengine.RuleEngine;
import org.jeecg.modules.medical.ruleengine.SPELUtil;
import org.jeecg.modules.medical.service.IAfterwardsAuditDetailService;
import org.jeecg.modules.medical.service.IAfterwardsAuditService;
import org.jeecg.modules.medical.service.IAfterwardsIncidentAuditDiagnoseService;
import org.jeecg.modules.medical.service.IMedicalInsRuleInfoService;
import org.jeecg.modules.medical.service.IMedicalInsRuleProjectDiagnoseService;
import org.jeecg.modules.medical.service.IMedicalInsRuleProjectService;
import org.jeecg.modules.medical.service.IMidIncidentAuditDetailService;
import org.jeecg.modules.medical.service.IMidIncidentAuditDiagnoseService;
import org.jeecg.modules.medical.service.IMidIncidentAuditService;
import org.jeecg.modules.medical.service.ISttlMasterBillService;
import org.jeecg.modules.medical.service.ISttlMasterDetailBillService;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysUserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.test.context.junit4.SpringRunner;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

/**
 * @author soft01
 * @time 2023/5/28 21:41
 * @description '生成一些模拟数据'
 * @parentProject medical-java
 */
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = JeecgSystemApplication.class)
@Slf4j
public class MidAuditDataTest {

    List<Map<String, String>> doctorList = new ArrayList<>();

    //就诊类别;住院(hosp)/门诊(outpatient)
    public static final String TREATMENTTYPE = "hops";
    public static final String NOTICE_TYPE = "after";

    public static final String medicalDeptCode = "1001"; //部门代码
    public static final String deptName = "儿科"; //科室

//    public static final String doctorName = "章邯";
//    public static final String doctorId = "1001001";

    //  患者信息
    public static final String patientId = "A1001";
    public static final String patientName = "魏冉";

    public static final String ZYH = "H001"; // 住院号

    // 医嘱/处方号
    public static final String prescriptionNumber = "P001";

    // 项目类型 medicine;consumable;diagnoses;
    public static final String PROJECTTYPE = "medicine";
    public static final String PROJECTCODE = "8001";

    @Autowired
    private IAfterwardsAuditService afterwardsAuditService;
    @Autowired
    private IAfterwardsAuditDetailService afterwardsAuditDetailService;
    @Autowired
    private IAfterwardsIncidentAuditDiagnoseService afterwardsIncidentAuditDiagnoseService;
    @Autowired
    private AfterWaringLogTestJob afterWaringLogTestJob;
    @Autowired
    ISysUserService sysUserService;
    @Autowired
    ISysDepartService sysDepartService;
    @Autowired
    ISttlMasterBillService sttlMasterBillService;
    @Autowired
    ISttlMasterDetailBillService sttlMasterDetailBillService;
    @Autowired
    IMedicalInsRuleProjectService medicalInsRuleProjectService;
    @Autowired
    IMedicalInsRuleProjectDiagnoseService medicalInsRuleProjectDiagnoseService;
    @Autowired
    RuleEngine ruleEngine;
    @Autowired
    IMedicalInsRuleInfoService medicalInsRuleInfoService;
    @Autowired
    RedisTemplate redisTemplate;
    @Autowired
    IMidIncidentAuditService midIncidentAuditService;
    @Autowired
    IMidIncidentAuditDetailService midIncidentAuditDetailService;
    @Autowired
    IMidIncidentAuditDiagnoseService midIncidentAuditDiagnoseService;


    @Test
    public void testJob() {
        try {
            afterWaringLogTestJob.execute(null);
        } catch (JobExecutionException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void genMidDiag() {
        List<MidIncidentAudit> midIncidentAuditList = midIncidentAuditService.lambdaQuery().list();
        log.info("进入查询，数据条数:{}", midIncidentAuditList.size());

        List<MidIncidentAuditDiagnose> midIncidentAuditDiagnoseList = new ArrayList<>();
        MidIncidentAuditDiagnose midIncidentAuditDiagnose = null;
        for (MidIncidentAudit midIncidentAudit : midIncidentAuditList) {
            midIncidentAuditDiagnose = new MidIncidentAuditDiagnose();
            List<SttlMasterBill> sttlMasterBills = sttlMasterBillService.lambdaQuery().eq(SttlMasterBill::getJsdjh, midIncidentAudit.getPrescriptionNumber()).list();
            if (CollectionUtil.isEmpty(sttlMasterBills)) {
                continue;
            }
            SttlMasterBill sttlMasterBill = sttlMasterBills.get(0);
            midIncidentAuditDiagnose.setMidIncidentAuditId(midIncidentAudit.getId());
            midIncidentAuditDiagnose.setDiagnoseCode(sttlMasterBill.getCyzdbm());
            midIncidentAuditDiagnose.setDiagnoseDesc(sttlMasterBill.getCyzdmc());
            midIncidentAuditDiagnose.setMedDiagnoseCode(sttlMasterBill.getRyzdbm());
            midIncidentAuditDiagnose.setMedDiagnoseDesc(sttlMasterBill.getRyksmc());
            midIncidentAuditDiagnose.setPrescriptionNumber(midIncidentAudit.getPrescriptionNumber());
            midIncidentAuditDiagnose.setOutpatientNumber(midIncidentAudit.getOutpatientNumber());
            midIncidentAuditDiagnose.setCreateTime(new Date());
            midIncidentAuditDiagnoseList.add(midIncidentAuditDiagnose);
            log.info("midIncidentAuditDiagnose:{}", midIncidentAuditDiagnose);
        }
        midIncidentAuditDiagnoseService.saveBatch(midIncidentAuditDiagnoseList, 1000);
    }


    @Test
    public void genAfterDiag() {
        List<AfterwardsAudit> midIncidentAuditList = afterwardsAuditService.lambdaQuery().list();
        log.info("进入查询，数据条数:{}", midIncidentAuditList.size());

        List<AfterwardsIncidentAuditDiagnose> midIncidentAuditDiagnoseList = new ArrayList<>();
        AfterwardsIncidentAuditDiagnose midIncidentAuditDiagnose = null;
        for (AfterwardsAudit afterwardsAudit : midIncidentAuditList) {
            midIncidentAuditDiagnose = new AfterwardsIncidentAuditDiagnose();
            List<SttlMasterBill> sttlMasterBills = sttlMasterBillService.lambdaQuery().eq(SttlMasterBill::getJsdjh, afterwardsAudit.getPrescriptionNumber()).list();
            if (CollectionUtil.isEmpty(sttlMasterBills)) {
                continue;
            }
            SttlMasterBill sttlMasterBill = sttlMasterBills.get(0);
            midIncidentAuditDiagnose.setAfterwardsAuditId(afterwardsAudit.getId());
            midIncidentAuditDiagnose.setDiagnoseCode(sttlMasterBill.getCyzdbm());
            midIncidentAuditDiagnose.setDiagnoseDesc(sttlMasterBill.getCyzdmc());
            midIncidentAuditDiagnose.setMedDiagnoseCode(sttlMasterBill.getRyzdbm());
            midIncidentAuditDiagnose.setMedDiagnoseDesc(sttlMasterBill.getRyksmc());
            midIncidentAuditDiagnose.setPrescriptionNumber(afterwardsAudit.getPrescriptionNumber());
            midIncidentAuditDiagnose.setOutpatientNumber(afterwardsAudit.getOutpatientNumber());
            midIncidentAuditDiagnose.setCreateTime(new Date());
            midIncidentAuditDiagnoseList.add(midIncidentAuditDiagnose);
            log.info("afterDiag:{}", midIncidentAuditDiagnose);
        }
        afterwardsIncidentAuditDiagnoseService.saveBatch(midIncidentAuditDiagnoseList, 1000);
    }

    //    @Test
    public void getAfterToMid() {
        log.info("进入查询");
        List<AfterwardsAudit> afterwardsAuditList = afterwardsAuditService.lambdaQuery().list();
        log.info("数据条数：{}", afterwardsAuditList.size());
        MidIncidentAudit midIncidentAudit = new MidIncidentAudit();
        List<MidIncidentAudit> midIncidentAuditList = new ArrayList<>();
        for (AfterwardsAudit audit : afterwardsAuditList) {
            SttlMasterBill sttlMasterBill = sttlMasterBillService.lambdaQuery().eq(SttlMasterBill::getJsdjh, audit.getPrescriptionNumber()).one();
            if (null == sttlMasterBill) {
                continue;
            }
            Long count = afterwardsAuditDetailService.lambdaQuery().eq(AfterwardsAuditDetail::getAfterwardsAuditId, audit.getId()).isNotNull(AfterwardsAuditDetail::getMedicalInsRuleInfoId).count();
            if (null == count || count <= 0) {
                continue;
            }
            midIncidentAudit = new MidIncidentAudit();
            midIncidentAudit.setInsuranceType("1");
            midIncidentAudit.setInpatientArea(audit.getMedicalDeptName());
//            midIncidentAudit.setAllergies()
            midIncidentAudit.setNumberBeds(audit.getOutpatientNumber());
            midIncidentAudit.setDischargeStatus("1");

            midIncidentAudit.setPatientGender(sttlMasterBill.getHzxb());
            midIncidentAudit.setAmount(audit.getAmount());
            midIncidentAudit.setDoctorLevel(sttlMasterBill.getYsjb());
            midIncidentAudit.setPatientAge(sttlMasterBill.getHznl());
            midIncidentAudit.setPrescriptionNumber(audit.getPrescriptionNumber());
            midIncidentAudit.setDoctorId(audit.getDoctorId());
            midIncidentAudit.setDoctorName(audit.getDoctorName());
            midIncidentAudit.setPatientName(audit.getPatientName());
            midIncidentAudit.setPatientId(audit.getPatientId());
            midIncidentAudit.setInHospDate(DateUtils.str2Date(sttlMasterBill.getRyrq(), new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")));
            midIncidentAudit.setNoticeType("after");
            midIncidentAudit.setTreatmentType("1");
            midIncidentAudit.setVisitTime(midIncidentAudit.getInHospDate());
            midIncidentAudit.setMedicalDeptName(audit.getMedicalDeptName());
            midIncidentAudit.setMedicalDeptCode(audit.getMedicalDeptCode());
            midIncidentAudit.setOutpatientNumber(audit.getOutpatientNumber());
            midIncidentAuditList.add(midIncidentAudit);
            log.info("midIncident:{}", midIncidentAudit);
        }
        midIncidentAuditService.saveBatch(midIncidentAuditList, 1000);
    }

    @Test
    public void insertMidWordDetail() {
//        QueryWrapper<SttlMasterBill> queryWrapper = new QueryWrapper();
//        queryWrapper.notIn("jsdjh","0182940007_20201202081355","111929226_20201124104538","20200914-3603991000-014606");
//
//        List<SttlMasterBill> sttlMasterBills = sttlMasterBillService.list(queryWrapper);
        List<MidIncidentAudit> midIncidentAuditList = midIncidentAuditService.lambdaQuery().ne(MidIncidentAudit::getId, 45).list();


        for (MidIncidentAudit midIncidentAudit : midIncidentAuditList) {
//            QueryWrapper<MedicalInsRuleProject> mrPQueryWrapper = new QueryWrapper();
//            medicalInsRuleInfoService.lambdaQuery().last()


            List<AfterwardsAuditDetail> afterwardsAuditDetails = afterwardsAuditDetailService.lambdaQuery().eq(AfterwardsAuditDetail::getPrescriptionNumber, midIncidentAudit.getPrescriptionNumber()).list();
            List<MidIncidentAuditDetail> midIncidentAuditDetails = new ArrayList<>();
            MidIncidentAuditDetail midIncidentAuditDetail = null;
            for (AfterwardsAuditDetail afterwardsAuditDetail : afterwardsAuditDetails) {
//                String lastSql = "INSTR("+afterwardsAuditDetail.getMedicalProjectCode()+",project_code)";
//                List<MedicalInsRuleProject> medicalInsRuleProjectList = medicalInsRuleProjectService.lambdaQuery().eq(MedicalInsRuleProject::getState, Constant.EFF_STATE).last(lastSql).list();
//                if (!CollectionUtil.isNotEmpty(medicalInsRuleProjectList)) {
//                    log.error("规则对象配置表没有有效的规则:{}", lastSql);
//                    continue;
//                }

                SttlMasterDetailBill sttlMasterDetailBill = sttlMasterDetailBillService.lambdaQuery().eq(SttlMasterDetailBill::getJsdjh, afterwardsAuditDetail.getPrescriptionNumber()).eq(SttlMasterDetailBill::getYbxmbm, afterwardsAuditDetail.getMedicalProjectCode()).list().get(0);
//                for(SttlMasterDetailBill sttlMasterDetailBill : sttlMasterDetailBillList) {
                midIncidentAuditDetail = new MidIncidentAuditDetail();
                midIncidentAuditDetail.setMidIncidentAuditId(midIncidentAudit.getId());

                midIncidentAuditDetail.setUseDay(Integer.parseInt(sttlMasterDetailBill.get用药天数()));
//                midIncidentAuditDetail.setDoseUnit(sttlMasterDetailBill.get)
                midIncidentAuditDetail.setMedicalNumber(afterwardsAuditDetail.getQuantity().floatValue());
                midIncidentAuditDetail.setPrice(afterwardsAuditDetail.getPrice());
//                midIncidentAuditDetail.setSingleDoseNumber()
                midIncidentAuditDetail.setAmount(afterwardsAuditDetail.getAmount());
                midIncidentAuditDetail.setMedicalProjectName(afterwardsAuditDetail.getMedicalProjectName());
                midIncidentAuditDetail.setMedicalProjectCode(afterwardsAuditDetail.getMedicalProjectCode());
                midIncidentAuditDetail.setTreatmentType("1");
                midIncidentAuditDetail.setNoticeType("middle");
                midIncidentAuditDetail.setMedicalInsRuleInfoId(afterwardsAuditDetail.getMedicalInsRuleInfoId());
                midIncidentAuditDetail.setMedicalInsRuleInfoName(afterwardsAuditDetail.getMedicalInsRuleInfoName());
                midIncidentAuditDetail.setMedicalInsRuleInfoCode(afterwardsAuditDetail.getMedicalInsRuleInfoCode());
//                midIncidentAuditDetail.getAmount()-Math.random();

                midIncidentAuditDetail.setErrorRelativelyManyAmt(new BigDecimal(getRandom(midIncidentAuditDetail.getAmount())));
                midIncidentAuditDetail.setErrorRelativelyFewAmt(new BigDecimal(0));
                midIncidentAuditDetail.setOutpatientNumber(afterwardsAuditDetail.getOutpatientNumber());
                midIncidentAuditDetail.setPrescriptionNumber(afterwardsAuditDetail.getPrescriptionNumber());
                midIncidentAuditDetail.setPatientId(afterwardsAuditDetail.getPatientId());
                midIncidentAuditDetail.setPatientName(afterwardsAuditDetail.getPatientName());
                midIncidentAuditDetail.setProjectType(afterwardsAuditDetail.getProjectType());
                midIncidentAuditDetail.setViolationLevel(afterwardsAuditDetail.getViolationLevel());
                midIncidentAuditDetail.setReminderLevel("0");
                midIncidentAuditDetail.setDescription(afterwardsAuditDetail.getDescription());
                midIncidentAuditDetail.setCreateTime(new Date());
                midIncidentAuditDetail.setMedicalInsuranceMark("1");
                midIncidentAuditDetail.setMedicalDeptCode(afterwardsAuditDetail.getMedicalDeptCode());
                midIncidentAuditDetail.setMedicalDeptName(afterwardsAuditDetail.getMedicalDeptName());
                midIncidentAuditDetail.setProejctCode(afterwardsAuditDetail.getMedicalProjectCode());
                midIncidentAuditDetail.setProejctName(afterwardsAuditDetail.getMedicalProjectName());
                midIncidentAuditDetail.setDoctorId(afterwardsAuditDetail.getDoctorId());
                midIncidentAuditDetail.setDoctorName(afterwardsAuditDetail.getDoctorName());
                midIncidentAuditDetails.add(midIncidentAuditDetail);

//                }
            }
            midIncidentAuditDetailService.saveBatch(midIncidentAuditDetails, 1000);
        }
//        for (SttlMasterBill sttlMasterBill : sttlMasterBills) {
//            AfterwardsAudit afterwardsAudit = afterwardsAuditService.lambdaQuery().eq(AfterwardsAudit::getPrescriptionNumber, sttlMasterBill.getJsdjh()).one();
//            if (null == afterwardsAudit) {
//                log.error("结算单据号找不到稽核单:{}", sttlMasterBill.getJsdjh());
//                continue;
//            }
//            List<SttlMasterDetailBill> sttlMasterDetailBills = sttlMasterDetailBillService.lambdaQuery().eq(SttlMasterDetailBill::getJsdjh, sttlMasterBill.getJsdjh()).list();
//            if (CollectionUtil.isNotEmpty(sttlMasterBills)) {
//
//                for (SttlMasterDetailBill sttlMasterDetailBill : sttlMasterDetailBills) {
//
//                    genData(sttlMasterDetailBill, codeDataMap, afterwardsAudit, medicalInsRuleInfoList, medicalMap);
//                }
//            }
//        }

//        afterwardsAuditDetailService.saveBatch(detailList, 1000);
    }

    @Async
    public void genData(SttlMasterDetailBill sttlMasterDetailBill, Map<String, Boolean> codeDataMap, AfterwardsAudit afterwardsAudit, List<MedicalInsRuleInfo> medicalInsRuleInfoList, Map<Integer, MedicalInsRuleInfo> medicalMap) {
        AfterwardsAuditDetail afterwardsAuditDetail = new AfterwardsAuditDetail();

        String projectCode = sttlMasterDetailBill.getYbxmbm();
//        if (codeDataMap.containsKey(projectCode)) {
//            return;
//        }
        if (StringUtils.isBlank(projectCode)) {
            log.error("医保编码:{}", sttlMasterDetailBill);
            return;
        }

        if (StringUtils.isNotBlank(projectCode)) {
            Set<Integer> medicalRuleInfoIdSet = RuleEngine.itemCodeAndRuleIdMap.get(projectCode);
            if (CollectionUtil.isEmpty(medicalRuleInfoIdSet)) {
                log.info("医保编码未匹配到规则:{}", projectCode);
                if (!codeDataMap.containsKey(projectCode)) {
                    ruleEngine.genItemCodeAndRuleIdMapTest(projectCode, afterwardsAuditDetail, medicalInsRuleInfoList, medicalMap, codeDataMap);
                }

            } else {
                List<Integer> ruleIdList = new ArrayList<>(medicalRuleInfoIdSet);
                Integer ruleId = ruleIdList.get(0);
                MedicalInsRuleInfo medicalInsRuleInfo = medicalInsRuleInfoService.getById(ruleId);
                afterwardsAuditDetail.setMedicalInsRuleInfoId(ruleId);
//                            MedicalInsRuleInfo medicalInsRuleInfo = medicalMap.get(medicalInsRuleProject.getMedicalInsRuleInfoId());
                afterwardsAuditDetail.setMedicalInsRuleInfoName(medicalInsRuleInfo.getRuleName());
                afterwardsAuditDetail.setMedicalInsRuleInfoCode(medicalInsRuleInfo.getRuleCode());
                Object desc = redisTemplate.opsForHash().get(Constant.PROJECT_VOLIDATION_DESC_KEY + ruleId, projectCode);
                if (null != desc && StringUtils.isNotBlank(desc.toString())) {
                    afterwardsAuditDetail.setDescription(desc.toString());
                } else {
                    afterwardsAuditDetail.setDescription(medicalInsRuleInfo.getDescription());
                }
            }

        }
        String projectType = null;

        if (projectCode.startsWith(Constant.CONSUMABLE_START_KEY)) {
            projectType = "consumable";
        } else if (projectCode.startsWith(Constant.RESTORATIVES_T_START_KEY) ||
                projectCode.startsWith(Constant.RESTORATIVES_X_START_KEY) ||
                projectCode.startsWith(Constant.RESTORATIVES_Z_START_KEY)) {
            projectType = "medicine";
            //耗材都是字母c开头， 药品是X或Z T， 医疗服务是数字开头
        } else if (SPELUtil.isNumeric(projectCode)) {
            projectType = "diagnoses";
        }
        afterwardsAuditDetail.setProjectType(projectType);
        afterwardsAuditDetail.setAfterwardsAuditId(afterwardsAudit.getId());

        afterwardsAuditDetail.setAmount(Double.parseDouble(sttlMasterDetailBill.get金额()));
        afterwardsAuditDetail.setTreatmentType("hops");
        afterwardsAuditDetail.setDoctorId(afterwardsAudit.getDoctorId());
        afterwardsAuditDetail.setDoctorName(afterwardsAudit.getDoctorName());
        afterwardsAuditDetail.setMedicalDeptCode(afterwardsAudit.getMedicalDeptCode());
        afterwardsAuditDetail.setMedicalDeptName(afterwardsAudit.getMedicalDeptName());
        afterwardsAuditDetail.setNoticeType("after");

        afterwardsAuditDetail.setMedicalProjectCode(projectCode);
        afterwardsAuditDetail.setMedicalProjectName(sttlMasterDetailBill.get医保项目名称());
        afterwardsAuditDetail.setPatientId(afterwardsAudit.getPatientId());
        afterwardsAuditDetail.setPatientName(afterwardsAudit.getPatientName());
        afterwardsAuditDetail.setViolationLevel(0);
        afterwardsAuditDetail.setProejctCode(projectCode);
        afterwardsAuditDetail.setProejctName(sttlMasterDetailBill.get医保项目名称());
        afterwardsAuditDetail.setCreateTime(new Date());
        Double quantit = Double.parseDouble(sttlMasterDetailBill.get数量());
        afterwardsAuditDetail.setQuantity(quantit.intValue());
        afterwardsAuditDetail.setReminderLevel("1");
//                    detailList.add(afterwardsAuditDetail);
        afterwardsAuditDetailService.save(afterwardsAuditDetail);
    }


    @Test
    public void generateAfterwardsAuditData() {

        Map<String, String> doctorItem1 = new HashMap<>();
        doctorItem1.put("doctorName", "章邯");
        doctorItem1.put("doctorId", "1001001");

        Map<String, String> doctorItem2 = new HashMap<>();
        doctorItem2.put("doctorName", "楚南公");
        doctorItem2.put("doctorId", "1001006");

        Map<String, String> doctorItem3 = new HashMap<>();
        doctorItem3.put("doctorName", "晓梦");
        doctorItem3.put("doctorId", "1001005");

        Map<String, String> doctorItem4 = new HashMap<>();
        doctorItem4.put("doctorName", "柳梦璃");
        doctorItem4.put("doctorId", "1002002");


        Map<String, String> doctorItem5 = new HashMap<>();
        doctorItem5.put("doctorName", "司马懿");
        doctorItem5.put("doctorId", "1001201");


        Map<String, String> doctorItem6 = new HashMap<>();
        doctorItem6.put("doctorName", "荀彧");
        doctorItem6.put("doctorId", "1001202");


        Map<String, String> doctorItem7 = new HashMap<>();
        doctorItem7.put("doctorName", "夏侯渊");
        doctorItem7.put("doctorId", "1001203");

        Map<String, String> doctorItem8 = new HashMap<>();
        doctorItem8.put("doctorName", "曹仁");
        doctorItem8.put("doctorId", "1001205");


        Map<String, String> doctorItem9 = new HashMap<>();
        doctorItem9.put("doctorName", "孙权");
        doctorItem9.put("doctorId", "1001206");


        Map<String, String> doctorItem10 = new HashMap<>();
        doctorItem10.put("doctorName", "鲁肃");
        doctorItem10.put("doctorId", "1001207");


        doctorList.add(doctorItem1);
        doctorList.add(doctorItem2);
        doctorList.add(doctorItem3);
        doctorList.add(doctorItem4);
        doctorList.add(doctorItem5);
        doctorList.add(doctorItem6);
        doctorList.add(doctorItem7);
        doctorList.add(doctorItem8);
        doctorList.add(doctorItem9);
        doctorList.add(doctorItem10);

        for (Map<String, String> stringStringMap : doctorList) {
            String doctorName = stringStringMap.get("doctorName");
            String doctorId = stringStringMap.get("doctorId");

            // 写主表
            AfterwardsAudit extracted = writeMaster(doctorId, doctorName);
            // 写从表
            writeSlave(doctorId, doctorName, extracted.getId(), 5);
        }


    }

    private void writeSlave(String doctorId, String doctorName, Integer id, int number) {
        for (int i = 0; i < number; i++) {
            AfterwardsAuditDetail aad = new AfterwardsAuditDetail();
            aad.setAfterwardsAuditId(id);
            aad.setMedicalInsRuleInfoId(1);
            aad.setMedicalInsRuleInfoCode("1");
            aad.setMedicalInsRuleInfoName("前");
            aad.setTreatmentType(TREATMENTTYPE);
            aad.setReminderLevel("1");
            aad.setViolationLevel(1);
            aad.setNoticeType(NOTICE_TYPE);
            aad.setMedicalDeptCode(medicalDeptCode);
            aad.setMedicalDeptName(deptName);
            aad.setDoctorName(doctorName);
            aad.setDoctorId(doctorId);

            aad.setPatientId(patientId);
            aad.setPatientName(patientName);

            aad.setOutpatientNumber(aad.getOutpatientNumber());
            aad.setPrescriptionNumber(prescriptionNumber);
            aad.setProjectType(PROJECTTYPE);
            aad.setProejctCode(PROJECTCODE);

            aad.setQuantity(1);
            aad.setMedicalProjectCode("8001");
            aad.setMedicalProjectName("1");

            aad.setAmount(Double.valueOf(MidAuditDataTest.getRandom()));

            aad.setCreateBy("admin");
            aad.setCreateTime(new Date());
            afterwardsAuditDetailService.save(aad);
        }
    }


    AfterwardsAudit writeMaster(String doctorId, String doctorName) {
        AfterwardsAudit aa = new AfterwardsAudit();
        aa.setTreatmentType(TREATMENTTYPE);
        aa.setNoticeType(NOTICE_TYPE);
        aa.setMedicalDeptCode(medicalDeptCode);
        aa.setMedicalDeptName(deptName);
        aa.setDoctorName(doctorName);
        aa.setDoctorId(doctorId);
        aa.setPatientId(patientId);
        aa.setPatientName(patientName);

        aa.setOutpatientNumber(ZYH);
        aa.setPrescriptionNumber(prescriptionNumber);
        aa.setFeedbackResult("SUCCESS");
        aa.setFeedbackCode("0000");
        aa.setAuditSource("system(系统)");

        aa.setCreateBy("admin");
        aa.setCreateTime(new Date());

        afterwardsAuditService.save(aa);
        return aa;
    }

    public static void main(String[] args) {

        getRandom();
    }

    private static double getRandom() {
        Random a = new Random();
        int i = a.nextInt(200) - 80;
        double v = a.nextDouble();
        System.out.println(i + v);
        return i + v;
    }

    private static double getRandom(Double src) {
        Random a = new Random();
        if (src.intValue() > 0) {
            int i = a.nextInt(src.intValue());
            return src - i;
        }

        return 0;
    }
}