Case 13: Medical insurance reimbursement

This case corresponds to Scenario 13 in the JQuick-Java repository’s USE-CASES.md, targeting instant medical insurance settlement in the healthcare domain. The system first determines the catalog scope of class A, class B, and class C drugs — items outside the catalog are fully self-paid. For in-catalog items, the deductible and reimbursement ratio are determined by insurance type (employee / resident) and hospital level (tier-3A / tier-2 / community); emergency visits halve the deductible and raise the ratio by 5 percentage points, and class B drugs take a 10% upfront self-pay first. The final pooled payment is truncated by the annual pooled-fund cap. Off-site treatment without filing is routed to manual review. All policy criteria are driven by JQuick-Java XML rule proxies.

Industry scenario

Instant medical insurance settlement happens at the hospital cashier window: after the insured registers with a medical settlement slip (MedicalClaim), the system captures the insurance type (EMPLOYEE employee insurance / RESIDENT resident insurance), hospital level (THIRD_A tier-3A / SECOND_A tier-2 / COMMUNITY community), expense category (DRUG_A class A drug / DRUG_B class B drug / DRUG_C class C self-paid / TREATMENT treatment / EXAMINATION examination), the total expense of this visit, whether it is an emergency, whether it is off-site treatment and whether it has been filed, and the year-to-date accumulated pooled-fund payment.

The first gate of settlement is catalog scope determination: class C (DRUG_C) is outside the catalog, the conclusion is directly SELF_PAY, pooled payment is 0, all expenses are borne by the individual, and the downstream deductible and ratio chain is not executed. In-catalog items enter the full reimbursement chain: first deduct the class B drug’s 10% upfront self-pay, then deduct the deductible, multiply the remainder by the reimbursement ratio to get the theoretical pooled payment, and finally compare and truncate against the remaining allowance of the annual cap.

The deductible and ratio form a policy matrix of “insurance type × hospital level × emergency”: for regular visits, employee deductibles at tier-3A / tier-2 / community are 800/500/200 yuan with ratios 0.9/0.85/0.8; resident deductibles are 600/300/100 yuan with ratios 0.7/0.65/0.6. For emergencies, deductibles are halved (employee tier-3A 400, tier-2 250, community 100) and the ratio is raised by 0.05 on top of the matrix, capped at 1.0. The annual cap is 300,000 for employees and 200,000 for residents; when the payment exceeds the remaining annual allowance, it settles at the remaining allowance, and when the remaining allowance is ≤0 the payment is 0.

Compliance conclusions come in three tiers: out-of-catalog SELF_PAY; off-site treatment without filing MANUAL_REVIEW, with expenses held for manual review before settlement; otherwise APPROVE for instant settlement. In addition, needManualReview is set when a single pooled payment reaches 50,000 yuan or the conclusion itself is manual review. The decision result fully retains the deductible, upfront self-pay, ratio, pooled payment, personal self-pay, cap, whether the cap was hit, and item-by-item settlement notes.

Business pain points

The policy matrix has many dimensions and is hard-coded: the three dimensions of insurance type × hospital level × emergency stack into 12 deductible tiers and 6 ratio tiers, written in nested Java if-else blocks that are extremely hard to verify, and cashier staff cannot see the criteria directly.
Medical insurance policy adjustments require re-releasing hospital systems: deductibles, reimbursement ratios, caps, and the class B upfront self-pay ratio adjust annually with regional policies; HIS release windows are strict and regression costs are high.
The reimbursement chain order must not be wrong: out-of-catalog must return early; in-catalog must chain “upfront self-pay → deductible → ratio → cap truncation” in order — reversing the order or missing a deduction causes erroneous fund payments.
Deductible halving and ratio uplift need overflow protection: the emergency ratio adds +0.05 on top of the matrix; without the 1.0 cap, high tiers could produce reimbursement ratios above 100%.
The annual cap is a dynamic remaining allowance, not a fixed threshold: truncation is based on “annual cap - year-to-date accumulated payment”; when the remaining allowance is insufficient or even 0, deterministic behavior is required — a simple fixed-cap comparison is not enough.
Medical insurance audits require every settlement to be explainable: out-of-catalog self-pay, class B upfront self-pay, emergency preference, cap truncation, and off-site unfiled holds must all be traceable in settlement notes; moreover, many regional core systems still run on JDK 8 / IT-innovation environments where heavy rule platforms are hard to introduce.

