소스 검색

feat(cf): T1+T2+T3 打卡 CF 按会员等级配置(等级金额通道)

T1 后端核心:computeAmount 支持 params_json.levels[levelCode] 等级金额通道
- CfBalanceServiceImpl.earnByRule 提前解析 levelCode 并传入 computeAmount
- 新增 resolveLevelAmount:命中 levels[levelCode] 且 >0 则覆盖 base;
  当前等级未配置回退 levels.NONE;无有效值回落 rule.amount(老规则行为不变)
- 覆盖发生在 resolveMultiplier 之前(等级金额再乘倍数)

T2 管理端:CfRuleConfig.vue 新增「按会员等级配置单次 CF 值」矩阵
- 仅 ruleType=fixed 时显示;等级来源 /api/admin/membership/levels,兜底 NONE/FAMILY/PREMIUM 枚举
- 编辑时回显 paramsJson.levels;保存时序列化回 levels 且保留 paramsJson 其它键
  (如 daily_limit_by_tier);保存前校验参数 JSON 合法性
- api/cfRule.js 新增 getAdminMembershipLevels()

T3 种子/迁移:为打卡类规则补 levels 默认值(迁移437,幂等)
- F14/F15: NONE2/FAMILY4/PREMIUM10;F16: NONE5/FAMILY10/PREMIUM25;F05/F07/F08: NONE1/FAMILY2/PREMIUM5
- params_json 为 TEXT 且 MySQL 5.7 无 JSON_MERGEREPLACE,改用 Java 读-合并-写(仅补缺失键,
  保留其它键,不覆盖运营已改值,非法 JSON 跳过不覆盖)
- CF_EARN_RULE_SEEDS 同步带 levels,新建库 seed 即含默认矩阵

测试:新增 CfBalanceServiceImplLevelAmountTest(9 例)、DatabaseInitializerLevelMergeTest(7 例)
Sisyphus 2 주 전
부모
커밋
6e40e97319

+ 127 - 12
cfc-backend/src/main/java/com/etotem/cfc/config/DatabaseInitializer.java

@@ -4,6 +4,7 @@ import com.etotem.cfc.mapper.*;
 import com.etotem.cfc.service.CfLegacyLedgerMigrationService;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 
 import javax.annotation.Resource;
 import org.slf4j.Logger;
