Case 6: Performance grade & bonus coefficient

This case corresponds to Scenario 6: Performance grade & bonus coefficient in the JQuick-Java repository’s USE-CASES.md. It belongs to the human resources domain and solves the integrated decision chain inside an appraisal cycle: “four-dimension weighted scoring → S/A/B/C/D grade mapping → bonus coefficient adjustment → bonus amount / promotion eligibility / PIP determination”.

Industry scenario

In an annual or quarterly performance appraisal cycle, HR first aggregates four kinds of employee scores: KPI score, project score, teamwork score, and attendance score (all 0-100), weighted into a composite score with fixed weights of KPI 50%, project 20%, teamwork 15%, and attendance 15%.

The composite score maps to five performance grades S/A/B/C/D, each with a base bonus coefficient: S is 1.8, A is 1.4, B is 1.1, C is 0.8, D is 0.5. On top of the base coefficient, three adjustments are stacked: a manager responsibility bonus of +0.2, a sales incentive (grade S/A with annual sales reaching 500k adds 0.2; sales reaching 200k adds 0.1), and a violation deduction of -0.3. The final coefficient multiplied by the monthly base salary yields the bonus amount.

The same decision chain also produces in parallel: promotion eligibility (total score no less than 85 and no violation record), whether the employee is forced into a PIP performance improvement plan, the attendance tier (scores 95/90/80 map to tiers 3/2/1/0), and an employee-facing remark list (excellence pool entry, violation deduction explanation, attendance warning, sales incentive explanation, etc.).

These outputs directly drive bonus payout, annual promotion pool screening, and PIP follow-up. Scenario 6 covers 6 real employee profiles: excellent sales (composite 92.65, grade S, coefficient 2.0), low performer with violation (51.25, grade D, coefficient 0.2), manager grade A (coefficient 1.7), average grade B (coefficient 1.2), underperformer grade D (coefficient 0.5), and an excellent employee whose promotion is blocked by a violation.

Business pain points

Appraisal weights 50%/20%/15%/15%, S/A/B/C/D score lines, and base coefficients 1.8/1.4/1.1/0.8/0.5 are scattered across the payroll module, Excel templates, and hard-coded logic; every annual policy change requires coordinating multiple redeployments.
Manager bonus, sales incentive (two tiers at 500k/200k), and violation deduction are entangled in the same if-else block; changing one tier easily misses linked logic.
Promotion eligibility (“total score 85 and no violation”) and the PIP entry are coupled with bonus calculation in business code, so HR cannot tune parameters or run simulations independently.
Stacked coefficients can theoretically go negative, and each system lacks a unified floor guard; decimal conventions for amounts (two digits, half-up rounding) are also inconsistent.
Decisions often return only a bonus number; when employees challenge the result, it is hard to trace the composite score, grade, and every bonus or deduction.
Many eHR and payroll systems still run on JDK 8 or domestic IT-innovation environments, making it hard to introduce heavy rule platforms such as Drools.

Solution architecture

This case uses the standard “six-piece set”: the input model and decision result model carry the data, the rule interface declares the calculation policies, the XML script externalizes all thresholds and coefficients, the Service handles aggregation and floor protection, and JUnit regresses all decision paths with 6 employee profiles.

Layer	Responsibility	Files
Domain model	Performance appraisal snapshot, bonus decision result	PerformanceRecord.java, BonusDecision.java
Rule set & XML	10 rule methods covering weighting, grading, coefficient, three adjustments, promotion, and PIP	PerformanceRules.java, performance.xml
Orchestration service	Coefficient aggregation with floor protection, two-decimal amounts, promotion line review, remark assembly	PerformanceService.java
Tests	6 employee profiles (excellent / low performer with violation / manager / average / underperformer / excellent with violation)	PerformanceServiceTest.java

Rule method breakdown

Rule method	Policy	Score/output
`weightedScore`	KPI×50% + project×20% + teamwork×15% + attendance×15%	0-100 composite score
`grade`	≥90 S / ≥80 A / ≥70 B / ≥60 C / otherwise D	S/A/B/C/D
`baseCoefficient`	S 1.8 / A 1.4 / B 1.1 / C 0.8 / D 0.5	Base coefficient
`managerBonus`	Manager +0.2, otherwise 0	+0.2 / 0
`salesBonus`	S/A with sales ≥500k +0.2; sales ≥200k +0.1; otherwise 0	+0.2 / +0.1 / 0
`violationPenalty`	Violation -0.3, otherwise 0	-0.3 / 0
`promotionEligible`	Eligible only when total score ≥85 and no violation (violation veto first)	true / false
`needPip`	Total score below 60, or below 70 with violation → enter PIP	true / false
`attendanceLevel`	Attendance ≥95 → 3 / ≥90 → 2 / ≥80 → 1 / otherwise 0	Tier 0-3
`bonusAmount`	Monthly base salary × final bonus coefficient	Bonus amount (CNY)