Solution architecture

This case adopts the six-piece structure of “input model + decision result model + rule interface + XML rule script + Service orchestration + JUnit tests”. The catalog, deductible/ratio matrix, upfront self-pay, cap, and filing criteria are all externalized in XML; the Service handles reimbursement chain sequencing, negative-value zeroing, and note assembly:

Layer	Responsibility	Files
Domain model	Settlement elements, reimbursement decision (deductible / ratio / payment / conclusion / notes)	MedicalClaim.java, ReimbursementDecision.java
Rule set & XML	8 rule methods for catalog / deductible / ratio / upfront self-pay / cap / conclusion	MedicalReimbursementRules.java, medical-reimbursement.xml
Orchestration service	Catalog → self-pay → deductible → ratio → cap chain sequencing, conclusion and note assembly	MedicalReimbursementService.java
Tests	6 settlement profiles (class A, class B, class C, cap, emergency, off-site)	MedicalReimbursementServiceTest.java

Rule method breakdown

The rule interface has 8 methods in total, separating policy queries from conclusion determination:

Rule method	Criterion	Score / output
`withinCatalog`	Returns false when the expense category is DRUG_C (class C); class A, class B, treatment, and examination are in the catalog	boolean
`deductible`	Employee 800/500/200, resident 600/300/100 (tier-3A/tier-2/community); halved in emergencies to 400/250/100 and 300/150/50	Deductible amount
`reimburseRatio`	Employee 0.9/0.85/0.8, resident 0.7/0.65/0.6; emergency +0.05, truncated to 1.0 when exceeding	Reimbursement ratio
`prepaidSelfPay`	Class B drug DRUG_B upfront self-pay = total expense × 10%; 0 for other categories	Upfront self-pay amount
`annualCap`	Employee insurance 300000, resident insurance 200000	Annual cap
`applyCap`	Returns 0 when remaining allowance ≤0; returns the remaining allowance when the theoretical payment exceeds it; otherwise pays as-is	Truncated payment
`complianceResult`	Out-of-catalog SELF_PAY; off-site and unfiled MANUAL_REVIEW; otherwise APPROVE	Conclusion string
`needManualReview`	Returns true when the conclusion is MANUAL_REVIEW, or APPROVE with a single pooled payment ≥50000	boolean

Code implementation (complete & runnable)

Place the following six files into the JQuick-Java test project using the original package names from the source: the two models go into com.github.paohaijiao.demo.model, the rule interface and test class go into com.github.paohaijiao.demo, the orchestration service goes into com.github.paohaijiao.demo.service, and the XML script goes into src/test/resources/demo/. Keeping directories and package names unchanged, run mvn test -Dtest=MedicalReimbursementServiceTest at the project root.

MedicalClaim.java

package com.github.paohaijiao.demo.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 医保结算要素（报销合规校验所需的就诊与费用快照）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class MedicalClaim {

    /**
     * 结算单号
     */
    private String claimNo;

    /**
     * 患者姓名
     */
    private String patientName;

    /**
     * 参保类型：EMPLOYEE-职工医保 / RESIDENT-居民医保
     */
    private String insuranceType;

    /**
     * 医院等级：THIRD_A-三甲 / SECOND_A-二级 / COMMUNITY-社区
     */
    private String hospitalLevel;

    /**
     * 费用类别：DRUG_A-甲类药 / DRUG_B-乙类药 / DRUG_C-丙类自费 / TREATMENT-诊疗 / EXAMINATION-检查
     */
    private String medicalCategory;

    /**
     * 本次费用总额
     */
    private double totalExpense;

    /**
     * 是否急诊
     */
    private boolean emergency;

    /**
     * 是否异地就医
     */
    private boolean offSite;

    /**
     * 异地就医是否已备案
     */
    private boolean filed;

    /**
     * 年度统筹基金已累计支付额
     */
    private double annualAccumulated;
}

ReimbursementDecision.java

package com.github.paohaijiao.demo.model;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

/**
 * 医保报销决策结果
 */
@Data
public class ReimbursementDecision {

    /**
     * 结算单号
     */
    private String claimNo;

    /**
     * 是否在医保目录内
     */
    private boolean withinCatalog;

    /**
     * 起付线金额
     */
    private double deductibleAmount;

    /**
     * 乙类先行自付金额
     */
    private double prepaidSelfPay;

    /**
     * 报销比例
     */
    private double reimburseRatio;