@@ -24,6 +25,7 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.regex.Pattern;
@@ -3403,6 +3405,12 @@ insertSysConfigSeed("gift_membership_pay_price", "198000", "送会员商品达
 
         // 迁移436: products 表添加营养数据字段(热量/蛋白质/脂肪/碳水/膳食纤维/营养标签)
         migrateProductNutritionFields();
+
+        // 迁移437: 为打卡类规则补 levels 等级金额默认值(T3,幂等读-合并-写)
+        // 背景:T1 引入 computeAmount 等级金额通道 params_json.levels[levelCode];为存量规则补默认矩阵。
+        // 实现:params_json 为 TEXT(MySQL 5.7 无 JSON_MERGEREPLACE),用 Java 读-合并-写,
+        //       仅在 levels 缺失对应键时补默认值,保留其他键(如 daily_limit_by_tier),幂等可重入。
+        migrateCfEarnRuleLevelDefaults();
     }
 
     /**
@@ -3538,6 +3546,113 @@ insertSysConfigSeed("gift_membership_pay_price", "198000", "送会员商品达
         }
     }
 
+    /**
+     * 迁移437: 为打卡类规则补 levels 等级金额默认值(T3)。
+     *
+     * <p>等级矩阵(廖总拍板:家庭=非会员×2、超级=非会员×5):
+     * F14/F15 基准 2 → 家庭 4 / 超级 10;F16 基准 5 → 家庭 10 / 超级 25;
+     * F05/F07/F08 基准 1 → 家庭 2 / 超级 5。</p>
+     *
+     * <p>params_json 为 TEXT(MySQL 5.7 无 JSON_MERGEREPLACE),采用 Java 侧读-合并-写:
+     * 仅在 {@code levels} 缺失对应键时补默认值,保留其它键(如 daily_limit_by_tier),
+     * 幂等可重入(再次执行不产生变更)。</p>
+     */
+    private void migrateCfEarnRuleLevelDefaults() {
+        if (!tableExists("cf_earn_rule")) {
+            log.warn("迁移437: cf_earn_rule 表不存在,跳过 levels 默认值迁移");
+            return;
+        }
+        Map<String, Map<String, Integer>> defaults = new LinkedHashMap<>();
+        defaults.put("F14", levelMap(2, 4, 10));
+        defaults.put("F15", levelMap(2, 4, 10));
+        defaults.put("F16", levelMap(5, 10, 25));
+        defaults.put("F05", levelMap(1, 2, 5));
+        defaults.put("F07", levelMap(1, 2, 5));
+        defaults.put("F08", levelMap(1, 2, 5));
+
+        ObjectMapper mapper = new ObjectMapper();
+        int updated = 0;
+        for (Map.Entry<String, Map<String, Integer>> entry : defaults.entrySet()) {
+            String code = entry.getKey();
+            Map<String, Integer> levels = entry.getValue();
+            try {
+                List<Map<String, Object>> rows = jdbcTemplate.queryForList(
+                        "SELECT id, params_json FROM cf_earn_rule WHERE code = ?", code);
+                for (Map<String, Object> row : rows) {
+                    Object id = row.get("id");
+                    Object raw = row.get("params_json");
+                    String paramsJson = raw == null ? null : String.valueOf(raw);
+                    String merged = mergeLevels(mapper, paramsJson, levels);
+                    if (merged == null) {
+                        continue;
+                    }
+                    if (!merged.equals(paramsJson == null ? "" : paramsJson)) {
+                        jdbcTemplate.update(
+                                "UPDATE cf_earn_rule SET params_json = ?, updated_at = NOW() WHERE id = ?",
+                                merged, id);
+                        updated++;
+                    }
+                }
+            } catch (Exception e) {
+                log.warn("迁移437: 规则 {} levels 默认值迁移失败: {}", code, e.getMessage());
+            }
+        }
+        if (updated > 0) {
+            log.info("迁移437: cf_earn_rule 补 levels 等级金额默认值,更新 {} 行", updated);
+        } else {
+            log.info("迁移437: cf_earn_rule 已含 levels 默认值或无需更新");
+        }
+    }
+
+    /** NONE / FAMILY / PREMIUM 三档等级矩阵 */
+    private static Map<String, Integer> levelMap(int none, int family, int premium) {
+        Map<String, Integer> m = new LinkedHashMap<>();
+        m.put("NONE", none);
+        m.put("FAMILY", family);
+        m.put("PREMIUM", premium);
+        return m;
+    }
+
+    /**
+     * 幂等合并 levels 到 params_json:仅当 {@code levels} 缺失对应键时补默认值,保留其它键。
+     * params_json 为空/null 时新建对象再补;无法解析或非 JSON 对象(避免覆盖丢失原内容)
+     * 返回 null,调用方跳过该行,不产生写入(幂等)。
+     *
+     * @return 合并后的 JSON 字符串;合并失败返回 null,调用方跳过该行
+     */
+    private String mergeLevels(ObjectMapper mapper, String paramsJson, Map<String, Integer> levels) {
+        try {
+            JsonNode root;
+            if (paramsJson == null || paramsJson.trim().isEmpty()) {
+                root = mapper.createObjectNode();
+            } else {
+                JsonNode parsed = mapper.readTree(paramsJson);
+                if (parsed == null || !parsed.isObject()) {
+                    log.warn("迁移437: params_json 非 JSON 对象,跳过不覆盖: {}", paramsJson);
+                    return null;
+                }
+                root = parsed;
+            }
+            JsonNode levelsNode = root.get("levels");
+            ObjectNode levelsObj;
+            if (levelsNode != null && levelsNode.isObject()) {
+                levelsObj = (ObjectNode) levelsNode;
+            } else {
+                levelsObj = mapper.createObjectNode();
+                ((ObjectNode) root).set("levels", levelsObj);
+            }
+            for (Map.Entry<String, Integer> lv : levels.entrySet()) {
+                if (!levelsObj.has(lv.getKey())) {
+                    levelsObj.put(lv.getKey(), lv.getValue());
+                }
+            }
+            return mapper.writeValueAsString(root);
+        } catch (Exception e) {
+            log.warn("迁移437: levels 合并失败 params_json={}: {}", paramsJson, e.getMessage());
+            return null;
+        }
+    }
+
     private void migrateHealthDimensionsTable() {
         try {
             if (tableExists("health_dimension_score")) {
@@ -13601,9 +13716,9 @@ log.info("迁移298: 已为无 openid 的 child 账号补齐 family_members 记
                     "赠品规则管理端配置"},
             {"F05", "活动签到CF", "consume", "per_item", "",
                     "",
-                    "{\"source\":\"activities.platform_points\"}",
+                    "{\"source\":\"activities.platform_points\",\"levels\":{\"NONE\":1,\"FAMILY\":2,\"PREMIUM\":5}}",
                     "", "", "", "activity_checkin", "50",
-                    "活动配置数量"},
+                    "活动配置数量;等级金额通道:非会员1/家庭2/超级5"},
             {"F06", "菌群健康调研打卡返还", "consume", "formula", "",
                     "floor(amt)",
                     "{\"cf_per_yuan\":100,\"amt_unit\":\"cent\",\"fallback\":\"gut_health_project.cf_refund_amount\",\"example\":\"19.9元=1990CF\"}",
@@ -13611,14 +13726,14 @@ log.info("迁移298: 已为无 openid 的 child 账号补齐 family_members 记
                     "cf_refund_amount 为空时按项目价×100(19.9元=1990CF,§九修正值);一周项目只发一次"},
             {"F07", "文章答题奖励", "behavior", "formula", "",
                     "score + (all_correct ? 3 : 0)",
-                    "{\"bonus_all_correct\":3,\"dedup\":\"article\"}",
+                    "{\"bonus_all_correct\":3,\"dedup\":\"article\",\"levels\":{\"NONE\":1,\"FAMILY\":2,\"PREMIUM\":5}}",
                     "5", "", "", "article_answer", "70",
-                    "答对题数+全对3;日限5次(N9)"},
+                    "答对题数+全对3;日限5次(N9);等级金额通道:非会员1/家庭2/超级5"},
             {"F08", "AI阅读答题奖励", "behavior", "fixed", "5",
                     "",
-                    "{\"require_all_correct\":true}",
+                    "{\"require_all_correct\":true,\"levels\":{\"NONE\":1,\"FAMILY\":2,\"PREMIUM\":5}}",
                     "3", "", "", "ai_reading_answer", "80",
-                    "仅全部答对才发(原硬编码已外置)"},
+                    "仅全部答对才发(原硬编码已外置);等级金额通道:非会员1/家庭2/超级5"},
             {"F09", "完成测评建档", "behavior", "formula", "",
                     "first_report ? 50 : 10",
                     "{\"first_amount\":50,\"repeat_amount\":10,\"dedup_key\":\"report_hash\"}",
@@ -13646,19 +13761,19 @@ log.info("迁移298: 已为无 openid 的 child 账号补齐 family_members 记
                     "默认5CF;日限5次"},
             {"F14", "喝水打卡", "behavior", "fixed", "5",
                     "",
-                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}",
+                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\",\"levels\":{\"NONE\":2,\"FAMILY\":4,\"PREMIUM\":10}}",
                     "", "", "", "health_water", "140",
-                    "5CF/次;日限按会员等级(N11)"},
+                    "5CF/次;日限按会员等级(N11);等级金额通道:非会员2/家庭4/超级10"},
             {"F15", "饮食打卡", "behavior", "fixed", "5",
                     "",
-                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}",
+                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\",\"levels\":{\"NONE\":2,\"FAMILY\":4,\"PREMIUM\":10}}",
                     "", "", "", "health_meal", "150",