Code implementation (complete & runnable)

Place the six files into a Maven project following the repository’s original package structure: the two models go into src/test/java/com/github/paohaijiao/demo/model/, the rule interface, orchestration service, and test go into the com.github.paohaijiao.demo and com.github.paohaijiao.demo.service packages, and the XML script goes into src/test/resources/demo/performance.xml; keep all package names exactly as in the source. Run mvn test -Dtest=PerformanceServiceTest at the project root to execute.

PerformanceRecord.java

package com.github.paohaijiao.demo.model;

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

/**
 * 绩效考核记录（绩效与奖金核算所需的考核快照）
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class PerformanceRecord {

    /**
     * 工号
     */
    private String employeeId;

    /**
     * 姓名
     */
    private String employeeName;

    /**
     * 部门
     */
    private String dept;

    /**
     * KPI 得分（0-100）
     */
    private double kpiScore;

    /**
     * 项目得分（0-100）
     */
    private double projectScore;

    /**
     * 团队协作风得分（0-100）
     */
    private double teamScore;

    /**
     * 考勤得分（0-100）
     */
    private double attendanceScore;

    /**
     * 是否管理者
     */
    private boolean manager;

    /**
     * 是否发生违规
     */
    private boolean hasViolation;

    /**
     * 年度销售额（元）
     */
    private double salesAmount;

    /**
     * 月度基本工资（元）
     */
    private double baseSalary;
}

BonusDecision.java

package com.github.paohaijiao.demo.model;

import lombok.Data;

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

/**
 * 绩效奖金决策结果
 */
@Data
public class BonusDecision {

    /**
     * 工号
     */
    private String employeeId;

    /**
     * 加权总分（0-100）
     */
    private double totalScore;

    /**
     * 绩效等级：S / A / B / C / D
     */
    private String grade;

    /**
     * 最终奖金系数
     */
    private double bonusCoefficient;

    /**
     * 奖金金额（元）
     */
    private double bonusAmount;

    /**
     * 考勤等级：0-3
     */
    private int attendanceLevel;

    /**
     * 是否具备晋升资格
     */
    private boolean promotionEligible;

    /**
     * 是否进入绩效改进计划
     */
    private boolean needPip;

    /**
     * 说明与建议
     */
    private List<String> remarks = new ArrayList<String>();

    public void addRemark(String remark) {
        this.remarks.add(remark);
    }
}

PerformanceRules.java

package com.github.paohaijiao.demo;

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

/**
 * 场景 6（生产级样板）：绩效等级与奖金系数规则集
 * <p>
 * 规则按「加权评分 → 等级映射 → 系数修正 → 奖金核算」拆分：
 * <ul>
 *     <li>评分类：KPI / 项目 / 协作 / 考勤四维加权</li>
 *     <li>修正类：管理者加成、销售激励、违规扣减</li>
 *     <li>决策类：晋升资格、绩效改进、奖金金额</li>
 * </ul>
 * 规则脚本见 {@code src/test/resources/demo/performance.xml}。
 */
public interface PerformanceRules {

    /**
     * 加权总分：KPI 50% + 项目 20% + 协作 15% + 考勤 15%
     */
    double weightedScore(@Param("kpiScore") double kpiScore,
                         @Param("projectScore") double projectScore,
                         @Param("teamScore") double teamScore,
                         @Param("attendanceScore") double attendanceScore);

    /**
     * 绩效等级：S / A / B / C / D
     */
    String grade(@Param("totalScore") double totalScore);

    /**
     * 等级基准奖金系数
     */
    double baseCoefficient(@Param("grade") String grade);

    /**
     * 管理者加成
     */
    double managerBonus(@Param("manager") boolean manager);

    /**
     * 销售激励：高等级高销售额额外加成
     */
    double salesBonus(@Param("salesAmount") double salesAmount,
                      @Param("grade") String grade);

    /**
     * 违规扣减
     */
    double violationPenalty(@Param("hasViolation") boolean hasViolation);