    /**
     * 统筹支付金额
     */
    private double payableAmount;

    /**
     * 个人自付金额
     */
    private double selfPayAmount;

    /**
     * 年度封顶线
     */
    private double annualCap;

    /**
     * 是否触及封顶线
     */
    private boolean capped;

    /**
     * 结算结论：APPROVE-即时结算 / MANUAL_REVIEW-人工审核 / SELF_PAY-全自费
     */
    private String result;

    /**
     * 是否需要人工审核
     */
    private boolean needManualReview;

    /**
     * 结算说明
     */
    private List<String> notes = new ArrayList<String>();

    public void addNote(String note) {
        this.notes.add(note);
    }
}

MedicalReimbursementRules.java

package com.github.paohaijiao.demo;

import com.github.paohaijiao.xml.param.Param;

/**
 * 场景 13：医保报销项目与比例合规校验规则集
 * <p>
 * 规则按「目录范围 → 起付线/比例 → 先行自付 → 封顶线 → 结算结论」拆分：
 * <ul>
 *     <li>政策类：目录判定、起付线、报销比例、乙类先行自付、年度封顶线</li>
 *     <li>决策类：结算结论、封顶截断、人工审核门槛、异地备案校验</li>
 * </ul>
 * 规则脚本见 {@code src/test/resources/demo/medical-reimbursement.xml}。
 */
public interface MedicalReimbursementRules {

    boolean withinCatalog(@Param("medicalCategory") String medicalCategory);

    double deductible(@Param("insuranceType") String insuranceType,
                      @Param("hospitalLevel") String hospitalLevel,
                      @Param("emergency") boolean emergency);

    double reimburseRatio(@Param("insuranceType") String insuranceType,
                          @Param("hospitalLevel") String hospitalLevel,
                          @Param("emergency") boolean emergency);

    double prepaidSelfPay(@Param("medicalCategory") String medicalCategory,
                          @Param("totalExpense") double totalExpense);

    double annualCap(@Param("insuranceType") String insuranceType);

    double applyCap(@Param("payableAmount") double payableAmount,
                    @Param("remainingCap") double remainingCap);

    String complianceResult(@Param("withinCatalog") boolean withinCatalog,
                            @Param("offSite") boolean offSite,
                            @Param("filed") boolean filed);

    boolean needManualReview(@Param("result") String result,
                             @Param("payableAmount") double payableAmount);
}

Run
Run at the project root: → 封顶线 → 结算结论」拆分： *
*
政策类：目录判定、起付线、报销比例、乙类先行自付、年度封顶线
*
决策类：结算结论、封顶截断、人工审核门槛、异地备案校验
*
* 规则脚本见 {@code src/test/resources/demo/medical-reimbursement.xml}。 */public interface MedicalReimbursementRules { boolean withinCatalog(@Param("medicalCategory") String medicalCategory); double deductible(@Param("insuranceType") String insuranceType, @Param("hospitalLevel") String hospitalLevel, @Param("emergency") boolean emergency); double reimburseRatio(@Param("insuranceType") String insuranceType, @Param("hospitalLevel") String hospitalLevel, @Param("emergency") boolean emergency); double prepaidSelfPay(@Param("medicalCategory") String medicalCategory, @Param("totalExpense") double totalExpense); double annualCap(@Param("insuranceType") String insuranceType); double applyCap(@Param("payableAmount") double payableAmount, @Param("remainingCap") double remainingCap); String complianceResult(@Param("withinCatalog") boolean withinCatalog, @Param("offSite") boolean offSite, @Param("filed") boolean filed); boolean needManualReview(@Param("result") String result, @Param("payableAmount") double payableAmount);}">

l">medical-reimbursement.xml

class="header">

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE javas PUBLIC "-//PAOHAIJIAO//DTD API JAVA 1.0//EN"
        "classpath:paohaijiao/dtd/Jquick-java.dtd">
