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

package org.jeecg;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.modules.medical.Constant;
import org.jeecg.modules.medical.entity.AfterIncidentDetailLog;
import org.jeecg.modules.medical.entity.AfterwardsAudit;
import org.jeecg.modules.medical.entity.AfterwardsAuditDetail;
import org.jeecg.modules.medical.entity.MedicalInsRuleInfo;
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.IAfterIncidentDetailLogService;
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.ISttlMasterBillService;
import org.jeecg.modules.medical.service.ISttlMasterDetailBillService;
import org.jeecg.modules.system.entity.SysUserDepart;
import org.jeecg.modules.system.mapper.SysUserDepartMapper;
import org.jeecg.modules.system.service.ISysDepartService;
import org.jeecg.modules.system.service.ISysDictService;
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.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;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @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 AfterwardsAuditDataTest {

    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 ISysDepartService sysDepartService;
    @Autowired
    private SysUserDepartMapper sysUserDepartMapper;


    @Autowired
    private IAfterwardsIncidentAuditDiagnoseService afterwardsIncidentAuditDiagnoseService;
    @Autowired
    private AfterWaringLogTestJob afterWaringLogTestJob;
    @Autowired
    ISysUserService sysUserService;
    @Autowired
    ISttlMasterBillService sttlMasterBillService;
    @Autowired
    ISttlMasterDetailBillService sttlMasterDetailBillService;
    @Autowired
    IMedicalInsRuleProjectService medicalInsRuleProjectService;
    @Autowired
    IMedicalInsRuleProjectDiagnoseService medicalInsRuleProjectDiagnoseService;
    @Autowired
    RuleEngine ruleEngine;
    @Autowired
    IMedicalInsRuleInfoService medicalInsRuleInfoService;
    @Autowired
    RedisTemplate redisTemplate;
    //    @Autowired
//    AfterWaringJob afterWaringJob;
    @Autowired
    IAfterIncidentDetailLogService afterIncidentDetailLogService;
    @Autowired
    ISysDictService sysDictService;

    //    @Autowired
//    IMedicalInsRuleProjectService medicalInsRuleProjectService;
    @Test
    public void testProjectCode() {
//        List<MedicalInsRuleProject> medicalInsRuleProjectList = medicalInsRuleProjectService.getRuleProjectByMedicalProjectCode("C17040122300004123asfsdf");
//        System.out.println(medicalInsRuleProjectList);
    }

    @Test
    public void testDD() {
        List<DictModel> cateGoriesList = sysDictService.getDictItems(Constant.DICT_CATEGORIES_ITEMS_KEY);
        Map<String, String> cateGoriesMap = new HashMap<>();
        for (DictModel dictModel : cateGoriesList) {
            cateGoriesMap.put(dictModel.getText(), dictModel.getValue());
        }
        System.out.println(cateGoriesMap);
    }

    @Test
    public void testXX() {
        List<AfterIncidentDetailLog> afterIncidentDetailLogList = afterIncidentDetailLogService.lambdaQuery().eq(AfterIncidentDetailLog::getAfterIncidentLogId, 217).list();
        System.out.println(afterIncidentDetailLogList);
    }

    @Test
    public void testAfterWaringJob() {
//        try {
////            afterWaringJob.execute(null);
//        } catch (JobExecutionException e) {
//            e.printStackTrace();
//        }
    }
//    @Autowired
//    org.jeecg.modules.medical.job.XCFYDatav_check_listJob XCFYDatav_check_listJob;
//    @Autowired
//    org.jeecg.modules.medical.job.XCFYDatav_diagnose_itemsJob XCFYDatav_diagnose_itemsJob;
//
//    @Test
//    public void testXCFYDatav_diagnose_itemsJob(){
//        try {
//            XCFYDatav_diagnose_itemsJob.execute(null);
//        } catch (JobExecutionException e) {
//            e.printStackTrace();
//        }
//    }

//    @Test
//    public void testXCFYDatav_check_listJob(){
//        try {
//            XCFYDatav_check_listJob.execute(null);
//
//        } catch (JobExecutionException e) {
//            e.printStackTrace();
//        }
//    }

    @Test
    public void testMAB() {
        try {
//            afterWaringLogTestJob.testMasterAdmBill();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


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


    @Test
    public void insertAfterWordDetail() {
        QueryWrapper<SttlMasterBill> queryWrapper = new QueryWrapper();
//        queryWrapper.notIn("jsdjh","0182940007_20201202081355","111929226_20201124104538","20200914-3603991000-014606");
//        queryWrapper.isNull("state");
        queryWrapper.last("limit 0,10");
        List<SttlMasterBill> sttlMasterBills = sttlMasterBillService.list(queryWrapper);
        List<AfterwardsAuditDetail> detailList = new ArrayList<>();
        Map<String, Boolean> codeDataMap = new ConcurrentHashMap<>();
        String[] sAr = {"1", "2", "3"};
        List<MedicalInsRuleInfo> medicalInsRuleInfoList = medicalInsRuleInfoService.lambdaQuery().in(MedicalInsRuleInfo::getTreatmentType, sAr).eq(MedicalInsRuleInfo::getState, Constant.EFF_STATE).list();
        if (!CollectionUtil.isNotEmpty(medicalInsRuleInfoList)) {
            log.error("规则配置表没有有效的规则");
            return;
        }
        /*
         * 根据规则id加载规则并初始化到redis里
         * 后续提醒通过redis加载id，把id传入规则引擎，迅速调用对应规则
         */
//        List<MedicalInsRuleInfo> midMedicalInsRuleInfoList = new ArrayList<>();
        Map<Integer, MedicalInsRuleInfo> medicalMap = new HashMap<>();
        for (MedicalInsRuleInfo medicalInsRuleInfo : medicalInsRuleInfoList) {
            medicalMap.put(medicalInsRuleInfo.getId(), medicalInsRuleInfo);
        }
        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);
    }

    @Test
    public void insertAfterWordDetailOne() {
        QueryWrapper<SttlMasterBill> queryWrapper = new QueryWrapper();
//        queryWrapper.notIn("jsdjh","0182940007_20201202081355","111929226_20201124104538","20200914-3603991000-014606");
//        queryWrapper.isNull("state");
        queryWrapper.last("limit 1,10");
        List<SttlMasterBill> sttlMasterBills = sttlMasterBillService.list(queryWrapper);
        List<AfterwardsAuditDetail> detailList = new ArrayList<>();
        Map<String, Boolean> codeDataMap = new ConcurrentHashMap<>();
        String[] sAr = {"1", "2", "3"};
        List<MedicalInsRuleInfo> medicalInsRuleInfoList = medicalInsRuleInfoService.lambdaQuery().in(MedicalInsRuleInfo::getTreatmentType, sAr).eq(MedicalInsRuleInfo::getState, Constant.EFF_STATE).list();
        if (!CollectionUtil.isNotEmpty(medicalInsRuleInfoList)) {
            log.error("规则配置表没有有效的规则");
            return;
        }
        /*
         * 根据规则id加载规则并初始化到redis里
         * 后续提醒通过redis加载id，把id传入规则引擎，迅速调用对应规则
         */
//        List<MedicalInsRuleInfo> midMedicalInsRuleInfoList = new ArrayList<>();
        Map<Integer, MedicalInsRuleInfo> medicalMap = new HashMap<>();
        for (MedicalInsRuleInfo medicalInsRuleInfo : medicalInsRuleInfoList) {
            medicalMap.put(medicalInsRuleInfo.getId(), medicalInsRuleInfo);
        }
        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("commonTaskAsyncPool")
    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());
                }
                afterwardsAuditDetail.setTreatmentType(medicalInsRuleInfo.getTreatmentType());
            }

        }
        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.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");
        afterwardsAuditDetail.setPrice(new BigDecimal(sttlMasterDetailBill.get单价()));
        afterwardsAuditDetail.setPrescriptionNumber(afterwardsAudit.getPrescriptionNumber());
        afterwardsAuditDetail.setOutpatientNumber(afterwardsAudit.getOutpatientNumber());

//                    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(AfterwardsAuditDataTest.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;
    }

    @Test
    public void depart() {
        String a = "1711012523714580481\n" +
                "1711012523949461506\n" +
                "1711012524184342529";


        String[] lines = a.split("\n");
        for (String id : lines) {
            SysUserDepart userDepart = new SysUserDepart(id, "1711037900931567617");
            sysUserDepartMapper.insert(userDepart);
        }

    }
}