-                    "5CF/次;日限按会员等级(N11)"},
+                    "5CF/次;日限按会员等级(N11);等级金额通道:非会员2/家庭4/超级10"},
             {"F16", "每日健康打卡", "behavior", "fixed", "10",
                     "",
-                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}",
+                    "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\",\"levels\":{\"NONE\":5,\"FAMILY\":10,\"PREMIUM\":25}}",
                     "", "", "", "daily_health_checkin", "160",
-                    "10CF/次;日限按会员等级(N11)"},
+                    "10CF/次;日限按会员等级(N11);等级金额通道:非会员5/家庭10/超级25(F16基准5)"},
             {"F17", "挑战赛子任务完成", "behavior", "per_item", "",
                     "",
                     "{\"source\":\"challenge_task.reward_cf\"}",

+ 42 - 5
cfc-backend/src/main/java/com/etotem/cfc/service/impl/CfBalanceServiceImpl.java

@@ -342,15 +342,14 @@ public class CfBalanceServiceImpl implements CfBalanceService {
         }
 
         Map<String, Object> params = parseParams(rule.getParamsJson());
-        int amount = computeAmount(rule, params, ctx);
+        String levelCode = resolveLevelCode(memberId);
+        int amount = computeAmount(rule, params, ctx, levelCode);
         if (amount <= 0) {
             result.setReason("规则计算数量非正:" + result.getRuleCode());
             log.warn("CF 发放跳过:memberId={}, rule={} 计算数量 {}", memberId, rule.getCode(), amount);
             return result;
         }
         result.setAmount(amount);
-
-        String levelCode = resolveLevelCode(memberId);
         result.setLevelCode(levelCode);
 
         // 三道闸:会员等级日限 / 累计上限 / 冷却期(命中即跳过并写 skip 流水)
@@ -413,9 +412,11 @@ public class CfBalanceServiceImpl implements CfBalanceService {
 
     /**
      * 按规则计算发放数量:fixed 取 amount;formula 用白名单求值器;per_item 取 ctx 提供的数量。
-     * 倍数(params.multiplier_key 或 params.multiplier)在基础数量上放大,最终向下取整。
+     * 等级金额通道(params.levels[levelCode])优先于规则默认数量;倍数(params.multiplier_key 或
+     * params.multiplier)在最终数量上放大,最终向下取整。
      */
-    private int computeAmount(CfEarnRule rule, Map<String, Object> params, Map<String, Object> ctx) {
+    private int computeAmount(CfEarnRule rule, Map<String, Object> params, Map<String, Object> ctx,
+                              String levelCode) {
         String ruleType = rule.getRuleType() == null ? "" : rule.getRuleType().trim().toLowerCase();
         double base;
         switch (ruleType) {
@@ -434,6 +435,11 @@ public class CfBalanceServiceImpl implements CfBalanceService {
             default:
                 throw new IllegalArgumentException("未知的规则类型:" + rule.getRuleType() + "(规则 " + rule.getCode() + ")");
         }
+        // 等级金额通道:params_json.levels[levelCode] 优先,缺省回落 rule.amount
+        double levelAmount = resolveLevelAmount(rule, levelCode, params);
+        if (levelAmount > 0) {
+            base = levelAmount;
+        }
         base = base * resolveMultiplier(params);
         if (base > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("规则 " + rule.getCode() + " 计算数量溢出");
@@ -442,6 +448,37 @@ public class CfBalanceServiceImpl implements CfBalanceService {
         return (int) Math.floor(base + 1e-6);
     }
 
+    /**
+     * 等级金额通道:读取 params_json.levels 中当前会员等级(levelCode)对应的单次 CF 值。
+     * 规则:命中且 > 0 → 覆盖基础数量;当前等级未配置 → 回退 levels.NONE(覆盖免费/基础档位);
+     * 仍无有效值 → 返回 0,由调用方回落 rule.amount(未配置 levels 的老规则行为不变)。
+     */
+    private double resolveLevelAmount(CfEarnRule rule, String levelCode, Map<String, Object> params) {
+        if (params == null || levelCode == null) {
+            return 0;
+        }
+        Object levels = params.get("levels");
+        if (!(levels instanceof Map)) {
+            return 0;
+        }
+        Map<?, ?> levelsMap = (Map<?, ?>) levels;
+        Object val = levelsMap.get(levelCode);
+        if (val == null) {
+            val = levelsMap.get("NONE");
+        }
+        if (val == null) {
+            return 0;
+        }
+        try {
+            double amount = Double.parseDouble(String.valueOf(val).trim());
+            return amount > 0 ? amount : 0;
+        } catch (Exception e) {
+            log.warn("规则 {} 等级金额解析失败:levels[{}]={}", rule == null ? "" : rule.getCode(),
+                    levelCode, val);
+            return 0;
+        }
+    }
+
     private double evaluateFormula(CfEarnRule rule, Map<String, Object> params, Map<String, Object> ctx) {
         String formula = rule.getFormula();
         if (formula == null || formula.trim().isEmpty()) {

+ 98 - 0
cfc-backend/src/test/java/com/etotem/cfc/config/DatabaseInitializerLevelMergeTest.java

@@ -0,0 +1,98 @@
+package com.etotem.cfc.config;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * 迁移437(为打卡类规则补 levels 等级金额默认值)的合并逻辑单元测试:
+ *  - 仅在 levels 缺失对应键时补默认值,保留 params_json 其它键(如 daily_limit_by_tier);
+ *  - 幂等:重复合并结果一致(不会重复写、不会覆盖运营已改的等级值);
+ *  - params_json 为空 → 新建对象;非法 JSON / 非对象 → 返回 null(跳过,不覆盖原内容)。
+ */
+class DatabaseInitializerLevelMergeTest {
+
+    private DatabaseInitializer initializer;
+    private Method mergeLevels;
+    private ObjectMapper mapper;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        initializer = new DatabaseInitializer();
+        mapper = new ObjectMapper();
+        mergeLevels = DatabaseInitializer.class.getDeclaredMethod(
+                "mergeLevels", ObjectMapper.class, String.class, Map.class);
+        mergeLevels.setAccessible(true);
+    }
+
+    private Map<String, Integer> defaults() {
+        Map<String, Integer> m = new LinkedHashMap<>();
+        m.put("NONE", 2);
+        m.put("FAMILY", 4);
+        m.put("PREMIUM", 10);
+        return m;
+    }
+
+    private String merge(String paramsJson, Map<String, Integer> levels) throws Exception {
+        return (String) mergeLevels.invoke(initializer, mapper, paramsJson, levels);
+    }
+
+    @Test
+    void 补levels且保留其它键() throws Exception {
+        String r = merge("{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}", defaults());
+        assertTrue(r.contains("daily_limit_by_tier"), r);
+        assertTrue(r.contains("\"levels\""), r);
+        assertTrue(r.contains("\"NONE\":2") && r.contains("\"FAMILY\":4") && r.contains("\"PREMIUM\":10"), r);
+    }
+
+    @Test
+    void 幂等_重复合并结果一致() throws Exception {
+        String once = merge("{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}", defaults());
+        String twice = merge(once, defaults());
+        assertEquals(once, twice);
+    }
+
+    @Test
+    void 不覆盖运营已改的等级值() throws Exception {
+        String r = merge("{\"levels\":{\"FAMILY\":99}}", defaults());
+        assertTrue(r.contains("\"FAMILY\":99"), r);
+        // 缺失的键仍补默认值
+        assertTrue(r.contains("\"NONE\":2") && r.contains("\"PREMIUM\":10"), r);
+    }
+
+    @Test
+    void paramsJson为空时新建对象() throws Exception {
+        String r = merge(null, defaults());
+        assertTrue(r.contains("\"levels\""), r);
+        assertTrue(r.contains("\"NONE\":2"), r);
+    }
+
+    @Test
+    void 非法JSON返回null_不覆盖原内容() throws Exception {
+        assertNull(merge("not-a-json", defaults()));
+    }
+
+    @Test
+    void 非对象JSON返回null_不覆盖原内容() throws Exception {
+        assertNull(merge("[1,2,3]", defaults()));
+        assertNull(merge("\"abc\"", defaults()));
+    }
+
+    @Test
+    void 其它键原样保留() throws Exception {
+        String r = merge("{\"source\":\"activities.platform_points\",\"dedup\":\"article\"}", defaults());
+        assertTrue(r.contains("\"source\":\"activities.platform_points\""), r);
+        assertTrue(r.contains("\"dedup\":\"article\""), r);
+        assertTrue(r.contains("\"levels\""), r);
+        // 原有键在 levels 之前(未被打乱或覆盖)
+        assertTrue(r.indexOf("source") < r.indexOf("levels"), r);
+    }
+}

+ 209 - 0
cfc-backend/src/test/java/com/etotem/cfc/service/CfBalanceServiceImplLevelAmountTest.java

@@ -0,0 +1,209 @@
+package com.etotem.cfc.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.etotem.cfc.config.ConfigService;
+import com.etotem.cfc.dto.CfEarnResult;
+import com.etotem.cfc.dto.MembershipLevelDTO;
+import com.etotem.cfc.entity.CfBalance;
+import com.etotem.cfc.entity.CfBalanceLog;
+import com.etotem.cfc.entity.CfEarnDailyLimit;
+import com.etotem.cfc.entity.CfEarnRule;
+import com.etotem.cfc.entity.FamilyMember;
+import com.etotem.cfc.mapper.CfBalanceLogMapper;
+import com.etotem.cfc.mapper.CfBalanceMapper;
+import com.etotem.cfc.mapper.CfEarnDailyLimitMapper;
+import com.etotem.cfc.mapper.FamilyMemberMapper;
+import com.etotem.cfc.service.impl.CfBalanceServiceImpl;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+/**
+ * T1 等级金额通道(params_json.levels[levelCode])单元测试:
+ *  - levels[当前等级] 命中且 > 0 → 覆盖规则默认数量(rule.amount);
+ *  - 当前等级未配置 → 回退 levels.NONE(覆盖免费/基础档位);
+ *  - levels 缺失 / 非 Map / 当前等级与 NONE 都未配置 / params 为 null → 回落 rule.amount;
+ *  - 等级金额在倍数放大之前生效(base=levelAmount,再乘 multiplier)。
+ *
+ * 通过 {@link CfBalanceServiceImpl#earnByRule} 走真实 {@code computeAmount} 路径验证。
+ */
+class CfBalanceServiceImplLevelAmountTest {
+
+    @Mock
+    private CfBalanceMapper cfBalanceMapper;
+    @Mock
+    private CfBalanceLogMapper cfBalanceLogMapper;
+    @Mock
+    private CfEarnDailyLimitMapper cfEarnDailyLimitMapper;
+    @Mock
+    private CfEarnRuleService cfEarnRuleService;
+    @Mock
+    private FamilyMemberMapper familyMemberMapper;
+    @Mock
+    private MembershipService membershipService;
+    @Mock
+    private ConfigService configService;
+    @Mock
+    private NotificationDispatchService notificationDispatchService;
+    @Spy
+    private ObjectMapper objectMapper = new ObjectMapper();
+
+    @InjectMocks
+    private CfBalanceServiceImpl cfBalanceService;
+
+    private CfBalance balance;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), CfBalance.class);
+        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), CfBalanceLog.class);
+        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), CfEarnDailyLimit.class);
+        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), FamilyMember.class);
+
+        balance = new CfBalance();
+        balance.setId(1L);
+        balance.setMemberId(1L);
+        balance.setUserId(3L);
+        balance.setFamilyId(7L);
+        balance.setAvailable(100);
+        balance.setFrozen(0);
+        balance.setTotalEarned(100);
+        balance.setWithdrawn(0);
+        balance.setExchanged(0);
+
+        when(cfBalanceMapper.selectForUpdate(1L)).thenReturn(balance);
+        when(cfBalanceMapper.selectOne(any())).thenReturn(balance);
+        when(cfBalanceLogMapper.selectOne(any())).thenReturn(null);
+        when(cfBalanceLogMapper.selectCount(any())).thenReturn(0L);
+
+        FamilyMember member = new FamilyMember();
+        member.setId(1L);
+        member.setFamilyId(7L);
+        member.setUserId(3L);
+        when(familyMemberMapper.selectById(1L)).thenReturn(member);
+
+        // 默认无等级日限行 / 无规则日限 / 无冷却,避免三道闸干扰数量断言
+        when(cfEarnDailyLimitMapper.selectOne(any())).thenReturn(null);
+    }
+
+    private void stubMemberLevel(String levelCode) {
+        MembershipLevelDTO dto = new MembershipLevelDTO();
+        dto.setLevelCode(levelCode);
+        when(membershipService.getCurrentLevel(7L)).thenReturn(dto);
+    }
+
+    private CfEarnRule fixedRule(String code, int amount, String paramsJson) {
+        CfEarnRule r = new CfEarnRule();
+        r.setCode(code);
+        r.setName(code + "-规则");
+        r.setCategory("behavior");
+        r.setEnabled(1);
+        r.setRuleType("fixed");
+        r.setAmount(amount);
+        r.setParamsJson(paramsJson);
+        return r;
+    }
+
+    private Map<String, Object> ctx(Object... kv) {
+        Map<String, Object> m = new HashMap<>();
+        for (int i = 0; i + 1 < kv.length; i += 2) {
+            m.put(String.valueOf(kv[i]), kv[i + 1]);
+        }
+        return m;
+    }
+
+    private CfEarnResult earn(String code, int amount, String paramsJson, String levelCode) {
+        CfEarnRule rule = fixedRule(code, amount, paramsJson);
+        when(cfEarnRuleService.getByCode(code)).thenReturn(rule);
+        stubMemberLevel(levelCode);
+        return cfBalanceService.earnByRule(1L, code, 1000L, ctx());
+    }
+
+    @Test
+    void levelsFAMILY命中_覆盖ruleamount() {
+        // rule.amount=3,levels.FAMILY=10,等级 FAMILY → amount=10
+        CfEarnResult r = earn("F14", 3, "{\"levels\":{\"FAMILY\":10}}", "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(10, r.getAmount());
+        assertEquals("FAMILY", r.getLevelCode());
+    }
+
+    @Test
+    void levels缺失_回落ruleamount() {
+        // 老规则无 levels 字段 → 行为不变,amount=rule.amount
+        CfEarnResult r = earn("F14", 5, "{\"daily_limit_by_tier\":\"cf_earn_daily_limit\"}", "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(5, r.getAmount());
+    }
+
+    @Test
+    void levels当前等级未配置_回退NONE() {
+        // levels 有 FAMILY 但当前等级 BASIC(无 NONE 键)→ 未命中 → 回落 rule.amount
+        CfEarnResult r = earn("F14", 5, "{\"levels\":{\"FAMILY\":10}}", "BASIC");
+        assertTrue(r.getEarned());
+        assertEquals(5, r.getAmount());
+    }
+
+    @Test
+    void levelsNONE命中_免费等级回落NONE() {
+        // levels.NONE=2,等级 FREE(免费/基础档位不在 levels 中)→ amount=2
+        CfEarnResult r = earn("F14", 5, "{\"levels\":{\"NONE\":2}}", "FREE");
+        assertTrue(r.getEarned());
+        assertEquals(2, r.getAmount());
+    }
+
+    @Test
+    void levels当前等级缺失但NONE在_回退NONE() {
+        // levels 有 NONE/FAMILY/PREMIUM,当前等级 PROFESSIONAL(未配置)→ 回退 NONE=2
+        CfEarnResult r = earn("F14", 5,
+                "{\"levels\":{\"NONE\":2,\"FAMILY\":4,\"PREMIUM\":10}}", "PROFESSIONAL");
+        assertTrue(r.getEarned());
+        assertEquals(2, r.getAmount());
+    }
+
+    @Test
+    void params为null_回落ruleamount() {
+        CfEarnResult r = earn("F14", 5, null, "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(5, r.getAmount());
+    }
+
+    @Test
+    void levels非Map_回落ruleamount() {
+        CfEarnResult r = earn("F14", 5, "{\"levels\":\"NONE:2,FAMILY:4\"}", "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(5, r.getAmount());
+    }
+
+    @Test
+    void levels值为0_视为未命中_回落ruleamount() {
+        // 命中但值 <= 0 不生效(0 表示"未配置/禁用")
+        CfEarnResult r = earn("F14", 5, "{\"levels\":{\"FAMILY\":0}}", "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(5, r.getAmount());
+    }
+
+    @Test
+    void levels命中后再乘multiplier() {
+        // levels.FAMILY=4,multiplier=2 → base=4,*2=8
+        CfEarnResult r = earn("F14", 3,
+                "{\"levels\":{\"FAMILY\":4},\"multiplier\":2}", "FAMILY");
+        assertTrue(r.getEarned());
+        assertEquals(8, r.getAmount());
+    }
+}

+ 5 - 0
cfc-web/src/api/cfRule.js

@@ -17,6 +17,11 @@ export function getCfEarnRuleHistory(data) {
   return request({ url: '/api/admin/cf-earn-rule/history', method: 'post', data })
 }
 
+// ===== 会员等级(按等级配置单次 CF 值矩阵的等级列表来源,T2) =====
+export function getAdminMembershipLevels() {
+  return request({ url: '/api/admin/membership/levels', method: 'post' })
+}
+
 // ===== CF 销售奖档位(cf_rate_tier,销售奖档位配置) =====
 export function getCfRateTierList() {
   return request({ url: '/api/admin/cf-rate-tier/list', method: 'post' })

+ 130 - 1
cfc-web/src/views/admin/CfRuleConfig.vue

@@ -179,6 +179,22 @@
         <el-form-item label="参数 JSON">
           <el-input v-model="ruleForm.paramsJson" type="textarea" :rows="3" placeholder='{"bps": 50, "max_rate_percent": 70}' />
         </el-form-item>
+        <el-form-item v-if="ruleForm.ruleType === 'fixed'" label="按会员等级配置单次 CF 值">
+          <div v-if="levelOptions.length" class="level-matrix">
+            <div v-for="row in levelOptions" :key="row.code" class="level-matrix-row">
+              <span class="level-matrix-name">{{ row.label }}</span>
+              <el-input-number
+                v-model="levelMap[row.code]"
+                :min="0"
+                :precision="0"
+                :controls="false"
+                size="small"
+                style="width: 130px"
+              />
+            </div>
+            <div class="level-matrix-note">未填等级按「固定数量」发放;「非会员」为未识别等级的兜底(保存后写入参数 JSON 的 levels 字段)。</div>
+          </div>
+        </el-form-item>
         <el-form-item label="备注">
           <el-input v-model="ruleForm.remark" type="textarea" :rows="2" />
         </el-form-item>
@@ -248,7 +264,20 @@
 </template>
 
 <script>
-import { getCfEarnRuleList, saveCfEarnRule, toggleCfEarnRule, getCfEarnRuleHistory, getCfRateTierList, saveCfRateTier, deleteCfRateTier } from '@/api/cfRule'
+import { getCfEarnRuleList, saveCfEarnRule, toggleCfEarnRule, getCfEarnRuleHistory, getCfRateTierList, saveCfRateTier, deleteCfRateTier, getAdminMembershipLevels } from '@/api/cfRule'
+
+// 等级列表兜底枚举(T2:读 /api/admin/membership/levels 失败时使用)
+const LEVEL_FALLBACK = [
+  { code: 'NONE', label: '非会员' },
+  { code: 'FAMILY', label: 'FAMILY' },
+  { code: 'PREMIUM', label: 'PREMIUM' }
+]
+
+function levelOptionsToMap(options) {
+  const map = {}
+  ;(options || []).forEach(r => { map[r.code] = null })
+  return map
+}
 
 export default {
   name: 'CfRuleConfig',
@@ -262,6 +291,9 @@ export default {
       ruleQuery: { category: '', enabled: null },
       ruleDialogVisible: false,
       ruleForm: {},
+      // ---- level matrix (T2) ----
+      levelOptions: LEVEL_FALLBACK,
+      levelMap: levelOptionsToMap(LEVEL_FALLBACK),
       // ---- history ----
       historyVisible: false,
       historyCode: '',
@@ -278,11 +310,13 @@ export default {
   mounted() {
     this.loadRules()
     this.loadTiers()
+    this.loadLevelOptions()
   },
   methods: {
     refreshAll() {
       this.loadRules()
       this.loadTiers()
+      this.loadLevelOptions()
     },
     // ============ 发放规则 ============
     loadRules() {
@@ -294,12 +328,79 @@ export default {
         .catch(() => {})
         .finally(() => { this.ruleLoading = false })
     },
+    // ============ 会员等级(T2 矩阵等级来源) ============
+    loadLevelOptions() {
+      getAdminMembershipLevels()
+        .then(res => {
+          const list = (res && res.data) || []
+          if (!list || !list.length) {
+            this.applyLevelOptions(LEVEL_FALLBACK)
+            return
+          }
+          const seen = {}
+          const rows = [{ code: 'NONE', label: '非会员' }]
+          seen.NONE = true
+          list.forEach(m => {
+            if (m && m.levelCode && !seen[m.levelCode]) {
+              seen[m.levelCode] = true
+              rows.push({ code: m.levelCode, label: m.levelName || m.levelCode })
+            }
+          })
+          this.applyLevelOptions(rows)
+        })
+        .catch(() => { this.applyLevelOptions(LEVEL_FALLBACK) })
+    },
+    applyLevelOptions(options) {
+      this.levelOptions = options
+      const map = this.levelMap || {}
+      ;(options || []).forEach(r => {
+        if (!(r.code in map)) {
+          this.$set(map, r.code, null)
+        }
+      })
+      this.levelMap = map
+    },
+    // 编辑时回显 paramsJson.levels 到矩阵
+    initLevelMap(paramsJson) {
+      const map = levelOptionsToMap(this.levelOptions)
+      try {
+        const p = JSON.parse(paramsJson || '{}')
+        if (p && p.levels && typeof p.levels === 'object') {
+          Object.keys(p.levels).forEach(k => {
+            if (k in map && p.levels[k] !== undefined && p.levels[k] !== null) {
+              map[k] = p.levels[k]
+            }
+          })
+        }
+      } catch (e) {
+        // 参数 JSON 非法时矩阵留空,保存时会提示
+      }
+      this.levelMap = map
+    },
+    // 保存时把矩阵序列化为 paramsJson.levels(保留 paramsJson 其它键与 levels 中非当前等级的旧键)
+    matrixToLevels(existingLevels) {
+      const levels = {}
+      if (existingLevels && typeof existingLevels === 'object' && !Array.isArray(existingLevels)) {
+        Object.keys(existingLevels).forEach(k => { levels[k] = existingLevels[k] })
+      }
+      this.levelOptions.forEach(row => {
+        const v = this.levelMap[row.code]
+        const n = Number(v)
+        if (v !== '' && v !== undefined && v !== null && !isNaN(n) && n > 0) {
+          levels[row.code] = Math.floor(n)
+        } else {
+          delete levels[row.code]
+        }
+      })
+      return levels
+    },
     openRuleDialog(row) {
       if (row) {
         this.ruleForm = Object.assign({}, row, { enabled: row.enabled === 1 ? 1 : 0, changeReason: '' })
       } else {
         this.ruleForm = { enabled: 1, ruleType: 'fixed', sortOrder: 0, changeReason: '' }
       }
+      this.initLevelMap(this.ruleForm.paramsJson)
       this.ruleDialogVisible = true
     },
     saveRule() {
@@ -307,6 +408,30 @@ export default {
         this.$message.warning('编码和名称必填')
         return
       }
+      // 参数 JSON 合法性校验(防注入):非空时必须可解析为 JSON 对象
+      const rawParams = this.ruleForm.paramsJson
+      let params = {}
+      if (rawParams && String(rawParams).trim()) {
+        try {
+          params = JSON.parse(String(rawParams).trim())
+          if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            this.$message.warning('参数 JSON 必须是 JSON 对象')
+            return
+          }
+        } catch (e) {
+          this.$message.warning('参数 JSON 格式非法:' + e.message)
+          return
+        }
+      }
+      if (this.ruleForm.ruleType === 'fixed') {
+        const levels = this.matrixToLevels(params.levels)
+        if (Object.keys(levels).length) {
+          params.levels = levels
+        } else {
+          delete params.levels
+        }
+        this.ruleForm.paramsJson = JSON.stringify(params)
+      }
       this.ruleSaving = true
       const adminId = Number(localStorage.getItem('adminId')) || null
       const payload = Object.assign({}, this.ruleForm, { changedBy: adminId })
@@ -436,4 +561,8 @@ export default {
   color: #595959;
 }
 .tier-tip { margin-bottom: 0; }
+.level-matrix { display: flex; flex-direction: column; gap: 8px; }
+.level-matrix-row { display: flex; align-items: center; gap: 10px; }
+.level-matrix-name { width: 150px; font-size: 13px; color: #303133; }
+.level-matrix-note { font-size: 12px; color: #909399; line-height: 1.5; }
 </style>