<javas namespace="com.github.paohaijiao.demo.MedicalReimbursementRules">
 <!-- 医保目录判定：丙类全部自费 -->
    <java name="withinCatalog" returnClass="boolean">
        <![CDATA[
            boolean def withinCatalog(str:medicalCategory) {
                if (medicalCategory == "DRUG_C") {
                    return false;
                } else {
                    return true;
                }
            }
        ]]>
    </java>
 <!-- 起付线：参保类型 × 医院等级，急诊减半执行 -->
    <java name="deductible" returnClass="double">
        <![CDATA[
            double def deductible(str:insuranceType, str:hospitalLevel, boolean:emergency) {
                if (insuranceType == "EMPLOYEE") {
                    if (emergency) {
                        if (hospitalLevel == "THIRD_A") {
                            return 400.0;
                        } else if (hospitalLevel == "SECOND_A") {
                            return 250.0;
                        } else {
                            return 100.0;
                        }
                    } else {
                        if (hospitalLevel == "THIRD_A") {
                            return 800.0;
                        } else if (hospitalLevel == "SECOND_A") {
                            return 500.0;
                        } else {
                            return 200.0;
                        }
                    }
                } else {
                    if (emergency) {
                        if (hospitalLevel == "THIRD_A") {
                            return 300.0;
                        } else if (hospitalLevel == "SECOND_A") {
                            return 150.0;
                        } else {
                            return 50.0;
                        }
                    } else {
                        if (hospitalLevel == "THIRD_A") {
                            return 600.0;
                        } else if (hospitalLevel == "SECOND_A") {
                            return 300.0;
                        } else {
                            return 100.0;
                        }
                    }
                }
            }
        ]]>
    </java>
 <!-- 报销比例：参保类型 × 医院等级，急诊上浮 5 个百分点，上限 100% -->
    <java name="reimburseRatio" returnClass="double">
        <![CDATA[
            double def reimburseRatio(str:insuranceType, str:hospitalLevel, boolean:emergency) {
                double ratio = 0.6;
                if (insuranceType == "EMPLOYEE") {
                    if (hospitalLevel == "THIRD_A") {
                        ratio = 0.9;
                    } else if (hospitalLevel == "SECOND_A") {
                        ratio = 0.85;
                    } else {
                        ratio = 0.8;
                    }
                } else {
                    if (hospitalLevel == "THIRD_A") {
                        ratio = 0.7;
                    } else if (hospitalLevel == "SECOND_A") {
                        ratio = 0.65;
                    } else {
                        ratio = 0.6;
                    }
                }
                if (emergency) {
                    ratio = ratio + 0.05;
                }
                if (ratio > 1.0) {
                    ratio = 1.0;
                }
                return ratio;
            }
        ]]>
    </java>
 <!-- 乙类药品先行自付 10%，其余类别无先行自付 -->
    <java name="prepaidSelfPay" returnClass="double">
        <![CDATA[
            double def prepaidSelfPay(str:medicalCategory, double:totalExpense) {
                if (medicalCategory == "DRUG_B") {
                    return totalExpense * 0.1;
                } else {
                    return 0.0;
                }
            }
        ]]>
    </java>
 <!-- 年度统筹基金封顶线 -->
    <java name="annualCap" returnClass="double">
        <![CDATA[
            double def annualCap(str:insuranceType) {
                if (insuranceType == "EMPLOYEE") {
                    return 300000.0;
                } else {
                    return 200000.0;
                }
            }
        ]]>
    </java>
 <!-- 封顶截断：支付额不得超过年度剩余额度 -->
    <java name="applyCap" returnClass="double">
        <![CDATA[
            double def applyCap(double:payableAmount, double:remainingCap) {
                if (remainingCap <= 0.0) {
                    return 0.0;
                } else if (payableAmount > remainingCap) {
                    return remainingCap;
                } else {
                    return payableAmount;
                }
            }
        ]]>
    </java>
 <!-- 结算结论：目录外全自费，异地未备案转人工，其余即时结算 -->
    <java name="complianceResult" returnClass="java.lang.String">
        <![CDATA[
            str def complianceResult(boolean:withinCatalog, boolean:offSite, boolean:filed) {
                if (withinCatalog == false) {
                    return "SELF_PAY";
                } else if (offSite && filed == false) {
                    return "MANUAL_REVIEW";
                } else {
                    return "APPROVE";
                }
            }
        ]]>
    </java>
 <!-- 人工审核：异地未备案或单笔统筹支付达到 5 万 -->
    <java name="needManualReview" returnClass="boolean">
        <![CDATA[
            boolean def needManualReview(str:result, double:payableAmount) {
                if (result == "MANUAL_REVIEW") {
                    return true;
                } else if (result == "APPROVE" && payableAmount >= 50000.0) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 style="--0:#7FDBCA"></javas>

vicejava">MedicalReimbursementService.java