    /**
     * 是否具备晋升资格
     */
    boolean promotionEligible(@Param("totalScore") double totalScore,
                              @Param("hasViolation") boolean hasViolation);

    /**
     * 是否进入绩效改进计划
     */
    boolean needPip(@Param("totalScore") double totalScore,
                    @Param("hasViolation") boolean hasViolation);

    /**
     * 考勤等级：>=95 为 3，>=90 为 2，>=80 为 1，否则 0
     */
    int attendanceLevel(@Param("attendanceScore") double attendanceScore);

    /**
     * 奖金金额 = 基本工资 × 最终系数
     */
    double bonusAmount(@Param("baseSalary") double baseSalary,
                       @Param("bonusCoefficient") double bonusCoefficient);
}

ance.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.PerformanceRules">
 <!-- 加权总分 -->
    <java name="weightedScore" returnClass="double">
        <![CDATA[
            double def weightedScore(double:kpiScore, double:projectScore, double:teamScore, double:attendanceScore) {
                double total = kpiScore * 0.5 + projectScore * 0.2 + teamScore * 0.15 + attendanceScore * 0.15;
                return total;
            }
        ]]>
    </java>
 <!-- 绩效等级 -->
    <java name="grade" returnClass="java.lang.String">
        <![CDATA[
            str def grade(double:totalScore) {
                if (totalScore >= 90.0) {
                    return "S";
                } else if (totalScore >= 80.0) {
                    return "A";
                } else if (totalScore >= 70.0) {
                    return "B";
                } else if (totalScore >= 60.0) {
                    return "C";
                } else {
                    return "D";
                }
            }
        ]]>
    </java>
 <!-- 等级基准系数 -->
    <java name="baseCoefficient" returnClass="double">
        <![CDATA[
            double def baseCoefficient(str:grade) {
                if (grade == "S") {
                    return 1.8;
                } else if (grade == "A") {
                    return 1.4;
                } else if (grade == "B") {
                    return 1.1;
                } else if (grade == "C") {
                    return 0.8;
                } else {
                    return 0.5;
                }
            }
        ]]>
    </java>
 <!-- 管理者加成 -->
    <java name="managerBonus" returnClass="double">
        <![CDATA[
            double def managerBonus(boolean:manager) {
                if (manager) {
                    return 0.2;
                } else {
                    return 0.0;
                }
            }
        ]]>
    </java>
 <!-- 销售激励 -->
    <java name="salesBonus" returnClass="double">
        <![CDATA[
            double def salesBonus(double:salesAmount, str:grade) {
                if ((grade == "S" || grade == "A") && salesAmount >= 500000.0) {
                    return 0.2;
                } else if (salesAmount >= 200000.0) {
                    return 0.1;
                } else {
                    return 0.0;
                }
            }
        ]]>
    </java>
 <!-- 违规扣减 -->
    <java name="violationPenalty" returnClass="double">
        <![CDATA[
            double def violationPenalty(boolean:hasViolation) {
                if (hasViolation) {
                    return -0.3;
                } else {
                    return 0.0;
                }
            }
        ]]>
    </java>
 <!-- 晋升资格 -->
    <java name="promotionEligible" returnClass="boolean">
        <![CDATA[
            boolean def promotionEligible(double:totalScore, boolean:hasViolation) {
                if (hasViolation) {
                    return false;
                } else if (totalScore >= 85.0) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 绩效改进 -->
    <java name="needPip" returnClass="boolean">
        <![CDATA[
            boolean def needPip(double:totalScore, boolean:hasViolation) {
                if (totalScore < 60.0) {
                    return true;
                } else if (totalScore < 70.0 && hasViolation) {
                    return true;
                } else {
                    return false;
                }
            }
        ]]>
    </java>
 <!-- 考勤等级 -->
    <java name="attendanceLevel" returnClass="int">
        <![CDATA[
            int def attendanceLevel(double:attendanceScore) {
                if (attendanceScore >= 95.0) {
                    return 3;
                } else if (attendanceScore >= 90.0) {
                    return 2;
                } else if (attendanceScore >= 80.0) {
                    return 1;
                } else {
                    return 0;
                }
            }
        ]]>
    </java>
 <!-- 奖金金额 -->
    <java name="bonusAmount" returnClass="double">
        <![CDATA[
            double def bonusAmount(double:baseSalary, double:bonusCoefficient) {
                return baseSalary * bonusCoefficient;
            }
        ]]>
    </java>
 style="--0:#7FDBCA"></javas>

>PerformanceService.java