web_server/src/main/java/thyyxxk/webserver/service/medicalinsurance/SiQueryService.java

package thyyxxk.webserver.service.medicalinsurance;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import thyyxxk.webserver.config.exception.ExceptionEnum;
import thyyxxk.webserver.constants.sidicts.SiFunction;
import thyyxxk.webserver.constants.YesOrNo;
import thyyxxk.webserver.constants.sidicts.*;
import thyyxxk.webserver.dao.his.medicalinsurance.SiQueryDao;
import thyyxxk.webserver.entity.ResultVo;
import thyyxxk.webserver.entity.medicalinsurance.inpatient.InHspPsnInfo;
import thyyxxk.webserver.entity.medicalinsurance.outpatient.SpcChrDiseAcct;
import thyyxxk.webserver.entity.medicalinsurance.query.*;
import thyyxxk.webserver.entity.medicalinsurance.setllist.*;
import thyyxxk.webserver.utils.*;

import java.time.LocalDate;
import java.util.*;

/**
 * @description: 医保查询服务
 * @author: DingJie
 * @create: 2021-06-23 16:35:23
 **/
@Slf4j
@Service
public class SiQueryService {
    private final ExecService exec;
    private final SiQueryDao dao;
    private static final String RESULT_CODE = "infcode";
    private static final String ERROR_MESSAGE = "err_msg";
    private static final String OUTPUT = "output";

    @Autowired
    public SiQueryService(ExecService exec, SiQueryDao dao) {
        this.exec = exec;
        this.dao = dao;
    }

    public ResultVo<PsnBaseInfo> obtainBasicPersonInfo(QryPsnBsInfo qryPsnBsInfo) {
        if (StringUtil.isBlank(qryPsnBsInfo.getMedType())) {
            return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "请选择患者的医疗类别！");
        }
        if (StringUtil.isBlank(qryPsnBsInfo.getSocialNo()) || StringUtil.isBlank(qryPsnBsInfo.getName())) {
            QryPsnBsInfo qpbi = dao.selectMzSocialAndName(qryPsnBsInfo.getPatNo());
            if (StringUtil.isBlank(qpbi.getSocialNo())) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "患者的身份证不能为空，请补充！");
            }
            qryPsnBsInfo.setTimes(qpbi.getTimes());
            qryPsnBsInfo.setName(qpbi.getName());
            qryPsnBsInfo.setSocialNo(qpbi.getSocialNo());
            qryPsnBsInfo.setLedgerSn(0);
        }
        JSONObject input = exec.makeTradeHeader(SiFunction.OBTAIN_BASIC_PERSON_INFO);
        JSONObject data = new JSONObject();
        data.put("mdtrt_cert_type", MdtrtCertType.RESIDENT_IDENTITY_CARD.getCode());
        data.put("mdtrt_cert_no", qryPsnBsInfo.getSocialNo());
        data.put("psn_cert_type", "01");
        data.put("certno", qryPsnBsInfo.getSocialNo());
        data.put("psn_name", qryPsnBsInfo.getName());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.OBTAIN_BASIC_PERSON_INFO);
        log.info("【操作员：{}】，人员基本信息获取：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONObject baseinfo = output.getJSONObject("baseinfo");
            PsnBaseInfo psnBaseinfo = JSONObject.parseObject(baseinfo.toJSONString(), PsnBaseInfo.class);
            psnBaseinfo.setPatNo(qryPsnBsInfo.getPatNo());
            psnBaseinfo.setTimes(qryPsnBsInfo.getTimes());
            psnBaseinfo.setLedgerSn(qryPsnBsInfo.getLedgerSn());
            psnBaseinfo.setMedType(qryPsnBsInfo.getMedType());
            if (null != psnBaseinfo.getGend()) {
                for (Gend gend : Gend.values()) {
                    if (gend.getCode().equals(psnBaseinfo.getGend())) {
                        psnBaseinfo.setGendName(gend.getName());
                        break;
                    }
                }
            }
            if (null != psnBaseinfo.getPsnCertType()) {
                for (PsnCertType type : PsnCertType.values()) {
                    if (type.getCode().equals(psnBaseinfo.getPsnCertType())) {
                        psnBaseinfo.setPsnCertTypeName(type.getName());
                        break;
                    }
                }
            }
            if (null != psnBaseinfo.getNaty()) {
                for (Naty naty : Naty.values()) {
                    if (naty.getCode().equals(psnBaseinfo.getNaty())) {
                        psnBaseinfo.setNatyName(naty.getName());
                        break;
                    }
                }
            }
            if (null != qryPsnBsInfo.getNeedSaving() && qryPsnBsInfo.getNeedSaving() == 1) {
                int saved = dao.selectSiZyInfoCount(qryPsnBsInfo.getPatNo(), qryPsnBsInfo.getTimes(), qryPsnBsInfo.getLedgerSn());
                if (saved == 0) {
                    dao.insertSiZyInfoPsnNo(psnBaseinfo);
                } else {
                    dao.updateSiZyInfoPsnNo(psnBaseinfo);
                }
                log.info("患者基本信息已更新：{}", psnBaseinfo);
                output.put("times", qryPsnBsInfo.getTimes());
            }

            List<InsuInfo> list = new ArrayList<>();
            JSONArray insuinfo = output.getJSONArray("insuinfo");
            for (int i = 0; i < insuinfo.size(); i++) {
                JSONObject item = insuinfo.getJSONObject(i);
                InsuInfo info = JSONObject.parseObject(item.toJSONString(), InsuInfo.class);
                if (null != info.getInsutype()) {
                    for (Insutype type : Insutype.values()) {
                        if (type.getCode().equals(info.getInsutype())) {
                            info.setInsutypeName(type.getName());
                            break;
                        }
                    }
                }
                if (null != info.getPsnType()) {
                    for (PsnType type : PsnType.values()) {
                        if (type.getCode().equals(info.getPsnType())) {
                            info.setPsnTypeName(type.getName());
                            break;
                        }
                    }
                }
                if (null != info.getPsnInsuStas()) {
                    if (info.getPsnInsuStas().equals(YesOrNo.YES.getCodeStr())) {
                        info.setPsnInsuStasName("正常参保");
                    } else {
                        info.setPsnInsuStasName("暂停参保");
                    }
                }
                if (null != info.getCvlservFlag()) {
                    if (info.getCvlservFlag().equals(YesOrNo.YES.getCodeStr())) {
                        info.setCvlservFlagName("是");
                    } else {
                        info.setCvlservFlagName("否");
                    }
                }
                if (null != info.getInsuplcAdmdvs()) {
                    info.setInsuplcAdmdvsName(dao.selectRegion(info.getInsuplcAdmdvs()));
                }
                list.add(info);
            }
            psnBaseinfo.setInsuinfo(list);
            return ResultVoUtil.success(psnBaseinfo);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<MedInsInfo>> obtainMedicalInstitutionInfo(String type, String fuzzyName) {
        JSONObject input = exec.makeTradeHeader(SiFunction.OBTAIN_MEDICAL_INSTITUTION_INFO);
        JSONObject medinsinfo = new JSONObject();
        medinsinfo.put("fixmedins_type", type);
        medinsinfo.put("fixmedins_name", fuzzyName);
        input.getJSONObject("input").put("medinsinfo", medinsinfo);
        JSONObject result = exec.executeTrade(input, SiFunction.OBTAIN_MEDICAL_INSTITUTION_INFO);
        log.info("【操作员：{}】，获取定点医药机构信息：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONArray output = result.getJSONObject(OUTPUT).getJSONArray("medinsinfo");
            List<MedInsInfo> list = new ArrayList<>();
            for (int i = 0; i < output.size(); i++) {
                JSONObject item = output.getJSONObject(i);
                MedInsInfo info = JSONObject.parseObject(item.toJSONString(), MedInsInfo.class);
                info.setFixmedinsAdmdvs(info.getFixmedinsCode().substring(1, 7));
                info.setFixmedinsAdmdvsName(dao.selectRegion(info.getFixmedinsAdmdvs()));
                if (null != info.getFixmedinsType()) {
                    for (FixmedinsType ele : FixmedinsType.values()) {
                        if (ele.getCode().equals(info.getFixmedinsType())) {
                            info.setFixmedinsTypeName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != info.getHospLv()) {
                    for (HospLv ele : HospLv.values()) {
                        if (ele.getCode().equals(info.getHospLv())) {
                            info.setHospLvName(ele.getName());
                            break;
                        }
                    }
                }
                list.add(info);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<MdtrtInfo>> queryVisitInfo(BscQryPrm q) {
        String psnNo = dao.selectPsnNoByPatNoAndMedType(q.getPatNo(), q.getMedType());
        if (null == psnNo) {
            return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有找到患者该医疗类别的我院就诊记录。");
        }
        q.setPsnNo(psnNo);
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_VISIT_INFO);
        String ref = JSONObject.toJSONStringWithDateFormat(q, "yyyy-MM-dd HH:mm:ss");
        input.getJSONObject("input").put("data", JSONObject.parseObject(ref));
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_VISIT_INFO);
        log.info("【操作员：{}】，查询就诊信息：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray mdts = output.getJSONArray("mdtrtinfo");
            List<MdtrtInfo> list = new ArrayList<>();
            for (int i = 0; i < mdts.size(); i++) {
                JSONObject item = mdts.getJSONObject(i);
                MdtrtInfo mdtrtInfo = JSONObject.parseObject(item.toJSONString(), MdtrtInfo.class);
                if (null != mdtrtInfo.getInsuOptins()) {
                    mdtrtInfo.setInsuOptinsName(dao.selectRegion(mdtrtInfo.getInsuOptins()));
                }
                SiEnumReflectUtil.mdtrtInfoReflect(mdtrtInfo);
                list.add(mdtrtInfo);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<DiseInfo>> queryDiagnosisInfo(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_DIAGNOSIS_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("mdtrt_id", q.getMdtrtId());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_DIAGNOSIS_INFO);
        log.info("【操作员：{}】，查询诊断信息：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            List<DiseInfo> list = new ArrayList<>();
            JSONArray diseInfos = output.getJSONArray("diseinfo");
            for (int i = 0; i < diseInfos.size(); i++) {
                JSONObject item = diseInfos.getJSONObject(i);
                DiseInfo diseInfo = JSONObject.parseObject(item.toJSONString(), DiseInfo.class);
                SiEnumReflectUtil.diseInfoReflect(diseInfo);
                list.add(diseInfo);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<SetlInfo> querySettlementInfo(BscQryPrm q) {
        SiPatInfo siPatInfo;
        if (null == q.getMdtrtId()) {
            if (null == q.getLedgerSn()) {
                q.setLedgerSn(0);
            }
            siPatInfo = dao.selectSiPatInfoForZy(q.getPatNo(), q.getTimes(), q.getLedgerSn());
        } else {
            siPatInfo = dao.selectSiPatInfoByMdtrtId(q.getMdtrtId());
        }
        if (null == siPatInfo) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该次就诊尚未结算，无法查询结算信息。");
        }
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_SETTLEMENT_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", siPatInfo.getPsnNo());
        data.put("setl_id", siPatInfo.getSetlId());
        data.put("mdtrt_id", siPatInfo.getMdtrtId());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_SETTLEMENT_INFO);
        log.info("【操作员：{}】，查询结算信息：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONObject obj = output.getJSONObject("setlinfo");
            if (null == obj) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到该次就诊的结算明细。");
            }
            SetlInfo setlInfo = JSONObject.parseObject(obj.toJSONString(), SetlInfo.class);
            if (null != setlInfo.getClrType()) {
                for (ClrType ele : ClrType.values()) {
                    if (ele.getCode().equals(setlInfo.getClrType())) {
                        setlInfo.setClrTypeName(ele.getName());
                        break;
                    }
                }
            }
            return ResultVoUtil.success(setlInfo);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<FeeDetl>> queryFeeDetails(BscQryPrm q) {
        SiPatInfo siPatInfo;
        if (null == q.getMdtrtId()) {
            if (null == q.getLedgerSn()) {
                q.setLedgerSn(0);
            }
            siPatInfo = dao.selectSiPatInfoForZy(q.getPatNo(), q.getTimes(), q.getLedgerSn());
        } else {
            siPatInfo = dao.selectSiPatInfoByMdtrtId(q.getMdtrtId());
        }
        if (null == siPatInfo) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该次就诊尚未结算，无法查询费用明细。");
        }
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_FEE_DETAILS);
        JSONObject data = new JSONObject();
        data.put("psn_no", siPatInfo.getPsnNo());
        data.put("setl_id", siPatInfo.getSetlId());
        data.put("mdtrt_id", siPatInfo.getMdtrtId());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_FEE_DETAILS);
        log.info("【操作员：{}】，查询费用明细：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONArray output = result.getJSONArray(OUTPUT);
            if (null == output || output.size() == 0) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到费用明细。");
            }
            List<FeeDetl> list = new ArrayList<>();
            for (int i = 0; i < output.size(); i++) {
                JSONObject obj = output.getJSONObject(i);
                FeeDetl item = JSONObject.parseObject(obj.toJSONString(), FeeDetl.class);
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<TrtInfo>> checkPersonTreatment(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.CHECK_PERSON_TREATMENT);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("insutype", q.getInsutype());
        data.put("fixmedins_code", SiUtil.INSTITUTION_ID);
        data.put("med_type", q.getMedType());
        data.put("begntime", DateUtil.formatDatetime(q.getBegntime()));
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.CHECK_PERSON_TREATMENT);
        log.info("【操作员：{}】，人员待遇享受检查：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            List<TrtInfo> list = new ArrayList<>();
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray trtinfo = output.getJSONArray("trtinfo");
            for (int i = 0; i < trtinfo.size(); i++) {
                JSONObject obj = trtinfo.getJSONObject(i);
                TrtInfo item = JSONObject.parseObject(obj.toJSONString(), TrtInfo.class);
                if (null != item.getTrtChkType()) {
                    for (TrtChkType ele : TrtChkType.values()) {
                        if (ele.getCode().equals(item.getTrtChkType())) {
                            item.setTrtChkTypeName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getFundPayType()) {
                    for (FundPayType ele : FundPayType.values()) {
                        if (ele.getCode().equals(item.getFundPayType())) {
                            item.setFundPayTypeName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getTrtEnjymntFlag()) {
                    if (item.getTrtEnjymntFlag().equals(YesOrNo.YES.getCodeStr())) {
                        item.setTrtEnjymntFlagName("是");
                    } else {
                        item.setTrtEnjymntFlagName("否");
                    }
                }
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<InHspPsnInfo>> queryInHospitalPatientsInfo(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_IN_HOSPITAL_PATIENTS_INFO);
        JSONObject data = new JSONObject();
        if (StringUtil.notBlank(q.getPatNo())) {
            String psnNo = dao.selectPsnNo(q.getPatNo());
            if (null == psnNo) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "【住院号/门诊号：" + q.getPatNo() +
                        "】没有找到此患者在我院的医保在院信息，请核实。");
            }
            data.put("psn_no", psnNo);
        }
        data.put("begntime", DateUtil.formatDatetime(q.getBegntime()));
        data.put("endtime", null == q.getEndtime() ? DateUtil.now() : DateUtil.formatDatetime(q.getEndtime()));
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_IN_HOSPITAL_PATIENTS_INFO);
        log.info("【操作员：{}】，在院信息查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray pts = output.getJSONArray("data");
            if (pts.size() == 0) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到医保在院的患者信息。");
            }
            List<InHspPsnInfo> list = new ArrayList<>();
            for (int i = 0; i < pts.size(); i++) {
                JSONObject item = pts.getJSONObject(i);
                InHspPsnInfo inHspPsnInfo = JSONObject.parseObject(item.toJSONString(), InHspPsnInfo.class);
                SiEnumReflectUtil.inHspPsnInfoReflect(inHspPsnInfo);
                list.add(inHspPsnInfo);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<RefMedin>> queryPersonnelTransferHospitalInfo(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_PERSONNEL_TRANSFER_HOSPITAL_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("begntime", DateUtil.formatDatetime(q.getBegntime()));
        data.put("endtime", DateUtil.formatDatetime(q.getEndtime()));
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_PERSONNEL_TRANSFER_HOSPITAL_INFO);
        log.info("【操作员：{}】，转院信息查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray array = output.getJSONArray("refmedin");
            if (null == array || array.size() == 0) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到符合条件的转院信息。");
            }
            List<RefMedin> list = new ArrayList<>();
            for (int i = 0; i < array.size(); i++) {
                JSONObject obj = array.getJSONObject(i);
                RefMedin item = JSONObject.parseObject(obj.toJSONString(), RefMedin.class);
                if (null != item.getInsutype()) {
                    for (Insutype ele : Insutype.values()) {
                        if (ele.getCode().equals(item.getInsutype())) {
                            item.setInsutypeName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getDclaSouc()) {
                    for (DclaSouc ele : DclaSouc.values()) {
                        if (ele.getCode().equals(item.getDclaSouc())) {
                            item.setDclaSoucName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getPsnCertType()) {
                    for (PsnCertType ele : PsnCertType.values()) {
                        if (ele.getCode().equals(item.getPsnCertType())) {
                            item.setPsnCertTypeName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getGend()) {
                    for (Gend ele : Gend.values()) {
                        if (ele.getCode().equals(item.getGend())) {
                            item.setGendName(ele.getName());
                            break;
                        }
                    }
                }
                if (null != item.getInsuOptins()) {
                    item.setInsuOptinsName(dao.selectRegion(item.getInsuOptins()));
                }
                if (null != item.getOutFlag()) {
                    if (item.getOutFlag().equals(YesOrNo.YES.getCodeStr())) {
                        item.setOutFlagName("是");
                    } else {
                        item.setOutFlagName("否");
                    }
                }
                if (null != item.getHospAgreReflFlag()) {
                    if (item.getHospAgreReflFlag().equals(YesOrNo.YES.getCodeStr())) {
                        item.setHospAgreReflFlagName("是");
                    } else {
                        item.setHospAgreReflFlagName("否");
                    }
                }
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<MedUseRcd>> querySpecialChronicDiseasesMedicalRecord(BscQryPrm q) {
        if (null == q.getPsnNo()) {
            String psnNo = dao.selectPsnNo(q.getPatNo());
            if (null == psnNo) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "【住院号/门诊号：" + q.getPatNo() +
                        "】未找到此患者的医保参保信息，请核实。");
            }
            q.setPsnNo(psnNo);
        }
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_SPECIAL_CHRONIC_DISEASES_MEDICAL_RECORD);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("begntime", DateUtil.formatDatetime(q.getBegntime()));
        data.put("endtime", DateUtil.formatDatetime(q.getEndtime()));
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_SPECIAL_CHRONIC_DISEASES_MEDICAL_RECORD);
        log.info("【操作员：{}】，人员慢特病用药记录查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray array = output.getJSONArray("feedetail");
            if (null == array || array.size() == 0) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到此人的慢特病用药记录。");
            }
            List<MedUseRcd> list = new ArrayList<>();
            for (int i = 0; i < array.size(); i++) {
                JSONObject obj = array.getJSONObject(i);
                MedUseRcd item = JSONObject.parseObject(obj.toJSONString(), MedUseRcd.class);
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<CumInfo>> queryPersonnelCumulativeInfo(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_PERSONNEL_CUMULATIVE_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("cum_ym", q.getCumYm());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_PERSONNEL_CUMULATIVE_INFO);
        log.info("【操作员：{}】，人员累计信息查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray array = output.getJSONArray("cuminfo");
            List<CumInfo> list = new ArrayList<>();
            for (int i = 0; i < array.size(); i++) {
                JSONObject obj = array.getJSONObject(i);
                CumInfo item = JSONObject.parseObject(obj.toJSONString(), CumInfo.class);
                if (null != item.getInsutype()) {
                    for (Insutype ele : Insutype.values()) {
                        if (ele.getCode().equals(item.getInsutype())) {
                            item.setInsutypeName(ele.getName());
                            break;
                        }
                    }
                }
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<SpcChrDiseAcct>> querySpecialChronicDiseasesAccreditation(BscQryPrm q) {
        if (null == q.getPsnNo()) {
            String psnNo = dao.selectPsnNo(q.getPatNo());
            if (null == psnNo) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "【住院号/门诊号：" + q.getPatNo() +
                        "】未找到此患者的医保参保信息，请核实。");
            }
            q.setPsnNo(psnNo);
        }
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_SPECIAL_CHRONIC_DISEASES_ACCREDITATION);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_SPECIAL_CHRONIC_DISEASES_ACCREDITATION);
        log.info("【操作员：{}】，人员慢特病备案查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray details = output.getJSONArray("feedetail");
            List<SpcChrDiseAcct> list = new ArrayList<>();
            Date now = new Date();
            for (int i = 0; i < details.size(); i++) {
                JSONObject detail = details.getJSONObject(i);
                SpcChrDiseAcct spcChrDiseAcct = JSONObject.parseObject(detail.toJSONString(), SpcChrDiseAcct.class);
                if (null != q.getNeedAllRcd() && 1 == q.getNeedAllRcd()) {
                    list.add(spcChrDiseAcct);
                } else {
                    if (now.before(spcChrDiseAcct.getEnddate())) {
                        spcChrDiseAcct.setPatNo(q.getPatNo());
                        spcChrDiseAcct.setTimes(q.getTimes());
                        list.add(spcChrDiseAcct);
                    }
                }
            }
            if (list.size() > 0) {
                return ResultVoUtil.success(list);
            }
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "此患者没有有效的慢特病备案，或慢特病备案已过期！");
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<List<PsnFixMedin>> queryPersonnelAssignmentInfo(BscQryPrm q) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_PERSONNEL_ASSIGNMENT_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", q.getPsnNo());
        data.put("biz_appy_type", q.getBizAppyType());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_PERSONNEL_ASSIGNMENT_INFO);
        log.info("【操作员：{}】，人员定点信息查询：参数：{}，结果：{}", TokenUtil.getTokenUserId(), input, result);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue(RESULT_CODE) == 0) {
            JSONObject output = result.getJSONObject(OUTPUT);
            JSONArray array = output.getJSONArray("psnfixmedin");
            if (null == array || array.size() == 0) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到对应的点定信息。");
            }
            List<PsnFixMedin> list = new ArrayList<>();
            for (int i = 0; i < array.size(); i++) {
                JSONObject obj = array.getJSONObject(i);
                PsnFixMedin item = JSONObject.parseObject(obj.toJSONString(), PsnFixMedin.class);
                if (null != item.getInsutype()) {
                    for (Insutype ele : Insutype.values()) {
                        if (ele.getCode().equals(item.getInsutype())) {
                            item.setInsutypeName(ele.getName());
                            break;
                        }
                    }
                }
                list.add(item);
            }
            return ResultVoUtil.success(list);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, result.getString(ERROR_MESSAGE));
    }

    public ResultVo<String> queryInsuplcAdmdvsByMdtrtId(String mdtrtId) {
        return ResultVoUtil.success(dao.selectInsuplcAdmdvsByMdtrtId(mdtrtId));
    }

    public ResultVo<List<SetlIndex>> querySiSetlIndex(QrySetlListPrm q) {
        List<SetlIndex> list = dao.selectSetlIndex(q);
        if (null == list || list.isEmpty()) {
            return ResultVoUtil.fail(ExceptionEnum.NO_DATA_EXIST);
        }
        for (SetlIndex index : list) {
            for (Gend ele : Gend.values()) {
                if (index.getGend().equals(ele.getCode())) {
                    index.setGendName(ele.getName());
                    break;
                }
            }
        }
        return ResultVoUtil.success(list);
    }

    public ResultVo querySiSetlList(SetlIndex index) {
        if (StringUtil.isBlank(index.getPsnNo())) {
            index.setPsnNo(dao.selectPsnNo(index.getPatNo()));
        }
        CuminfoInYear cuminfo = getYearCuminfo(index.getPsnNo());
        if (cuminfo.getCode() != ExceptionEnum.SUCCESS.getCode()) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, cuminfo.getMessage());
        }
        if (index.getType() == SetlType.YZS_INPATIENT.getCode()) {
            YzsInptntSetlmtLst lst = dao.selectYzsZySetlinfo(index.getSetlId());
            return ResultVoUtil.success(lst);
        } else if (index.getType() == SetlType.NORMAL_INPATIENT.getCode()) {
            InptntSetlmtLst lst = dao.selectZySetlifo(index.getSetlId());
            lst.setFixmedinsName(SiUtil.INSTITUTION_NAME);
            lst.setGendName(index.getGendName());
            SiEnumReflectUtil.inptntSetlmtLstReflect(lst);
            List<BrfChrgitm> chrgitms = dao.selectZyBrfChrgitms(index.getPatNo(), index.getTimes(), index.getLedgerSn());
            analyzeZyChrgitm(lst, chrgitms);
            lst.setYrAdmtimes(cuminfo.getYearAdmtimes());
            lst.setYrMedfeeSumamt(cuminfo.getYearMedfeesum());
            lst.setYrPayedBegnLine(cuminfo.getYearPayedBegnline());
            lst.setYrFundPaySumamt(cuminfo.getYearBaseFundPayAmt());
            lst.setYrBigAmtFundPay(cuminfo.getYearBigAmtpays());
            lst.setYrBigDssInsPay(cuminfo.getYearBigdssFundPayAmt());
            lst.setYrMafPay(cuminfo.getYearMafPayAmt());
            return listPolItemCodePayInfo(lst);
        } else {
            index.setLedgerSn(0);
            OtptntSetlmtLst lst = dao.selectMzSetlifo(index.getPatNo(), index.getTimes());
            if (null == lst) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "没有找到此患者的结算信息！");
            }
            SiEnumReflectUtil.outptntSetlmtLstReflect(lst);
            List<BrfChrgitm> chrgitms = dao.selectMzBrfChrgitms(index.getPatNo(), index.getTimes());
            analyzeMzChrgitm(lst, chrgitms);
            lst.setYrAdmtimes(cuminfo.getYearAdmtimes());
            lst.setYrMedfeeSumamt(cuminfo.getYearMedfeesum());
            lst.setYrFundPaySumamt(cuminfo.getYearBaseFundPayAmt());
            lst.setYrBigAmtFundPay(cuminfo.getYearBigAmtpays());
            lst.setYrMafPay(cuminfo.getYearMafPayAmt());
            lst.setFixmedinsName(SiUtil.INSTITUTION_NAME);
            return ResultVoUtil.success(lst);
        }
    }

    private ResultVo<InptntSetlmtLst> listPolItemCodePayInfo(InptntSetlmtLst lst) {
        JSONObject input = exec.makeTradeHeader(SiFunction.LIST_POL_ITEM_CODE_PAY_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", lst.getPsnNo());
        data.put("mdtrt_id", lst.getMdtrtId());
        data.put("setl_id", lst.getSetlId());
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.LIST_POL_ITEM_CODE_PAY_INFO);
        if (null == result) {
            return ResultVoUtil.fail(ExceptionEnum.NETWORK_ERROR);
        }
        if (result.getIntValue("code") != 0) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "医保中心出错：" + result.getString("message"));
        }
        JSONArray array = result.getJSONArray("data");
        double selfPaySum = 0d;
        double fundPaySum = 0d;
        for (int i = 0; i < array.size(); i++) {
            JSONObject itm = array.getJSONObject(i);
            Double selfPayAmt = itm.getDouble("selfPayAmt");
            String selfPayProp = itm.getString("selfPayProp");
            Double fundPayAmt = itm.getDouble("fundPayAmt");
            String fundPayProp = itm.getString("fundPayProp");
            Double polItemPaySum = itm.getDouble("polItemPaySum");
            if (null != selfPayAmt) {
                selfPaySum += selfPayAmt;
            }
            if (null != fundPayAmt) {
                fundPaySum += fundPayAmt;
            }
            switch (itm.getString("polItemName")) {
                case "全自费":
                    lst.setSelfPayPsnAmt(selfPayAmt);
                    lst.setSelfPayPsnProp(selfPayProp);
                    lst.setSelfPayFundAmt(fundPayAmt);
                    lst.setSelfPayFundProp(fundPayProp);
                    lst.setSelfPaySum(polItemPaySum);
                    break;
                case "乙类先自付":
                    lst.setScndPrePayPsnAmt(selfPayAmt);
                    lst.setScndPrePayPsnProp(selfPayProp);
                    lst.setScndPrePayFundAmt(fundPayAmt);
                    lst.setScndPrePayFundProp(fundPayProp);
                    lst.setScndPrePaySum(polItemPaySum);
                    break;
                case "超限额自付":
                    lst.setOvrlmtSelfPayPsnAmt(selfPayAmt);
                    lst.setOvrlmtSelfPayPsnProp(selfPayProp);
                    lst.setOvrlmtSelfPayFundAmt(fundPayAmt);
                    lst.setOvrlmtSelfPayFundProp(fundPayProp);
                    lst.setOvrlmtSelfPaySum(polItemPaySum);
                    break;
                case "本次应付起付标准":
                    lst.setBegnlinePsnAmt(selfPayAmt);
                    lst.setBegnlinePsnProp(selfPayProp);
                    lst.setBegnlineFundAmt(fundPayAmt);
                    lst.setBegnlineFundProp(fundPayProp);
                    lst.setBegnlineSum(polItemPaySum);
                    break;
                case "统筹一段":
                    lst.setFundFrstLvPsnAmt(selfPayAmt);
                    lst.setFundFrstLvPsnProp(selfPayProp);
                    lst.setFundFrstLvFundAmt(fundPayAmt);
                    lst.setFundFrstLvFundProp(fundPayProp);
                    lst.setFundFrstLvSum(polItemPaySum);
                    break;
                case "统筹二段":
                    lst.setFundScndLvPsnAmt(selfPayAmt);
                    lst.setFundScndLvPsnProp(selfPayProp);
                    lst.setFundScndLvFundAmt(fundPayAmt);
                    lst.setFundScndLvFundProp(fundPayProp);
                    lst.setFundScndLvSum(polItemPaySum);
                    break;
                case "大额一段":
                    lst.setBigAmtFrstLvPsnAmt(selfPayAmt);
                    lst.setBigAmtFrstLvPsnProp(selfPayProp);
                    lst.setBigAmtFrstLvFundAmt(fundPayAmt);
                    lst.setBigAmtFrstLvFundProp(fundPayProp);
                    lst.setBigAmtFrstLvSum(polItemPaySum);
                    break;
            }
        }
        lst.setAllPsnAmt(selfPaySum);
        lst.setAllFundAmt(fundPaySum);
        lst.setAllSum(fundPaySum + selfPaySum);
        return ResultVoUtil.success(lst);
    }

    private CuminfoInYear getYearCuminfo(String psnNo) {
        JSONObject input = exec.makeTradeHeader(SiFunction.QUERY_PERSONNEL_CUMULATIVE_INFO);
        JSONObject data = new JSONObject();
        data.put("psn_no", psnNo);
        data.put("cum_ym", "");
        input.getJSONObject("input").put("data", data);
        JSONObject result = exec.executeTrade(input, SiFunction.QUERY_PERSONNEL_CUMULATIVE_INFO);
        CuminfoInYear cuminfo = new CuminfoInYear();
        if (null == result) {
            cuminfo.setCode(ExceptionEnum.NETWORK_ERROR.getCode());
            cuminfo.setMessage(ExceptionEnum.NETWORK_ERROR.getMessage());
            return cuminfo;
        }
        if (result.getIntValue(RESULT_CODE) != 0 || result.getIntValue("code") != 0) {
            cuminfo.setCode(ExceptionEnum.NETWORK_ERROR.getCode());
            cuminfo.setMessage("医保中心出错：" + result.getString("message"));
            return cuminfo;
        }
        cuminfo.setCode(ExceptionEnum.SUCCESS.getCode());
        String year = String.valueOf(LocalDate.now().getYear());
        JSONArray cuminfos = result.getJSONObject(OUTPUT).getJSONArray("cuminfo");
        for (int i = 0; i < cuminfos.size(); i++) {
            JSONObject itm = cuminfos.getJSONObject(i);
            if (itm.getString("year").equals(year)) {
                switch (itm.getString("cum_type_code")) {
                    case "C0000":
                        cuminfo.addYearAdmtimes(itm.getDoubleValue("cum"));
                        break;
                    case "F0000":
                        cuminfo.addYearFeesum(itm.getDoubleValue("cum"));
                        break;
                    case "Q0000":
                        cuminfo.addYearPayedbegnline(itm.getDoubleValue("cum"));
                        break;
                    case "D310101":
                    case "D390101":
                        cuminfo.addYearFundpays(itm.getDoubleValue("cum"));
                        break;
                    case "D330101":
                        cuminfo.addYearBigAmtpays(itm.getDoubleValue("cum"));
                        break;
                    case "D390201":
                        cuminfo.addYearBigdssInspays(itm.getDoubleValue("cum"));
                        break;
                    case "D610101":
                        cuminfo.addYearMafpays(itm.getDoubleValue("cum"));
                        break;
                }
            }
        }
        return cuminfo;
    }

    private void analyzeZyChrgitm(InptntSetlmtLst lst, List<BrfChrgitm> chrgitms) {
        Map<String, Double> map = new HashMap<>();
        map.put("totalFrst", 0d);
        map.put("totalScnd", 0d);
        chrgitms.forEach(itm -> {
            if (itm.getChrgitmLv().equals(ChrgitmLv.FIRST_CLASS.getCode())) {
                map.replace("totalFrst", map.get("totalFrst") + itm.getChargeFee());
            } else if (itm.getChrgitmLv().equals(ChrgitmLv.SECOND_CLASS.getCode())) {
                map.replace("totalScnd", map.get("totalScnd") + itm.getChargeFee());
            }
            String typeKey = itm.getMedChrgitmType();
            String lvKey = typeKey + "-" + itm.getChrgitmLv();
            if (map.containsKey(typeKey)) {
                map.replace(typeKey, map.get(typeKey) + itm.getChargeFee());
            } else {
                map.put(typeKey, itm.getChargeFee());
            }
            if (map.containsKey(lvKey)) {
                map.replace(lvKey, map.get(lvKey) + itm.getChargeFee());
            } else {
                map.put(lvKey, itm.getChargeFee());
            }
        });
        lst.setAllfeeSum(map.get("totalFrst") + map.get("totalScnd"));
        lst.setAllfeeFrst(map.get("totalFrst"));
        lst.setAllfeeScnd(map.get("totalScnd"));
        lst.setWestMedFeeSum(map.get("09"));
        lst.setWestMedFeeFrst(map.get("09-01"));
        lst.setWestMedFeeScnd(map.get("09-02"));
        lst.setHerbalSum(map.get("10"));
        lst.setHerbalFrst(map.get("10-01"));
        lst.setHerbalScnd(map.get("10-02"));
        lst.setChnsPtntSum(map.get("11"));
        lst.setChnsPtntFrst(map.get("11-01"));
        lst.setChnsPtntScnd(map.get("11-02"));
        lst.setClinicSum(map.get("02"));
        lst.setClinicFrst(map.get("02-01"));
        lst.setClinicScnd(map.get("02-02"));
        lst.setTreatSum(map.get("05"));
        lst.setTreatFrst(map.get("05-01"));
        lst.setTreatScnd(map.get("05-02"));
        lst.setSurgerySum(map.get("06"));
        lst.setSurgeryFrst(map.get("06-01"));
        lst.setSurgeryScnd(map.get("06-02"));
        lst.setNursingSum(map.get("07"));
        lst.setNursingFrst(map.get("07-01"));
        lst.setNursingScnd(map.get("07-02"));
        lst.setSntryMtrlsSum(map.get("08"));
        lst.setSntryMtrlsFrst(map.get("08-01"));
        lst.setSntryMtrlsScnd(map.get("08-02"));
        lst.setExamSum(map.get("04"));
        lst.setExamFrst(map.get("04-01"));
        lst.setExamScnd(map.get("04-02"));
        lst.setNrmlTrtmtSum(map.get("12"));
        lst.setNrmlTrtmtFrst(map.get("12-01"));
        lst.setNrmlTrtmtScnd(map.get("12-02"));
        lst.setInspectSum(map.get("03"));
        lst.setInspectFrst(map.get("03-01"));
        lst.setInspectScnd(map.get("03-02"));
        lst.setRegisterSum(map.get("13"));
        lst.setRegisterFrst(map.get("13-01"));
        lst.setRegisterScnd(map.get("13-02"));
        lst.setBedfeeSum(map.get("01"));
        lst.setBedfeeFrst(map.get("01-01"));
        lst.setBedfeeScnd(map.get("01-02"));
        lst.setOthfeeSum(map.get("14"));
        lst.setOthfeeFrst(map.get("14-01"));
        lst.setOthfeeScnd(map.get("14-02"));
    }

    private void analyzeMzChrgitm(OtptntSetlmtLst lst, List<BrfChrgitm> chrgitms) {
        Map<String, Double> map = new HashMap<>();
        map.put("allfeeSum", 0d);
        map.put("totalThrd", 0d);
        map.put("totalScnd", 0d);
        map.put("othSum", 0d);
        map.put("othThrd", 0d);
        map.put("othScnd", 0d);
        chrgitms.forEach(itm -> {
            map.replace("allfeeSum", map.get("allfeeSum") + itm.getChargeFee());
            if (itm.getChrgitmLv().equals(ChrgitmLv.SELF_PAY.getCode())) {
                map.replace("totalThrd", map.get("totalThrd") + itm.getChargeFee());
            } else if (itm.getChrgitmLv().equals(ChrgitmLv.SECOND_CLASS.getCode())) {
                map.replace("totalScnd", map.get("totalScnd") + itm.getChargeFee());
            }
            String typeKey = itm.getMedChrgitmType();
            if (!typeKey.equals("09") && !typeKey.equals("11")) {
                map.replace("othSum", map.get("othSum") + itm.getChargeFee());
                if (itm.getChrgitmLv().equals(ChrgitmLv.SELF_PAY.getCode())) {
                    map.replace("othThrd", map.get("othThrd") + itm.getChargeFee());
                } else if (itm.getChrgitmLv().equals(ChrgitmLv.SECOND_CLASS.getCode())) {
                    map.replace("othScnd", map.get("othScnd") + itm.getChargeFee());
                }
            } else {
                String lvKey = typeKey + "-" + itm.getChrgitmLv();
                if (map.containsKey(typeKey)) {
                    map.replace(typeKey, map.get(typeKey) + itm.getChargeFee());
                } else {
                    map.put(typeKey, itm.getChargeFee());
                }
                if (map.containsKey(lvKey)) {
                    map.replace(lvKey, map.get(lvKey) + itm.getChargeFee());
                } else {
                    map.put(lvKey, itm.getChargeFee());
                }
            }

        });
        lst.setAllfeeSum(map.get("allfeeSum"));
        lst.setAllfeeThrd(map.get("totalThrd"));
        lst.setAllfeeScnd(map.get("totalScnd"));
        lst.setWestMedFeeSum(map.get("09"));
        lst.setWestMedFeeThrd(map.get("09-03"));
        lst.setWestMedFeeScnd(map.get("09-02"));
        lst.setChnsPtntSum(map.get("11"));
        lst.setChnsPtntThrd(map.get("11-03"));
        lst.setChnsPtntScnd(map.get("11-02"));
        lst.setMedsrvcSum(map.get("othSum"));
        lst.setMedsrvcThrd(map.get("othThrd"));
        lst.setMedsrvcScnd(map.get("othScnd"));
    }
}