Merge remote-tracking branch 'origin/glms/feature/1.4.2' into glms/feature/1.4.2

UnitTestProject/Modules/SwapModule/GLMS20260701DbDiagnoseTest.cs

@@ -18,7 +18,8 @@ namespace YLErp.Modules.SwapModule
     [TestClass]
     public class GLMS20260701DbDiagnoseTest
     {
-        private const string TradeNumber = "GLMS-20260701-0008";
+        private const string TradeNumber_0008 = "GLMS-20260701-0008";
+        private const string TradeNumber_0013 = "GLMS-20260701-0013";
 
         #region 1) 录真实数据快照（手动跑）
 
@@ -31,8 +32,8 @@ namespace YLErp.Modules.SwapModule
             try { db = DbContextFactory.GetYLDbContext(); }
             catch (Exception ex) { Assert.Inconclusive($"无法连接测试库：{ex.Message}"); return; }
 
-            var td = db.trade.FirstOrDefault(t => t.TradeNumber == TradeNumber);
-            Assert.IsNotNull(td, $"测试库无交易 {TradeNumber}，请确认环境");
+            var td = db.trade.FirstOrDefault(t => t.TradeNumber == TradeNumber_0008);
+            Assert.IsNotNull(td, $"测试库无交易 {TradeNumber_0008}，请确认环境");
 
             var snapshot = new JObject
             {
@@ -99,13 +100,25 @@ namespace YLErp.Modules.SwapModule
         [TestMethod]
         [TestCategory("DbDiagnose")]
         public void Diagnose_InterestPrincipalFix_Progression_And_UnwindResult()
+        {
+            DiagnoseTrade(TradeNumber_0008);
+        }
+
+        [TestMethod]
+        [TestCategory("DbDiagnose")]
+        public void Diagnose_0013_InterestPrincipalFix_Progression_And_UnwindResult()
+        {
+            DiagnoseTrade(TradeNumber_0013);
+        }
+
+        private void DiagnoseTrade(string tradeNumber)
         {
             YLContext db;
             try { db = DbContextFactory.GetYLDbContext(); }
             catch (Exception ex) { Assert.Inconclusive($"无法连接测试库：{ex.Message}"); return; }
 
-            var td = db.trade.FirstOrDefault(t => t.TradeNumber == TradeNumber);
-            if (td == null) { Assert.Inconclusive($"测试库无 {TradeNumber}"); return; }
+            var td = db.trade.FirstOrDefault(t => t.TradeNumber == tradeNumber);
+            if (td == null) { Assert.Inconclusive($"测试库无 {tradeNumber}"); return; }
 
             // 2.1 预付金腿 position.InterestPrincipalFix 当前值（多次平仓后应该已被扣减）
             var marginPositions = db.swap_position
@@ -127,11 +140,11 @@ namespace YLErp.Modules.SwapModule
                 .ToList();
 
             Console.WriteLine("\n============== 全部 position 全景（对比 IsInitial 原始 vs !IsInitial 剩余） ==============");
-            Console.WriteLine($"  {"Id",-8}{"Mode",-6}{"Dir",-6}{"IsInit",-8}{"Fix",-18}{"PosiNotional",-18}{"PosiQty",-12}{"UnderlyingCode",-15}");
+            Console.WriteLine($"  {"Id",-8}{"Mode",-6}{"IntDir",-7}{"PosiDir",-8}{"IsInit",-8}{"Fix",-18}{"PosiNotional",-18}{"PosiQty",-12}{"UnderlyingCode",-15}");
             foreach (var p in allPositions)
             {
                 var ul = p.UnderlyingCode ?? "";
-                Console.WriteLine($"  {p.id,-8}{p.InterestMode,-6}{p.InterestDirection,-6}{p.IsInitial,-8}{p.InterestPrincipalFix,-18}{p.PosiNotionalValue,-18}{p.PosiQuantity,-12}{ul,-15}");
+                Console.WriteLine($"  {p.id,-8}{p.InterestMode,-6}{p.InterestDirection,-7}{p.PosiDirection,-8}{p.IsInitial,-8}{p.InterestPrincipalFix,-18}{p.PosiNotionalValue,-18}{p.PosiQuantity,-12}{ul,-15}");
             }
 
             // 2.1c 关键诊断：GetUnwindInterests 内部 origPositions vs realPostitions 差异
@@ -143,6 +156,14 @@ namespace YLErp.Modules.SwapModule
             Console.WriteLine($"  origPositions(IsInitial=True) 预付金腿 Fix: {string.Join(",", origPositions.Where(x => x.InterestMode == 5 || x.InterestMode == 6).Select(x => x.InterestPrincipalFix))}");
             Console.WriteLine($"  realPostitions(IsInitial=False) 预付金腿 Fix: {string.Join(",", realPostitions.Where(x => x.InterestMode == 5 || x.InterestMode == 6).Select(x => x.InterestPrincipalFix))}  ← 应为剩余值");
 
+            // 2.1d 关键诊断：realLeg.PositionId == origPos.id 匹配校验（修复后端 Clone 是否会触发）
+            Console.WriteLine("\n============== realLeg.PositionId ↔ origPos.id 匹配校验（决定 Clone 是否生效）==============");
+            foreach (var origPos in origPositions.Where(p => p.InterestMode == 5 || p.InterestMode == 6))
+            {
+                var realLeg = realPostitions.FirstOrDefault(r => r.PositionId == origPos.id);
+                Console.WriteLine($"  origPos.id={origPos.id} Fix={origPos.InterestPrincipalFix} | realLeg found={(realLeg != null)} | realLeg.id={realLeg?.id} realLeg.PositionId={realLeg?.PositionId} realLeg.Fix={realLeg?.InterestPrincipalFix} | 需Clone={(realLeg != null && realLeg.InterestPrincipalFix != origPos.InterestPrincipalFix)}");
+            }
+
             // 2.2 EOD 持仓 InterestPrincipalFix 逐日序列
             var eodMarginSeq = db.eod_swap_position
                 .Where(e => e.SwapTradeId == td.id && !e.Invalid
@@ -171,12 +192,38 @@ namespace YLErp.Modules.SwapModule
                 Console.WriteLine($"  EventDate={f.EventDate:yyyy-MM-dd} PositionId={f.PositionId} InterestPrincipal={f.InterestPrincipal} InterestAmount={f.InterestAmount} Quantity={f.Quantity} TradingAmount={f.TradingAmount}");
             }
 
+            // 2.3b 直接调 ResolveInterestLegPositions，验证 Clone 是否真的把 Fix 覆盖成 realLeg 值
+            var resolved = SwapDealService.ResolveInterestLegPositions(origPositions, realPostitions);
+            Console.WriteLine("\n============== ResolveInterestLegPositions 直接调用结果 ==============");
+            foreach (var rp in resolved.Where(x => x.InterestMode == 5 || x.InterestMode == 6))
+            {
+                Console.WriteLine($"  resolved: id={rp.id} PositionId={rp.PositionId} Mode={rp.InterestMode} Fix={rp.InterestPrincipalFix} (期望=realLeg.Fix)");
+            }
+
+            // 2.3c 模拟前端调用 controller 完整流程：前端传 closePercent=0.7(占期初) + notionalValue/posiNotionalValue
+            //      controller 调 ToRemainingClosePercent 转为占剩余，再调 GetUnwindInterests
+            //      等价于 HTTP POST /swaptrade2/GetUnwindInterestList
+            Console.WriteLine("\n============== 模拟 HTTP API 调用（前端 closePercent=0.7 占期初）==============");
+            decimal frontClosePercent = 0.7m;
+            decimal frontNotionalValue = Convert.ToDecimal(td.OriginalStockEqvNotional ?? 0d);       // 期初名义本金
+            decimal frontPosiNotionalValue = Convert.ToDecimal(td.StockEqvNotional);            // 剩余名义本金
+            Console.WriteLine($"  前端参数: closePercent={frontClosePercent} notionalValue={frontNotionalValue} posiNotionalValue={frontPosiNotionalValue}");
+            decimal convertedClosePercent = SwapDealService.ToRemainingClosePercent(frontClosePercent, frontNotionalValue, frontPosiNotionalValue);
+            Console.WriteLine($"  ToRemainingClosePercent 转换后: closePercent={convertedClosePercent}（占剩余）");
+            var svc = new SwapDealService(new OptUserInfo(1, "UnitTest", OptUserFrom.UnitTest));
+            var apiInterests = svc.GetUnwindInterests(DateTime.Today, DateTime.Today, td.id, convertedClosePercent, (int)SwapEventTypeEnum.平仓);
+            Console.WriteLine($"  GetUnwindInterests 返回 {apiInterests.Count} 条，预付金腿：");
+            foreach (var ai in apiInterests.Where(x => x.InterestMode == (int)InterestModeEnum.初始预付金 || x.InterestMode == (int)InterestModeEnum.追加预付金))
+            {
+                Console.WriteLine($"    PositionId={ai.PositionId} Mode={ai.InterestMode} InterestPrincipal={ai.InterestPrincipal} InterestAmount={ai.InterestAmount}");
+            }
+
             // 2.4 直调后端 GetUnwindInterests(closePercent=1.0) 看"按全部平仓应返"的预付金值
             try
             {
                 var user = new OptUserInfo(0, nameof(GLMS20260701DbDiagnoseTest), OptUserFrom.UnitTest);
-                var svc = new SwapDealService(user);
-                var interests = svc.GetUnwindInterests(DateTime.Today, DateTime.Today, td.id, 1.0m, (int)SwapEventTypeEnum.平仓);
+                var svcFull = new SwapDealService(user);
+                var interests = svcFull.GetUnwindInterests(DateTime.Today, DateTime.Today, td.id, 1.0m, (int)SwapEventTypeEnum.平仓);
 
                 Console.WriteLine("============== 后端 GetUnwindInterests(1.0) 实际返回值-预付金腿 ==============");
                 foreach (var it in interests.Where(i => i.InterestMode == 5 || i.InterestMode == 6))

UnitTestProject/Modules/SwapModule/InitUnwindDefaultClosePercentTest.cs

@@ -0,0 +1,103 @@
+namespace YLErp.Modules.SwapModule
+{
+    /// <summary>
+    /// InitUnwind 默认 ClosePercent 计算的回归测试。
+    /// ---------------------------------------------------------------
+    /// 守卫提交 e2fb456b "fix 平仓(InitUnwind L267)硬编码 1 而不是剩余平仓比例"。
+    ///
+    /// 旧 bug：InitUnwind 默认把 ClosePercent 硬编码为 1（按"占剩余 100%"），
+    /// 但前端约定 ClosePercent 是"占期初(original)"口径(A)，1 表示平掉原始本金的 100%。
+    /// 多次部分平仓后剩余本金 < 期初本金，此时默认 1 在前端语义上意味着"还要平掉原始全部"，
+    /// 与"平掉剩余全部"意图不符，且会触发后端 ToRemainingClosePercent 转换后 >1 被 cap 到 1，
+    /// 表面看无差异但语义混乱，且若前端 / 事件展示直接用此值会出错。
+    ///
+    /// 修复：ClosePercent = PosiNotionalValue / NotionalValue（占期初口径的"平剩余全部"）。
+    /// 抽出为纯函数 CalcDefaultInitClosePercent 以支持无库单测。
+    /// </summary>
+    [TestClass]
+    public class InitUnwindDefaultClosePercentTest
+    {
+        // ================================================================
+        // 场景1：未平仓 PosiNotionalValue == NotionalValue → ClosePercent = 1
+        // ================================================================
+        [TestMethod]
+        public void 未平仓_剩余等于期初_默认ClosePercent为1()
+        {
+            var result = SwapDealService.CalcDefaultInitClosePercent(
+                notionalValue: 1_000_000m, posiNotionalValue: 1_000_000m);
+
+            Assert.AreEqual(1m, result, "未平仓：默认应平 100%（占期初）");
+        }
+
+        // ================================================================
+        // 场景2：已平 30%（剩 70%）→ ClosePercent = 0.7
+        // ================================================================
+        [TestMethod]
+        public void 已平30_剩70_默认ClosePercent为0_7()
+        {
+            var result = SwapDealService.CalcDefaultInitClosePercent(
+                notionalValue: 1_000_000m, posiNotionalValue: 700_000m);
+
+            Assert.AreEqual(0.7m, result, 0.0001m, "已平 30% 剩 70%：默认 ClosePercent=0.7（占期初）");
+        }
+
+        // ================================================================
+        // 场景3：除零保护 NotionalValue = 0 → 返回 1（容错）
+        // ================================================================
+        [TestMethod]
+        public void 期初名义本金为零_返回1_容错不除零()
+        {
+            var result = SwapDealService.CalcDefaultInitClosePercent(
+                notionalValue: 0m, posiNotionalValue: 100_000m);
+
+            Assert.AreEqual(1m, result, "期初本金为 0 时容错返回 1，不应抛除零异常");
+        }
+
+        // ================================================================
+        // 场景4：GLMS-20260701-0013 真实快照（已平 2 次）
+        //   期初 NotionalValue = 980,000 / 剩余 PosiNotionalValue = 686,000.07
+        //   期望 ClosePercent ≈ 0.7（686000.07/980000）
+        // ================================================================
+        [TestMethod]
+        public void GLMS20260701_0013_已平两次_默认ClosePercent约为0_7()
+        {
+            var result = SwapDealService.CalcDefaultInitClosePercent(
+                notionalValue: 980_000m, posiNotionalValue: 686_000.07m);
+
+            // 686000.07 / 980000 = 0.700000071...
+            Assert.AreEqual(0.7m, result, 0.0001m,
+                "GLMS-20260701-0013 已平两次：默认 ClosePercent 应≈0.7（占期初），旧 bug 会硬编码 1");
+        }
+
+        // ================================================================
+        // 场景5：与 ToRemainingClosePercent 联动验证
+        //   前端拿 InitUnwind 返回的 A(占期初) 默认值，经 ToRemainingClosePercent 转 B(占剩余)，
+        //   应恰好 = 1.0（因为"平剩余全部"在占剩余语义下就是 100%）
+        // ================================================================
+        [TestMethod]
+        public void 默认A经ToRemainingClosePercent转B应为1_平剩余全部()
+        {
+            const decimal notionalValue = 1_000_000m;
+            const decimal posiNotionalValue = 600_000m; // 已平 40%，剩 60%
+
+            var defaultA = SwapDealService.CalcDefaultInitClosePercent(notionalValue, posiNotionalValue);
+            var convertedB = SwapDealService.ToRemainingClosePercent(defaultA, notionalValue, posiNotionalValue);
+
+            Assert.AreEqual(0.6m, defaultA, 0.0001m, "占期初默认 A=0.6");
+            Assert.AreEqual(1.0m, convertedB, 0.0001m,
+                "A=0.6 经 ToRemainingClosePercent 转换 → B=1.0（占剩余 100% = 平剩余全部），此为占期初/占剩余双语义自洽的关键不变式");
+        }
+
+        // ================================================================
+        // 场景6：全平完（PosiNotionalValue=0）→ ClosePercent=0（边界，实际不会进 InitUnwind）
+        // ================================================================
+        [TestMethod]
+        public void 全平完剩余为零_ClosePercent为零()
+        {
+            var result = SwapDealService.CalcDefaultInitClosePercent(
+                notionalValue: 1_000_000m, posiNotionalValue: 0m);
+
+            Assert.AreEqual(0m, result, "剩余本金为 0 时 ClosePercent=0（边界场景，实际全部平完不会再进 InitUnwind）");
+        }
+    }
+}

UnitTestProject/Modules/SwapModule/SwapEodRealizedPnlCalcTest.cs

@@ -0,0 +1,206 @@
+using YLErp.DBModels;
+using YLErp.DBModels.Enums;
+
+namespace YLErp.Modules.SwapModule
+{
+    /// <summary>
+    /// SwapEodPositionService.CalculateSwapRealizedPnl 的回归测试。
+    /// ---------------------------------------------------------------
+    /// 守卫张名锐提交 6676b625 "fix(swap): 修正掉期产品保证金利息计算逻辑"。
+    ///
+    /// 旧 bug：eod_swap.RealizedPnL 直接 Sum(s.RealizedPnl)，未对保证金腿利息做方向反向，
+    /// 导致"收取对手方保证金"产生的利息被错误计入我方收益（实际是我方支付给对手方的成本），
+    /// 框架合约已实现收益虚高。
+    ///
+    /// 修复：新增 CalculateSwapRealizedPnl ——
+    ///   非保证金腿：interestRatio = Direction==收取 ? 1 : -1（维持数据库方向）
+    ///   保证金腿（初始预付金 5 / 追加预付金 6）：interestRatio 反向
+    ///   最终：RealizedInterest × interestRatio + 其他 4 字段
+    ///
+    /// 抽为 public static 纯函数以支持无库单测（marginTypes 等价于 ConsTrade.InterestMarginModels）。
+    /// 本测试直接锁定方向反向契约，防止后续误改回归。
+    /// </summary>
+    [TestClass]
+    public class SwapEodRealizedPnlCalcTest
+    {
+        // ================================================================
+        // 场景1：非保证金腿收取方向 → RealizedInterest × +1（维持原向）
+        // ================================================================
+        [TestMethod]
+        public void 非保证金腿_收取方向_利息维持原向系数为1()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.固定值,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedInterest: 1000m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            Assert.AreEqual(1000m, result, 0.0001m,
+                "非保证金腿收取方向：利息 ×(+1)=1000");
+        }
+
+        // ================================================================
+        // 场景2：非保证金腿支付方向 → RealizedInterest × -1（维持原向）
+        // ================================================================
+        [TestMethod]
+        public void 非保证金腿_支付方向_利息维持原向系数为负1()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.固定值,
+                interestDirection: (int)SwapDirectionEnum.支付,
+                realizedInterest: 1000m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            Assert.AreEqual(-1000m, result, 0.0001m,
+                "非保证金腿支付方向：利息 ×(-1)=-1000");
+        }
+
+        // ================================================================
+        // 场景3：保证金腿（初始预付金）收取方向 → 利息反向，系数 -1
+        // 这是 6676b625 修复的核心场景：收取对手方保证金产生的利息是我方支付成本
+        // ================================================================
+        [TestMethod]
+        public void 保证金腿_初始预付金_收取方向_利息反向系数为负1()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.初始预付金,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedInterest: 1000m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            Assert.AreEqual(-1000m, result, 0.0001m,
+                "保证金腿收取方向：利息应反向 ×(-1)=-1000（修复前会错误得 +1000）");
+        }
+
+        // ================================================================
+        // 场景4：保证金腿（初始预付金）支付方向 → 利息反向，系数 +1
+        // ================================================================
+        [TestMethod]
+        public void 保证金腿_初始预付金_支付方向_利息反向系数为1()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.初始预付金,
+                interestDirection: (int)SwapDirectionEnum.支付,
+                realizedInterest: 1000m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            Assert.AreEqual(1000m, result, 0.0001m,
+                "保证金腿支付方向：利息应反向 ×(+1)=1000");
+        }
+
+        // ================================================================
+        // 场景5：追加预付金同初始预付金，同样走反向逻辑
+        // ================================================================
+        [TestMethod]
+        public void 保证金腿_追加预付金_收取方向_利息反向()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.追加预付金,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedInterest: 500m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            Assert.AreEqual(-500m, result, 0.0001m,
+                "追加预付金(mode=6)与初始预付金(mode=5)同走反向逻辑");
+        }
+
+        // ================================================================
+        // 场景6：完整 5 字段汇总（MtmPnL + Dividend + Fee + Interest×ratio + InterestFee）
+        //   保证金腿收取方向，Interest=200, 其他各 100
+        //   期望：100 + 100 + 100 + 200×(-1) + 100 = 200
+        // ================================================================
+        [TestMethod]
+        public void 完整5字段汇总_保证金腿收取方向_利息反向后合计正确()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.初始预付金,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedMtmPnL: 100m,
+                realizedDividend: 100m,
+                realizedFee: 100m,
+                realizedInterest: 200m,
+                realizedInterestFee: 100m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            // 100 + 100 + 100 + 200×(-1) + 100 = 200
+            Assert.AreEqual(200m, result, 0.0001m,
+                "5 字段汇总：保证金腿收取方向，Interest×(-1) 后合计=200，验证所有字段都参与计算");
+        }
+
+        // ================================================================
+        // 场景7：完整 5 字段汇总（非保证金腿收取方向）
+        //   非保证金腿收取方向，Interest=200, 其他各 100
+        //   期望：100 + 100 + 100 + 200×(+1) + 100 = 600
+        // ================================================================
+        [TestMethod]
+        public void 完整5字段汇总_非保证金腿收取方向_利息原向合计正确()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.固定值,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedMtmPnL: 100m,
+                realizedDividend: 100m,
+                realizedFee: 100m,
+                realizedInterest: 200m,
+                realizedInterestFee: 100m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            // 100 + 100 + 100 + 200×(+1) + 100 = 600
+            Assert.AreEqual(600m, result, 0.0001m,
+                "5 字段汇总：非保证金腿收取方向，Interest×(+1) 后合计=600");
+        }
+
+        // ================================================================
+        // 场景8：RealizedInterest=0 边界 —— 方向反向无影响，结果为其他 4 字段之和
+        // ================================================================
+        [TestMethod]
+        public void 利息为零_方向反向无影响_结果为其他4字段之和()
+        {
+            var pos = NewPosition(
+                interestMode: (int)InterestModeEnum.初始预付金,
+                interestDirection: (int)SwapDirectionEnum.收取,
+                realizedMtmPnL: 100m,
+                realizedDividend: 50m,
+                realizedFee: 30m,
+                realizedInterest: 0m,
+                realizedInterestFee: 20m);
+
+            var result = SwapEodPositionService.CalculateSwapRealizedPnl(pos);
+
+            // 100 + 50 + 30 + 0×(-1) + 20 = 200
+            Assert.AreEqual(200m, result, 0.0001m,
+                "RealizedInterest=0 时方向反向无影响，结果为其他 4 字段之和");
+        }
+
+        // ================================================================
+        // Helper：构造 eod_swap_position（只设置参与计算的 7 个字段）
+        // ================================================================
+        private static eod_swap_position NewPosition(
+            int interestMode,
+            int interestDirection,
+            decimal realizedMtmPnL = 0m,
+            decimal realizedDividend = 0m,
+            decimal realizedFee = 0m,
+            decimal realizedInterest = 0m,
+            decimal realizedInterestFee = 0m)
+        {
+            return new eod_swap_position
+            {
+                InterestMode = interestMode,
+                InterestDirection = interestDirection,
+                RealizedMtmPnL = realizedMtmPnL,
+                RealizedDividend = realizedDividend,
+                RealizedFee = realizedFee,
+                RealizedInterest = realizedInterest,
+                RealizedInterestFee = realizedInterestFee
+            };
+        }
+    }
+}

UnitTestProject/Modules/TradeModule/TradeServiceBaseCloseNotionalCalcTest.cs

@@ -0,0 +1,133 @@
+using Newtonsoft.Json;
+using YLErp.DBModels;
+using YLErp.Modules.TradeModule;
+
+namespace YLErp.Modules.TradeModule
+{
+    /// <summary>
+    /// TradeServiceBase.CalcSwapCloseNotionalFromEventData / CalcOptionCloseNotional 的回归测试。
+    /// ---------------------------------------------------------------
+    /// 守卫锦麟王提交 23108016 "BugFix 互换本次名义本金取错"。
+    ///
+    /// 旧 bug：BuildTriggerContext 了结场景统一用 trade_cash.UnwindPercentRate × 期初名义本金
+    /// 算本次名义本金，但收益互换的 trade_cash.UnwindPercentRate 口径与期权不同，
+    /// 导致互换审批触发条件用错本金，可能绕过/误触发审批阈值。
+    ///
+    /// 修复：互换分支从 swap_event.EventData 反序列化取 CloseNotionalValue 绝对值；
+    ///      期权分支保留旧逻辑（期初名义本金 × UnwindPercentRate 绝对值）。
+    ///
+    /// 抽出两个静态纯函数以支持无库单测，重点验证容错（null/空/非法 JSON）不会抛异常
+    /// 而是返回 0，避免静默吞异常导致名义本金为 0 进而绕过审批阈值。
+    /// </summary>
+    [TestClass]
+    public class TradeServiceBaseCloseNotionalCalcTest
+    {
+        // ================================================================
+        // 一、CalcSwapCloseNotionalFromEventData 容错与绝对值语义
+        // ================================================================
+
+        [TestMethod]
+        public void 互换_EventData为null_返回0_不抛异常()
+        {
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData(null);
+            Assert.AreEqual(0d, result, 0.0001, "null EventData 应容错返回 0");
+        }
+
+        [TestMethod]
+        public void 互换_EventData为空字符串_返回0_不抛异常()
+        {
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData("");
+            Assert.AreEqual(0d, result, 0.0001, "空字符串 EventData 应容错返回 0");
+        }
+
+        [TestMethod]
+        public void 互换_EventData为非法JSON_返回0_不抛异常()
+        {
+            // 旧实现 catch{} 静默吞异常，抽函数后必须保持此容错契约
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData("not-a-json");
+            Assert.AreEqual(0d, result, 0.0001, "非法 JSON 应被 catch 返回 0，不能抛异常");
+        }
+
+        [TestMethod]
+        public void 互换_EventData为合法JSON_正数CloseNotionalValue_原值返回()
+        {
+            var eventData = JsonConvert.SerializeObject(new UnwindData { CloseNotionalValue = 500_000m });
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData(eventData);
+            Assert.AreEqual(500_000d, result, 0.01, "正数 CloseNotionalValue 应原值返回");
+        }
+
+        [TestMethod]
+        public void 互换_EventData为合法JSON_负数CloseNotionalValue_取绝对值()
+        {
+            // 修复的核心契约：Math.Abs 取绝对值，防止方向反向导致名义本金变负
+            var eventData = JsonConvert.SerializeObject(new UnwindData { CloseNotionalValue = -500_000m });
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData(eventData);
+            Assert.AreEqual(500_000d, result, 0.01, "负数 CloseNotionalValue 应取绝对值返回 500000");
+        }
+
+        [TestMethod]
+        public void 互换_EventData为合法JSON_CloseNotionalValue为零_返回0()
+        {
+            var eventData = JsonConvert.SerializeObject(new UnwindData { CloseNotionalValue = 0m });
+            var result = TradeServiceBase.CalcSwapCloseNotionalFromEventData(eventData);
+            Assert.AreEqual(0d, result, 0.0001, "CloseNotionalValue=0 应返回 0");
+        }
+
+        // ================================================================
+        // 二、CalcOptionCloseNotional 容错与绝对值语义
+        // ================================================================
+
+        [TestMethod]
+        public void 期权_两者都为null_返回0()
+        {
+            var result = TradeServiceBase.CalcOptionCloseNotional(null, null);
+            Assert.AreEqual(0d, result, 0.0001, "两者 null 应返回 0");
+        }
+
+        [TestMethod]
+        public void 期权_期初名义本金为null_返回0()
+        {
+            var result = TradeServiceBase.CalcOptionCloseNotional(null, 0.5d);
+            Assert.AreEqual(0d, result, 0.0001, "originalStockEqvNotional=null 应返回 0");
+        }
+
+        [TestMethod]
+        public void 期权_平仓比例为null_返回0()
+        {
+            var result = TradeServiceBase.CalcOptionCloseNotional(1_000_000d, null);
+            Assert.AreEqual(0d, result, 0.0001, "unwindPercentRate=null 应返回 0");
+        }
+
+        [TestMethod]
+        public void 期权_两者都有值_正数相乘_返回乘积()
+        {
+            // 1,000,000 × 0.3 = 300,000
+            var result = TradeServiceBase.CalcOptionCloseNotional(1_000_000d, 0.3d);
+            Assert.AreEqual(300_000d, result, 0.01, "1M × 0.3 = 300K");
+        }
+
+        [TestMethod]
+        public void 期权_期初名义本金为负数_取绝对值后相乘()
+        {
+            // 异常但容错：-1,000,000 × 0.3 → Abs → 300,000
+            var result = TradeServiceBase.CalcOptionCloseNotional(-1_000_000d, 0.3d);
+            Assert.AreEqual(300_000d, result, 0.01, "期初名义本金为负数应取绝对值后相乘");
+        }
+
+        [TestMethod]
+        public void 期权_平仓比例为负数_取绝对值后相乘()
+        {
+            // 异常但容错：1,000,000 × -0.3 → Abs → 300,000
+            var result = TradeServiceBase.CalcOptionCloseNotional(1_000_000d, -0.3d);
+            Assert.AreEqual(300_000d, result, 0.01, "平仓比例为负数应取绝对值后相乘");
+        }
+
+        [TestMethod]
+        public void 期权_两者都为负数_取绝对值后相乘()
+        {
+            // -1,000,000 × -0.3 = 300,000（先乘后取 Abs，结果一致）
+            var result = TradeServiceBase.CalcOptionCloseNotional(-1_000_000d, -0.3d);
+            Assert.AreEqual(300_000d, result, 0.01, "两者都为负数应取绝对值后相乘");
+        }
+    }
+}

YLErpDAL/Modules/RiskEngine/Dto/BatchDisableRulesResult.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace YLErp.Modules.RiskEngine.Dto
+{
+    /// <summary>
+    /// 批量停用规则结果
+    /// </summary>
+    public class BatchDisableRulesResult
+    {
+        /// <summary>是否全部成功</summary>
+        public bool Success { get; set; }
+        /// <summary>总数量</summary>
+        public int TotalCount { get; set; }
+        /// <summary>成功数量</summary>
+        public int SuccessCount { get; set; }
+        /// <summary>错误信息</summary>
+        public string ErrorMessage { get; set; }
+        /// <summary>级联停用的应用 ID 列表</summary>
+        public List<long> CascadedApplicationIds { get; set; } = new List<long>();
+    }
+}

YLErpDAL/Modules/RiskEngine/Dto/BatchIdsReq.cs

@@ -0,0 +1,10 @@
+namespace YLErp.Modules.RiskEngine.Dto
+{
+    /// <summary>
+    /// 批量操作请求（兼容前端 {ids: [...]} 格式）
+    /// </summary>
+    public class BatchIdsReq
+    {
+        public List<long> Ids { get; set; }
+    }
+}

YLErpDAL/Modules/RiskEngine/Dto/DisableRuleResult.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace YLErp.Modules.RiskEngine.Dto
+{
+    /// <summary>
+    /// 停用规则结果
+    /// </summary>
+    public class DisableRuleResult
+    {
+        /// <summary>级联停用的应用 ID 列表</summary>
+        public List<long> CascadedApplicationIds { get; set; } = new List<long>();
+    }
+}

YLErpDAL/Modules/RiskEngine/Dto/RiskRuleSimpleItem.cs

@@ -1,3 +1,5 @@
+using YLErp.DBModels;
+
 namespace YLErp.Modules.RiskEngine.Dto
 {
     /// <summary>
@@ -11,5 +13,7 @@ namespace YLErp.Modules.RiskEngine.Dto
         public string RuleName { get; set; }
         /// <summary>规则描述文本</summary>
         public string RuleText { get; set; }
+        /// <summary>规则状态</summary>
+        public RiskRuleStatus Status { get; set; }
     }
 }

YLErpDAL/Modules/RiskEngine/RiskEngineService.cs

@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Qdp.Foundation.Utilities;
 using System.Reflection;
 using YLErp.BLL;
@@ -918,6 +918,17 @@ namespace YLErp.Modules.RiskEngine
                 return true;
             }
 
+            var hasAnyScope =
+                !IsScopeEmpty(application.ScopeAssetBookIds) ||
+                !IsScopeEmpty(application.ScopeClientIds) ||
+                !IsScopeEmpty(application.ScopeUnderlyingTypes) ||
+                !IsScopeEmpty(application.ScopeTradeTypes);
+            if (!hasAnyScope)
+            {
+                _logger.Error($"[风控引擎] 非全局应用未配置任何适用范围，拒绝匹配 - ApplicationId: {application.Id}");
+                return false;
+            }
+
             if (trade == null)
             {
                 return false;

YLErpDAL/Modules/RiskEngine/RiskRuleService.cs

@@ -1,9 +1,10 @@
-using BaseOUDAL;
+using BaseOUDAL;
 using Newtonsoft.Json;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Text.RegularExpressions;
 using YLErp.BLL;
+using YLErp.Commons;
 using YLErp.DBModels;
 using YLErp.Modules.RiskEngine.Dto;
 
@@ -76,9 +77,11 @@ using YLErp.Modules.RiskEngine.Dto;
   UpdateRule(long, UpdateRiskRuleReq)      修改规则（乐观锁校验，Version+1）
   DeleteRule(long)                         删除规则（强保护：有 Active 应用时拒绝）
   EnableRule(long)                         启用规则（仅 Disabled → Active）
-  DisableRule(long)                        停用规则（仅 Active → Disabled）
+  DisableRule(long)                        停用规则（仅 Active → Disabled，级联停用关联应用）
   GetRuleVersions(long)                    获取规则版本历史（从审计日志 SnapshotData 提取版本号）
   BatchDeleteRules(List<long>)             批量删除规则（逐条保护检查，单事务）
+  BatchEnableRules(List<long>)             批量启用规则（逐条编译校验）
+  BatchDisableRules(List<long>)            批量停用规则（级联停用关联应用）
   GetRuleApplications(long)                获取规则关联的应用配置列表
   GetAllRuleList()                         获取所有启用规则（轻量字段，供应用配置下拉）
 
@@ -88,6 +91,7 @@ using YLErp.Modules.RiskEngine.Dto;
   CreateApplication(CreateRiskApplicationReq)     新建应用（关联规则 Active 校验，触发时点/Scope 校验）
   UpdateApplication(long, UpdateRiskApplicationReq) 修改应用（乐观锁校验）
   DeleteApplication(long)                         删除应用（软删除）
+  BatchDeleteApplications(List<long>)             批量删除应用（软删除）
   EnableApplication(long)                         启用应用（校验关联规则状态）
   DisableApplication(long)                        停用应用
   BatchEnableApplications(List<long>)             批量启用（逐条校验关联规则）
@@ -207,6 +211,39 @@ namespace YLErp.Modules.RiskEngine
             { RiskVariableDataType.Boolean, new HashSet<string> { "是", "否" } }
         };
 
+        private static readonly Dictionary<string, string> AuditOperationTypeNames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            { "RULE_CREATE", "新建规则" },
+            { "RULE_UPDATE", "修改规则" },
+            { "RULE_DELETE", "删除规则" },
+            { "RULE_ENABLE", "启用规则" },
+            { "RULE_DISABLE", "停用规则" },
+            { "RULE_BATCH_DELETE", "批量删除规则" },
+            { "RULE_BATCH_ENABLE", "批量启用规则" },
+            { "RULE_BATCH_DISABLE", "批量停用规则" },
+            { "APP_CREATE", "新建应用" },
+            { "APP_UPDATE", "修改应用" },
+            { "APP_DELETE", "删除应用" },
+            { "APP_ENABLE", "启用应用" },
+            { "APP_DISABLE", "停用应用" },
+            { "APP_BATCH_ENABLE", "批量启用应用" },
+            { "APP_BATCH_DISABLE", "批量停用应用" },
+            { "APP_BATCH_DELETE", "批量删除应用" },
+            { "RULE_CASCADE_DISABLE_APP", "规则级联停用应用" },
+            { "VAR_CREATE", "新增变量" },
+            { "VARIABLE_CREATE", "新增变量" },
+            { "VAR_UPDATE", "修改变量" },
+            { "VAR_DELETE", "删除变量" },
+            { "VAR_CASCADE_UPDATE_RULE", "变量级联更新规则" }
+        };
+
+        private static readonly Dictionary<string, string> AuditTargetTypeNames = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            { "RULE", "规则" },
+            { "APPLICATION", "应用" },
+            { "VARIABLE", "变量" }
+        };
+
         public RiskRuleService(OptUserInfo userInfo) : base(userInfo)
         {
         }
@@ -221,6 +258,39 @@ namespace YLErp.Modules.RiskEngine
 
         #region Private Helpers
 
+        private static string GetAuditOperationTypeName(string operationType)
+        {
+            if (string.IsNullOrWhiteSpace(operationType))
+                return string.Empty;
+
+            return AuditOperationTypeNames.TryGetValue(operationType.Trim(), out var name)
+                ? name
+                : operationType;
+        }
+
+        private static string GetAuditTargetTypeName(string targetType)
+        {
+            if (string.IsNullOrWhiteSpace(targetType))
+                return string.Empty;
+
+            return AuditTargetTypeNames.TryGetValue(targetType.Trim(), out var name)
+                ? name
+                : targetType;
+        }
+
+        private static string FormatAuditId(object value)
+        {
+            return value == null ? string.Empty : value.ToString();
+        }
+
+        private static string SanitizeFileNamePart(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return string.Empty;
+
+            var sanitized = Regex.Replace(value.Trim(), @"[\\/:*?""<>|\r\n]+", "_");
+            return sanitized.Length <= 40 ? sanitized : sanitized.Substring(0, 40);
+        }
         /// <summary>
         /// 写入审计日志
         /// </summary>
@@ -398,24 +468,32 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         private void ValidateScopeFields(CreateRiskApplicationReq req)
         {
+            var hasAnyScope =
+                !string.IsNullOrWhiteSpace(req.ScopeAssetBookIds) ||
+                !string.IsNullOrWhiteSpace(req.ScopeClientIds) ||
+                !string.IsNullOrWhiteSpace(req.ScopeUnderlyingTypes) ||
+                !string.IsNullOrWhiteSpace(req.ScopeTradeTypes);
+
             if (req.ScopeIsGlobal == 1)
             {
-                if (!string.IsNullOrEmpty(req.ScopeAssetBookIds) ||
-                    !string.IsNullOrEmpty(req.ScopeClientIds) ||
-                    !string.IsNullOrEmpty(req.ScopeUnderlyingTypes) ||
-                    !string.IsNullOrEmpty(req.ScopeTradeTypes))
+                if (hasAnyScope)
                 {
                     throw new ServiceException("全局适用时，不应指定其他适用范围维度");
                 }
                 return;
             }
 
-            if (!string.IsNullOrEmpty(req.ScopeAssetBookIds))
+            if (!hasAnyScope)
+            {
+                throw new ServiceException("非全局应用至少需要指定一个适用范围");
+            }
+
+            if (!string.IsNullOrWhiteSpace(req.ScopeAssetBookIds))
             {
                 ValidateIdList(req.ScopeAssetBookIds, "适用账户");
             }
 
-            if (!string.IsNullOrEmpty(req.ScopeClientIds))
+            if (!string.IsNullOrWhiteSpace(req.ScopeClientIds))
             {
                 ValidateIdList(req.ScopeClientIds, "适用对手方");
             }
@@ -540,6 +618,27 @@ namespace YLErp.Modules.RiskEngine
             return ids;
         }
 
+        /// <summary>
+        /// 规范化逗号分隔的规则 ID：去除空格和重复项，统一为无空格格式。
+        /// </summary>
+        private string NormalizeRuleIds(string ruleIds)
+        {
+            return string.Join(",", ParseRuleIds(ruleIds).Distinct());
+        }
+
+        /// <summary>
+        /// EF Core 可翻译的逗号分隔字段精确匹配表达式
+        /// </summary>
+        private static Expression<Func<glms_risk_rule_application, bool>> RuleIdsMatchExpr(long ruleId)
+        {
+            var idStr = ruleId.ToString();
+            return a => a.RuleIds != null &&
+                (a.RuleIds == idStr ||
+                 a.RuleIds.StartsWith(idStr + ",") ||
+                 a.RuleIds.EndsWith("," + idStr) ||
+                 a.RuleIds.Contains("," + idStr + ","));
+        }
+
         /// <summary>
         /// 校验规则状态可用性并确保编译缓存就绪。
         /// 返回不可用规则信息列表，列表为空表示全部通过。
@@ -722,7 +821,12 @@ namespace YLErp.Modules.RiskEngine
                     OptDate = r.OptDate.GetValueOrDefault(),
                     UpdateOptName = r.UpdateOptName,
                     UpdateDate = r.UpdateDate ?? r.OptDate.GetValueOrDefault(),
-                    ApplicationCount = DbContext.glms_risk_rule_application.Count(a => a.RuleIds.Contains(r.id.ToString()) && a.Status != RiskRuleStatus.Deleted)
+                    ApplicationCount = DbContext.glms_risk_rule_application
+                        .Count(a => a.RuleIds != null &&
+                            (a.RuleIds == r.id.ToString() ||
+                             a.RuleIds.StartsWith(r.id.ToString() + ",") ||
+                             a.RuleIds.EndsWith("," + r.id.ToString()) ||
+                             a.RuleIds.Contains("," + r.id.ToString() + ",")))
                 });
 
             return result.ToSearchList(req);
@@ -735,9 +839,9 @@ namespace YLErp.Modules.RiskEngine
         {
             var rule = GetRuleOrThrow(ruleId);
 
-            var ruleIdStr = ruleId.ToString();
+
             var applications = DbContext.glms_risk_rule_application
-                .Where(a => a.RuleIds.Contains(ruleIdStr) && a.Status != RiskRuleStatus.Deleted)
+                .Where(RuleIdsMatchExpr(ruleId))
                 .Select(a => new RiskRuleApplicationSummary
                 {
                     Id = a.id,
@@ -858,9 +962,10 @@ namespace YLErp.Modules.RiskEngine
         {
             var rule = GetRuleOrThrow(ruleId);
 
-            var ruleIdStr = ruleId.ToString();
+
             var activeCount = DbContext.glms_risk_rule_application
-                .Count(a => a.RuleIds.Contains(ruleIdStr) && a.Status == RiskRuleStatus.Active);
+                .Where(a => a.Status == RiskRuleStatus.Active)
+                .Count(RuleIdsMatchExpr(ruleId));
             if (activeCount > 0)
                 throw new ServiceException($"该规则仍有 {activeCount} 个生效中的应用配置，请先停用或删除相关应用");
 
@@ -903,7 +1008,7 @@ namespace YLErp.Modules.RiskEngine
         /// <summary>
         /// 停用规则（仅 Active → Disabled）
         /// </summary>
-        public void DisableRule(long ruleId)
+        public DisableRuleResult DisableRule(long ruleId)
         {
             var rule = DbContext.glms_risk_rule.FirstOrDefault(r => r.id == ruleId && r.Status == RiskRuleStatus.Active);
             if (rule == null)
@@ -915,9 +1020,38 @@ namespace YLErp.Modules.RiskEngine
             rule.UpdateDate = DateTime.Now;
 
             WriteAuditLog("RULE_DISABLE", "RULE", ruleId, rule.RuleName, "停用规则");
+
+            // 级联停用关联的 Active 应用配置
+            var activeApps = DbContext.glms_risk_rule_application
+                .Where(a => a.Status == RiskRuleStatus.Active)
+                .Where(RuleIdsMatchExpr(ruleId))
+                .ToList();
+
+            var cascadedIds = new List<long>();
+            foreach (var app in activeApps)
+            {
+                app.Status = RiskRuleStatus.Disabled;
+                app.UpdateOptId = UserId;
+                app.UpdateOptName = UserName;
+                app.UpdateDate = DateTime.Now;
+                cascadedIds.Add(app.id);
+
+                WriteAuditLog("RULE_CASCADE_DISABLE_APP", "APPLICATION", app.id, $"应用{app.id}",
+                    $"因规则'{rule.RuleName}'(ID:{ruleId})停用，应用配置被级联停用");
+            }
+
+            if (cascadedIds.Any())
+            {
+                _logger.Info($"[停用规则] 规则ID: {ruleId}, 级联停用应用: {string.Join(",", cascadedIds)}");
+            }
+
             DbContext.SaveChanges();
 
             RiskEngineService.GetInstance().RefreshOneRuleCache(ruleId);
+            if (cascadedIds.Any())
+                RiskEngineService.GetInstance().RefreshApplication();
+
+            return new DisableRuleResult { CascadedApplicationIds = cascadedIds };
         }
 
         /// <summary>
@@ -965,24 +1099,58 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         public BatchOperationResult BatchDeleteRules(List<long> ruleIds)
         {
+            if (ruleIds == null || ruleIds.Count == 0)
+                throw new ServiceException("规则ID列表不能为空");
+
+            _logger.Info($"[批量删除] 开始 - 传入规则数: {ruleIds.Count}, IDs: {string.Join(",", ruleIds)}");
+
             var rules = DbContext.glms_risk_rule
                 .Where(r => ruleIds.Contains(r.id) && r.Status != RiskRuleStatus.Deleted)
                 .ToList();
 
-            if (rules.Count != ruleIds.Count)
-                throw new ServiceException("部分规则不存在或已删除");
+            _logger.Info($"[批量删除] DB查询完成 - 匹配到 {rules.Count} 条规则");
 
+            var foundIds = rules.Select(r => (long)r.id).ToList();
+            var missingIds = ruleIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"以下规则不存在或已删除：{string.Join(", ", missingIds)}"
+                };
+            }
+
+            var blockedRules = new List<string>();
             foreach (var rule in rules)
             {
-                var ruleIdStr = rule.id.ToString();
-                var activeCount = DbContext.glms_risk_rule_application
-                    .Count(a => a.RuleIds.Contains(ruleIdStr) && a.Status == RiskRuleStatus.Active);
+                _logger.Info($"[批量删除] 检查关联应用 - 规则ID: {rule.id}");
+                var activeApps = DbContext.glms_risk_rule_application
+                    .Where(a => a.Status == RiskRuleStatus.Active)
+                    .Where(RuleIdsMatchExpr(rule.id))
+                    .Select(a => (long)a.id)
+                    .ToList();
+                var activeCount = activeApps.Count;
+                _logger.Info($"[批量删除] 关联应用检查结果 - 规则ID: {rule.id}, ActiveCount: {activeCount}, AppIds: [{string.Join(",", activeApps)}]");
                 if (activeCount > 0)
-                    throw new ServiceException($"规则 '{rule.RuleName}' 仍有 {activeCount} 个生效中的应用配置，请先停用或删除相关应用");
+                    blockedRules.Add($"规则 '{rule.RuleName}'(ID:{rule.id}) 仍有 {activeCount} 个生效中的应用配置(IDs: {string.Join(",", activeApps)})");
+            }
+            if (blockedRules.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = string.Join("；", blockedRules)
+                };
             }
 
             foreach (var rule in rules)
             {
+                _logger.Info($"[批量删除] 写入状态 - 规则ID: {rule.id}");
                 rule.Status = RiskRuleStatus.Deleted;
                 rule.Version = rule.Version + 1;
                 rule.UpdateOptId = UserId;
@@ -992,11 +1160,14 @@ namespace YLErp.Modules.RiskEngine
                 WriteAuditLog("RULE_BATCH_DELETE", "RULE", rule.id, rule.RuleName, "批量删除规则");
             }
 
+            _logger.Info("[批量删除] 保存数据库...");
             DbContext.SaveChanges();
+            _logger.Info("[批量删除] 刷新规则缓存...");
             foreach (var ruleId in ruleIds)
             {
                 RiskEngineService.GetInstance().RefreshOneRuleCache(ruleId);
             }
+            _logger.Info("[批量删除] 完成");
 
             return new BatchOperationResult
             {
@@ -1006,6 +1177,210 @@ namespace YLErp.Modules.RiskEngine
             };
         }
 
+        /// <summary>
+        /// 批量启用规则（仅 Disabled → Active，逐条编译校验）
+        /// </summary>
+        public BatchOperationResult BatchEnableRules(List<long> ruleIds)
+        {
+            if (ruleIds == null || ruleIds.Count == 0)
+                throw new ServiceException("规则ID列表不能为空");
+
+            _logger.Info($"[批量启用规则] 开始 - 传入规则数: {ruleIds.Count}, IDs: {string.Join(",", ruleIds)}");
+
+            var rules = DbContext.glms_risk_rule
+                .Where(r => ruleIds.Contains(r.id) && r.Status != RiskRuleStatus.Deleted)
+                .ToList();
+
+            _logger.Info($"[批量启用规则] DB查询完成 - 匹配到 {rules.Count} 条规则");
+
+            var foundIds = rules.Select(r => (long)r.id).ToList();
+            var missingIds = ruleIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"以下规则不存在或已删除：{string.Join(", ", missingIds)}"
+                };
+            }
+
+            // 跳过已启用的规则
+            var skippedIds = rules.Where(r => r.Status == RiskRuleStatus.Active).Select(r => (long)r.id).ToList();
+            if (skippedIds.Any())
+                _logger.Info($"[批量启用规则] 跳过已启用规则 - IDs: {string.Join(",", skippedIds)}");
+
+            rules = rules.Where(r => r.Status != RiskRuleStatus.Active).ToList();
+            if (!rules.Any())
+            {
+                _logger.Info("[批量启用规则] 所有规则均已启用，无需操作");
+                return new BatchOperationResult
+                {
+                    Success = true,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = ruleIds.Count
+                };
+            }
+
+            // 逐条编译校验，任一失败则整体拒绝
+            var errors = new List<string>();
+            foreach (var rule in rules)
+            {
+                var compileResult = RuleCompiler.ValidateAndCompileFormula(rule.id, rule.RuleExpr);
+                if (!compileResult.Success)
+                    errors.Add($"规则'{rule.RuleName}'(ID:{rule.id})：{compileResult.ErrorMessage}");
+            }
+            if (errors.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"规则表达式编译失败：{string.Join("；", errors)}"
+                };
+            }
+
+            foreach (var rule in rules)
+            {
+                _logger.Info($"[批量启用规则] 写入状态 - 规则ID: {rule.id}");
+                rule.Status = RiskRuleStatus.Active;
+                rule.UpdateOptId = UserId;
+                rule.UpdateOptName = UserName;
+                rule.UpdateDate = DateTime.Now;
+            }
+
+            var enabledIds = rules.Select(r => r.id).ToList();
+            WriteAuditLog("RULE_BATCH_ENABLE", "RULE", 0, "",
+                $"批量启用规则(IDs: {string.Join(",", enabledIds)})");
+
+            _logger.Info("[批量启用规则] 保存数据库...");
+            DbContext.SaveChanges();
+            _logger.Info("[批量启用规则] 刷新规则缓存...");
+            foreach (var rule in rules)
+            {
+                RiskEngineService.GetInstance().RefreshOneRuleCache(rule.id);
+            }
+            _logger.Info("[批量启用规则] 完成");
+
+            return new BatchOperationResult
+            {
+                Success = true,
+                TotalCount = ruleIds.Count,
+                SuccessCount = ruleIds.Count
+            };
+        }
+
+        /// <summary>
+        /// 批量停用规则（仅 Active → Disabled，级联停用关联应用）
+        /// </summary>
+        public BatchDisableRulesResult BatchDisableRules(List<long> ruleIds)
+        {
+            if (ruleIds == null || ruleIds.Count == 0)
+                throw new ServiceException("规则ID列表不能为空");
+
+            _logger.Info($"[批量停用规则] 开始 - 传入规则数: {ruleIds.Count}, IDs: {string.Join(",", ruleIds)}");
+
+            var rules = DbContext.glms_risk_rule
+                .Where(r => ruleIds.Contains(r.id) && r.Status != RiskRuleStatus.Deleted)
+                .ToList();
+
+            _logger.Info($"[批量停用规则] DB查询完成 - 匹配到 {rules.Count} 条规则");
+
+            var foundIds = rules.Select(r => (long)r.id).ToList();
+            var missingIds = ruleIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchDisableRulesResult
+                {
+                    Success = false,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"以下规则不存在或已删除：{string.Join(", ", missingIds)}"
+                };
+            }
+
+            // 跳过已停用的规则
+            var skippedIds = rules.Where(r => r.Status == RiskRuleStatus.Disabled).Select(r => (long)r.id).ToList();
+            if (skippedIds.Any())
+                _logger.Info($"[批量停用规则] 跳过已停用规则 - IDs: {string.Join(",", skippedIds)}");
+
+            rules = rules.Where(r => r.Status != RiskRuleStatus.Disabled).ToList();
+            if (!rules.Any())
+            {
+                _logger.Info("[批量停用规则] 所有规则均已停用，无需操作");
+                return new BatchDisableRulesResult
+                {
+                    Success = true,
+                    TotalCount = ruleIds.Count,
+                    SuccessCount = ruleIds.Count
+                };
+            }
+
+            var allCascadedAppIds = new List<long>();
+            foreach (var rule in rules)
+            {
+                _logger.Info($"[批量停用规则] 写入状态 - 规则ID: {rule.id}");
+                rule.Status = RiskRuleStatus.Disabled;
+                rule.UpdateOptId = UserId;
+                rule.UpdateOptName = UserName;
+                rule.UpdateDate = DateTime.Now;
+
+                // 级联停用关联的 Active 应用配置
+                var activeApps = DbContext.glms_risk_rule_application
+                    .Where(a => a.Status == RiskRuleStatus.Active)
+                    .Where(RuleIdsMatchExpr(rule.id))
+                    .ToList();
+
+                var cascadedIds = new List<long>();
+                foreach (var app in activeApps)
+                {
+                    // 同一应用可能同时关联多条待停用规则，只对实际仍为 Active 的应用处理一次。
+                    if (app.Status != RiskRuleStatus.Active)
+                        continue;
+
+                    app.Status = RiskRuleStatus.Disabled;
+                    app.UpdateOptId = UserId;
+                    app.UpdateOptName = UserName;
+                    app.UpdateDate = DateTime.Now;
+                    cascadedIds.Add(app.id);
+
+                    WriteAuditLog("RULE_CASCADE_DISABLE_APP", "APPLICATION", app.id, $"应用{app.id}",
+                        $"因规则'{rule.RuleName}'(ID:{rule.id})停用，应用配置被级联停用");
+                }
+
+                if (cascadedIds.Any())
+                {
+                    _logger.Info($"[批量停用规则] 规则ID: {rule.id}, 级联停用应用: {string.Join(",", cascadedIds)}");
+                    allCascadedAppIds.AddRange(cascadedIds);
+                }
+            }
+
+            var disabledIds = rules.Select(r => r.id).ToList();
+            WriteAuditLog("RULE_BATCH_DISABLE", "RULE", 0, "",
+                $"批量停用规则(IDs: {string.Join(",", disabledIds)})");
+
+            _logger.Info("[批量停用规则] 保存数据库...");
+            DbContext.SaveChanges();
+            _logger.Info("[批量停用规则] 刷新规则缓存...");
+            foreach (var rule in rules)
+            {
+                RiskEngineService.GetInstance().RefreshOneRuleCache(rule.id);
+            }
+            if (allCascadedAppIds.Any())
+                RiskEngineService.GetInstance().RefreshApplication();
+            _logger.Info("[批量停用规则] 完成");
+
+            return new BatchDisableRulesResult
+            {
+                Success = true,
+                TotalCount = ruleIds.Count,
+                SuccessCount = ruleIds.Count,
+                CascadedApplicationIds = allCascadedAppIds
+            };
+        }
+
         /// <summary>
         /// 获取规则关联的应用配置列表
         /// </summary>
@@ -1013,9 +1388,9 @@ namespace YLErp.Modules.RiskEngine
         {
             GetRuleOrThrow(ruleId);
 
-            var ruleIdStr = ruleId.ToString();
             var apps = DbContext.glms_risk_rule_application
-                .Where(a => a.RuleIds.Contains(ruleIdStr) && a.Status != RiskRuleStatus.Deleted)
+                .Where(a => a.Status != RiskRuleStatus.Deleted)
+                .Where(RuleIdsMatchExpr(ruleId))
                 .OrderByDescending(a => a.UpdateDate)
                 .ToList();
 
@@ -1046,18 +1421,19 @@ namespace YLErp.Modules.RiskEngine
         }
 
         /// <summary>
-        /// 获取所有启用规则列表（轻量字段，供下拉选择）
+        /// 获取所有未删除规则列表（轻量字段，供下拉选择）
         /// </summary>
         public List<RiskRuleSimpleItem> GetAllRuleList()
         {
             return DbContext.glms_risk_rule
-                .Where(r => r.Status == RiskRuleStatus.Active)
+                .Where(r => r.Status != RiskRuleStatus.Deleted)
                 .OrderBy(r => r.id)
                 .Select(r => new RiskRuleSimpleItem
                 {
                     Id = r.id,
                     RuleName = r.RuleName,
-                    RuleText = r.RuleText
+                    RuleText = r.RuleText,
+                    Status = r.Status
                 })
                 .ToList();
         }
@@ -1093,8 +1469,12 @@ namespace YLErp.Modules.RiskEngine
             {
                 query = query.Where(a => DbContext.glms_risk_rule
                     .Any(r => r.Status != RiskRuleStatus.Deleted
-                        && a.RuleIds.Contains(r.id.ToString())
-                        && r.RuleName.Contains(req.RuleName)));
+                        && r.RuleName.Contains(req.RuleName)
+                        && a.RuleIds != null
+                        && (a.RuleIds == r.id.ToString()
+                            || a.RuleIds.StartsWith(r.id.ToString() + ",")
+                            || a.RuleIds.EndsWith("," + r.id.ToString())
+                            || a.RuleIds.Contains("," + r.id.ToString() + ","))));
             }
 
             if (!string.IsNullOrWhiteSpace(req.ScopeClientIds))
@@ -1170,7 +1550,8 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         public RiskApplicationDetail CreateApplication(CreateRiskApplicationReq req)
         {
-            var errors = ValidateAndEnsureRuleCache(req.RuleIds);
+            var normalizedRuleIds = NormalizeRuleIds(req.RuleIds);
+            var errors = ValidateAndEnsureRuleCache(normalizedRuleIds);
             if (errors.Any())
                 throw new ServiceException($"以下关联规则不可用：{string.Join("；", errors)}");
             ValidateTriggerPoints(req.TriggerPoints);
@@ -1178,7 +1559,7 @@ namespace YLErp.Modules.RiskEngine
 
             var entity = new glms_risk_rule_application
             {
-                RuleIds = req.RuleIds,
+                RuleIds = normalizedRuleIds,
                 Description = req.Description,
                 Status = RiskRuleStatus.Active,
                 ControlStrategy = req.ControlStrategy,
@@ -1203,7 +1584,7 @@ namespace YLErp.Modules.RiskEngine
                     DbContext.glms_risk_rule_application.Add(entity);
                     DbContext.SaveChanges();
 
-                    WriteAuditLog("APP_CREATE", "APPLICATION", entity.id, ResolveRuleNames(req.RuleIds),
+                    WriteAuditLog("APP_CREATE", "APPLICATION", entity.id, ResolveRuleNames(entity.RuleIds),
                         $"创建应用配置：策略={GetStrategyName(req.ControlStrategy)}, 触发时点={MapTriggerPointsToChinese(req.TriggerPoints)}",
                         snapshotData: JsonConvert.SerializeObject(new { Version = entity.Version }));
                     DbContext.SaveChanges();
@@ -1232,9 +1613,11 @@ namespace YLErp.Modules.RiskEngine
             if (app.Version != req.Version)
                 throw new ServiceException("应用配置已被其他用户修改，请重新加载后再编辑");
 
+            string normalizedRuleIds = null;
             if (!string.IsNullOrWhiteSpace(req.RuleIds))
             {
-                var errors = ValidateAndEnsureRuleCache(req.RuleIds);
+                normalizedRuleIds = NormalizeRuleIds(req.RuleIds);
+                var errors = ValidateAndEnsureRuleCache(normalizedRuleIds);
                 if (errors.Any())
                     throw new ServiceException($"以下关联规则不可用：{string.Join("；", errors)}");
             }
@@ -1250,8 +1633,8 @@ namespace YLErp.Modules.RiskEngine
             };
             ValidateScopeFields(scopeReq);
 
-            if (!string.IsNullOrWhiteSpace(req.RuleIds))
-                app.RuleIds = req.RuleIds;
+            if (normalizedRuleIds != null)
+                app.RuleIds = normalizedRuleIds;
             app.Description = req.Description;
             app.ControlStrategy = req.ControlStrategy;
             app.TriggerPoints = req.TriggerPoints;
@@ -1293,6 +1676,63 @@ namespace YLErp.Modules.RiskEngine
             RiskEngineService.GetInstance().RefreshApplication();
         }
 
+        /// <summary>
+        /// 批量删除应用配置（软删除）
+        /// </summary>
+        public BatchOperationResult BatchDeleteApplications(List<long> applicationIds)
+        {
+            if (applicationIds == null || applicationIds.Count == 0)
+                throw new ServiceException("应用配置ID列表不能为空");
+
+            _logger.Info($"[批量删除应用] 开始 - 传入应用数: {applicationIds.Count}, IDs: {string.Join(",", applicationIds)}");
+
+            var apps = DbContext.glms_risk_rule_application
+                .Where(a => applicationIds.Contains(a.id) && a.Status != RiskRuleStatus.Deleted)
+                .ToList();
+
+            _logger.Info($"[批量删除应用] DB查询完成 - 匹配到 {apps.Count} 条应用");
+
+            var foundIds = apps.Select(a => (long)a.id).ToList();
+            var missingIds = applicationIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = applicationIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"以下应用配置不存在或已删除：{string.Join(", ", missingIds)}"
+                };
+            }
+
+            foreach (var app in apps)
+            {
+                _logger.Info($"[批量删除应用] 写入状态 - 应用ID: {app.id}");
+                app.Status = RiskRuleStatus.Deleted;
+                app.Version = app.Version + 1;
+                app.UpdateOptId = UserId;
+                app.UpdateOptName = UserName;
+                app.UpdateDate = DateTime.Now;
+            }
+
+            var deletedIds = apps.Select(a => a.id).ToList();
+            WriteAuditLog("APP_BATCH_DELETE", "APPLICATION", 0, "",
+                $"批量删除应用配置(IDs: {string.Join(",", deletedIds)})");
+
+            _logger.Info("[批量删除应用] 保存数据库...");
+            DbContext.SaveChanges();
+            _logger.Info("[批量删除应用] 刷新应用缓存...");
+            RiskEngineService.GetInstance().RefreshApplication();
+            _logger.Info("[批量删除应用] 完成");
+
+            return new BatchOperationResult
+            {
+                Success = true,
+                TotalCount = applicationIds.Count,
+                SuccessCount = applicationIds.Count
+            };
+        }
+
         /// <summary>
         /// 启用应用配置（校验关联规则状态）
         /// </summary>
@@ -1342,16 +1782,46 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         public BatchOperationResult BatchEnableApplications(List<long> applicationIds)
         {
-            _logger.Info($"[批量启用] 开始 - 传入应用数: {applicationIds?.Count ?? 0}, IDs: {string.Join(",", applicationIds ?? new List<long>())}");
+            if (applicationIds == null || applicationIds.Count == 0)
+                throw new ServiceException("应用配置ID列表不能为空");
+
+            _logger.Info($"[批量启用] 开始 - 传入应用数: {applicationIds.Count}, IDs: {string.Join(",", applicationIds)}");
 
             var apps = DbContext.glms_risk_rule_application
-                .Where(a => applicationIds.Contains(a.id) && a.Status == RiskRuleStatus.Disabled)
+                .Where(a => applicationIds.Contains(a.id))
                 .ToList();
 
-            _logger.Info($"[批量启用] DB查询完成 - 匹配到 {apps.Count} 条已停用应用");
+            _logger.Info($"[批量启用] DB查询完成 - 匹配到 {apps.Count} 条应用");
 
-            if (apps.Count != applicationIds.Count)
-                throw new ServiceException("部分应用配置不存在或当前状态不允许启用");
+            var foundIds = apps.Select(a => (long)a.id).ToList();
+            var missingIds = applicationIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = applicationIds.Count,
+                    SuccessCount = 0,
+                    ErrorMessage = $"以下应用配置不存在：{string.Join(", ", missingIds)}"
+                };
+            }
+
+            // 跳过已启用的应用，只处理已停用的
+            var skippedIds = apps.Where(a => a.Status == RiskRuleStatus.Active).Select(a => (long)a.id).ToList();
+            if (skippedIds.Any())
+                _logger.Info($"[批量启用] 跳过已启用应用 - IDs: {string.Join(",", skippedIds)}");
+
+            apps = apps.Where(a => a.Status != RiskRuleStatus.Active).ToList();
+            if (!apps.Any())
+            {
+                _logger.Info("[批量启用] 所有应用均已启用，无需操作");
+                return new BatchOperationResult
+                {
+                    Success = true,
+                    TotalCount = applicationIds.Count,
+                    SuccessCount = applicationIds.Count
+                };
+            }
 
             var allErrors = new List<string>();
             foreach (var app in apps)
@@ -1360,7 +1830,7 @@ namespace YLErp.Modules.RiskEngine
                 var errors = ValidateAndEnsureRuleCache(app.RuleIds);
                 _logger.Info($"[批量启用] 规则校验结果 - 应用ID: {app.id}, Errors: {(errors.Any() ? string.Join(";", errors) : "无")}");
                 if (errors.Any())
-                    allErrors.Add($"应用 '{app.Description}'：{string.Join("；", errors)}");
+                    allErrors.Add($"应用 '{app.id}'：{string.Join("；", errors)}");
             }
 
             if (allErrors.Any())
@@ -1404,7 +1874,10 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         public BatchOperationResult BatchDisableApplications(List<long> applicationIds)
         {
-            _logger.Info($"[批量停用] 开始 - 传入应用数: {applicationIds?.Count ?? 0}, IDs: {string.Join(",", applicationIds ?? new List<long>())}");
+            if (applicationIds == null || applicationIds.Count == 0)
+                throw new ServiceException("应用配置ID列表不能为空");
+
+            _logger.Info($"[批量停用] 开始 - 传入应用数: {applicationIds.Count}, IDs: {string.Join(",", applicationIds)}");
 
             var apps = DbContext.glms_risk_rule_application
                 .Where(a => applicationIds.Contains(a.id) && a.Status == RiskRuleStatus.Active)
@@ -1412,8 +1885,18 @@ namespace YLErp.Modules.RiskEngine
 
             _logger.Info($"[批量停用] DB查询完成 - 匹配到 {apps.Count} 条已启用应用");
 
-            if (apps.Count != applicationIds.Count)
-                throw new ServiceException("部分应用配置不存在或当前状态不允许停用");
+            var foundIds = apps.Select(a => (long)a.id).ToList();
+            var missingIds = applicationIds.Except(foundIds).ToList();
+            if (missingIds.Any())
+            {
+                return new BatchOperationResult
+                {
+                    Success = false,
+                    TotalCount = applicationIds.Count,
+                    SuccessCount = apps.Count,
+                    ErrorMessage = $"以下应用配置不存在或当前状态不允许停用：{string.Join(", ", missingIds)}"
+                };
+            }
 
             foreach (var app in apps)
             {
@@ -1660,16 +2143,15 @@ namespace YLErp.Modules.RiskEngine
                             rule.UpdateOptId = UserId;
                             rule.UpdateOptName = UserName;
                             rule.UpdateDate = DateTime.Now;
+
+                            WriteAuditLog("VAR_CASCADE_UPDATE_RULE", "RULE", rule.id, rule.RuleName,
+                                $"因变量'{variable.VariableName}'(ID:{variableId})表达式变更，规则表达式被级联更新");
                         }
 
                         DbContext.SaveChanges();
 
                         WriteAuditLog("VAR_UPDATE", "VARIABLE", variableId, req.VariableName, $"修改变量：{variable.VariableName}");
 
-                        var cascadedRuleIds = affectedRules.Select(r => r.id.ToString()).ToList();
-                        WriteAuditLog("VAR_UPDATE_CASCADE", "VARIABLE", variableId, req.VariableName,
-                            $"变量 [{variable.VariableName}] VariableExpr 变更，级联更新规则 {string.Join("、", cascadedRuleIds)}");
-
                         DbContext.SaveChanges();
                         transaction.Commit();
                     }
@@ -1746,6 +2228,11 @@ namespace YLErp.Modules.RiskEngine
         /// 查询审计日志列表（分页）
         /// </summary>
         public SearchListResult<RiskAuditLogListItem> QueryAuditLogs(QueryRiskAuditLogReq req)
+        {
+            return BuildAuditLogQuery(req).ToSearchList(req);
+        }
+
+        private IQueryable<RiskAuditLogListItem> BuildAuditLogQuery(QueryRiskAuditLogReq req)
         {
             var query = DbContext.glms_risk_rule_audit_log.AsQueryable();
 
@@ -1806,7 +2293,55 @@ namespace YLErp.Modules.RiskEngine
                     OptDate = l.OptDate
                 });
 
-            return result.ToSearchList(req);
+            return result;
+        }
+
+        /// <summary>
+        /// 根据查询条件生成审计日志导出文件名
+        /// </summary>
+        public string BuildAuditLogExportFileName(QueryRiskAuditLogReq req)
+        {
+            req ??= new QueryRiskAuditLogReq();
+            var conditions = new List<string>();
+
+            var operationTypes = new List<string>();
+            if (!string.IsNullOrWhiteSpace(req.OperationType))
+                operationTypes.Add(req.OperationType.Trim());
+            if (!string.IsNullOrWhiteSpace(req.OperationTypes))
+            {
+                operationTypes.AddRange(req.OperationTypes.Split(',',
+                    StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries));
+            }
+            var operationTypeNames = operationTypes
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .Select(GetAuditOperationTypeName)
+                .ToList();
+            if (operationTypeNames.Any())
+                conditions.Add($"操作类型-{string.Join("+", operationTypeNames)}");
+
+            if (!string.IsNullOrWhiteSpace(req.TargetType))
+                conditions.Add($"目标类型-{GetAuditTargetTypeName(req.TargetType)}");
+            if (!string.IsNullOrWhiteSpace(req.TargetName))
+                conditions.Add($"目标名称-{SanitizeFileNamePart(req.TargetName)}");
+            if (!string.IsNullOrWhiteSpace(req.OptName))
+                conditions.Add($"操作人-{SanitizeFileNamePart(req.OptName)}");
+
+            if (req.StartDate.HasValue && req.EndDate.HasValue)
+                conditions.Add($"日期-{req.StartDate.Value:yyyyMMdd}至{req.EndDate.Value:yyyyMMdd}");
+            else if (req.StartDate.HasValue)
+                conditions.Add($"开始日期-{req.StartDate.Value:yyyyMMdd}");
+            else if (req.EndDate.HasValue)
+                conditions.Add($"结束日期-{req.EndDate.Value:yyyyMMdd}");
+
+            if (!string.IsNullOrWhiteSpace(req.Keyword))
+                conditions.Add($"关键词-{SanitizeFileNamePart(req.Keyword)}");
+
+            var suffix = conditions.Any() ? string.Join("_", conditions) : "全部";
+            var fileNameWithoutExtension = $"风控操作日志_{suffix}";
+            if (fileNameWithoutExtension.Length > 180)
+                fileNameWithoutExtension = fileNameWithoutExtension.Substring(0, 180);
+
+            return $"{fileNameWithoutExtension}.xlsx";
         }
 
         /// <summary>
@@ -1814,7 +2349,28 @@ namespace YLErp.Modules.RiskEngine
         /// </summary>
         public byte[] ExportAuditLogs(QueryRiskAuditLogReq req)
         {
-            throw new ServiceException("导出功能暂未实现");
+            var logs = BuildAuditLogQuery(req).ToList();
+            var columns = new List<ExcelHelper.DataColumnModel>
+            {
+                new ExcelHelper.DataColumnModel("日志ID", "Id", typeof(string),
+                    (value, _) => FormatAuditId(value)),
+                new ExcelHelper.DataColumnModel("操作类型", "OperationType", typeof(string),
+                    (value, _) => GetAuditOperationTypeName(value?.ToString())),
+                new ExcelHelper.DataColumnModel("目标类型", "TargetType", typeof(string),
+                    (value, _) => GetAuditTargetTypeName(value?.ToString())),
+                new ExcelHelper.DataColumnModel("目标ID", "TargetId", typeof(string),
+                    (value, _) => FormatAuditId(value)),
+                new ExcelHelper.DataColumnModel("目标名称", "TargetName", typeof(string)),
+                new ExcelHelper.DataColumnModel("操作详情", "OperationDetail", typeof(string)),
+                new ExcelHelper.DataColumnModel("操作结果", "Result", typeof(string)),
+                new ExcelHelper.DataColumnModel("操作人", "OptName", typeof(string)),
+                new ExcelHelper.DataColumnModel("操作时间", "OptDate", (value, _) =>
+                    value == null ? string.Empty : ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"))
+            };
+
+            new ExcelHelper().ListToExcel<RiskAuditLogListItem>(
+                columns.ToArray(), logs, "风控操作日志", true, out var buffer);
+            return buffer;
         }
 
         /// <summary>

YLErpDAL/Modules/SwapModule/SwapDealService.cs

@@ -267,9 +267,7 @@ namespace YLErp.Modules.SwapModule
                 // 占期初(original)语义(A)：默认"平掉剩余全部持仓" = 剩余名义本金/期初名义本金。
                 // 未平仓时 PosiNotionalValue==NotionalValue → 1（平100%）；部分平仓后自动变为剩余比例（如已平10%则默认90%）。
                 // 与互换/提前终止 InitIncome(L447) 保持一致。
-                unwindData.ClosePercent = unwindData.NotionalValue > 0
-                    ? unwindData.PosiNotionalValue / unwindData.NotionalValue
-                    : 1;
+                unwindData.ClosePercent = CalcDefaultInitClosePercent(unwindData.NotionalValue, unwindData.PosiNotionalValue);
                 unwindData.CloseNotionalValue = unwindData.PosiNotionalValue;
                 unwindData.CloseQty = unwindData.PositionQty;
                 if (position != null)
@@ -755,6 +753,18 @@ namespace YLErp.Modules.SwapModule
             return remainingClosePercent * posiNotionalValue / notionalValue;
         }
 
+        /// <summary>
+        /// 计算 InitUnwind 默认占期初(A)平仓比例 = "平掉剩余全部持仓"对应的占期初比例。
+        /// 即：ClosePercent(A) = PosiNotionalValue / NotionalValue。
+        /// 未平仓时 PosiNotionalValue==NotionalValue → 1（平100%）；
+        /// 部分平仓后自动变为剩余比例（如已平 30% 则默认 0.7）。
+        /// 与互换/提前终止 InitIncome 保持一致。抽出为纯函数以支持无库单测。
+        /// </summary>
+        public static decimal CalcDefaultInitClosePercent(decimal notionalValue, decimal posiNotionalValue)
+        {
+            return notionalValue > 0 ? posiNotionalValue / notionalValue : 1;
+        }
+
         /// <summary>
         /// 获取固定利率
         /// </summary>

YLErpDAL/Modules/SwapModule/SwapEodPositionService.cs

@@ -2069,11 +2069,12 @@ namespace YLErp.Modules.SwapModule
         /// 浮动腿及普通利息腿维持数据库记录的方向；初始/追加预付金腿的利息
         /// 则与保证金本金方向相反。这样“收取对手方保证金”产生的利息会作为
         /// 我方支付给对手方的成本计入，而不会错误增加框架合约已实现收益。
+        /// 抽为静态纯函数以支持无库单测（marginTypes 等价于 ConsTrade.InterestMarginModels）。
         /// </summary>
-        private decimal CalculateSwapRealizedPnl(eod_swap_position position)
+        public static decimal CalculateSwapRealizedPnl(eod_swap_position position)
         {
             var interestRatio = position.InterestDirection == (int)SwapDirectionEnum.收取 ? 1m : -1m;
-            if (marginTypes.Contains(position.InterestMode))
+            if (ConsTrade.InterestMarginModels.Contains(position.InterestMode))
             {
                 interestRatio = -interestRatio;
             }

YLErpDAL/Modules/TradeModule/TradeServiceBase.cs

@@ -1,4 +1,4 @@
-using BaseOUDAL;
+using BaseOUDAL;
 using YLErp.BLL;
 using YLErp.DBModels.Consts;
 using YLErp.DBModels.Enums;
@@ -210,18 +210,7 @@ namespace YLErp.Modules.TradeModule
                             && (x.EventType == (int)SwapEventTypeEnum.平仓 || x.EventType == (int)SwapEventTypeEnum.互换))
                         .OrderByDescending(x => x.id)
                         .FirstOrDefault();
-                    if (swapEvent != null && !string.IsNullOrEmpty(swapEvent.EventData))
-                    {
-                        try
-                        {
-                            var unwindData = Newtonsoft.Json.JsonConvert.DeserializeObject<UnwindData>(swapEvent.EventData);
-                            if (unwindData != null)
-                            {
-                                ctx.CurrentNotional = Math.Abs((double)unwindData.CloseNotionalValue);
-                            }
-                        }
-                        catch { }
-                    }
+                    ctx.CurrentNotional = CalcSwapCloseNotionalFromEventData(swapEvent?.EventData);
                 }
                 else
                 {
@@ -230,15 +219,41 @@ namespace YLErp.Modules.TradeModule
                         .Where(t => t.TradeId == td.id && t.ValidState == ConsGlobal.InValid && !t.IsDeleted)
                         .OrderByDescending(t => t.id)
                         .FirstOrDefault();
-                    if (tc != null && tc.UnwindPercentRate.HasValue && td.OriginalStockEqvNotional.HasValue)
-                    {
-                        ctx.CurrentNotional = Math.Abs(td.OriginalStockEqvNotional.Value * tc.UnwindPercentRate.Value);
-                    }
+                    ctx.CurrentNotional = CalcOptionCloseNotional(td.OriginalStockEqvNotional, tc?.UnwindPercentRate);
                 }
             }
             return ctx;
         }
 
+        /// <summary>
+        /// 互换：从 swap_event.EventData(JSON) 反序列化取 CloseNotionalValue 绝对值。
+        /// 容错：EventData 为 null/空/非法 JSON / unwindData=null 时返回 0（不影响审批阈值判断）。
+        /// 抽为静态纯函数以支持无库单测。
+        /// </summary>
+        public static double CalcSwapCloseNotionalFromEventData(string eventData)
+        {
+            if (string.IsNullOrEmpty(eventData)) return 0;
+            try
+            {
+                var unwindData = Newtonsoft.Json.JsonConvert.DeserializeObject<UnwindData>(eventData);
+                return unwindData != null ? Math.Abs((double)unwindData.CloseNotionalValue) : 0;
+            }
+            catch
+            {
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// 期权：当次平仓名义本金 = 期初名义本金 × 平仓比例(UnwindPercentRate)，取绝对值。
+        /// 容错：任一参数为 null 时返回 0。抽为静态纯函数以支持无库单测。
+        /// </summary>
+        public static double CalcOptionCloseNotional(double? originalStockEqvNotional, double? unwindPercentRate)
+        {
+            if (!originalStockEqvNotional.HasValue || !unwindPercentRate.HasValue) return 0;
+            return Math.Abs(originalStockEqvNotional.Value * unwindPercentRate.Value);
+        }
+
         /// <summary>
         /// 需求①：判断按触发条件是否需要审批。
         /// <para>取该交易类别的审批流程，若所有节点配置的触发条件都不满足当前业务，则无需审批（返回 false）。</para>

YLErpWeb/Controllers/RiskRuleController.cs

@@ -151,12 +151,14 @@ namespace YLErp.Web.Controllers
         [HttpDelete("risk-rules/batch")]
         [MyAuthorize("风险控制-风控规则删除")]
         /// <summary>批量删除风控规则</summary>
-        public async Task<JsonResult> BatchDeleteRiskRules([FromBody] List<long> ids)
+        public async Task<JsonResult> BatchDeleteRiskRules([FromBody] BatchIdsReq req)
         {
             try
             {
                 var service = GetRiskRuleService();
-                var result = await Task.Run(() => service.BatchDeleteRules(ids));
+                var result = await Task.Run(() => service.BatchDeleteRules(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
                 return Json(new { success = true, data = result });
             }
             catch (ServiceException ex)
@@ -200,8 +202,13 @@ namespace YLErp.Web.Controllers
             try
             {
                 var service = GetRiskRuleService();
-                await Task.Run(() => service.DisableRule(id));
-                return Json(new { success = true });
+                var result = await Task.Run(() => service.DisableRule(id));
+                return Json(new
+                {
+                    success = true,
+                    cascadedAppIds = result.CascadedApplicationIds,
+                    cascadedAppCount = result.CascadedApplicationIds.Count
+                });
             }
             catch (ServiceException ex)
             {
@@ -214,6 +221,60 @@ namespace YLErp.Web.Controllers
             }
         }
 
+        [HttpPost("risk-rules/batch-enable")]
+        [MyAuthorize("风险控制-风控规则启停")]
+        /// <summary>批量启用风控规则</summary>
+        public async Task<JsonResult> BatchEnableRiskRules([FromBody] BatchIdsReq req)
+        {
+            try
+            {
+                var service = GetRiskRuleService();
+                var result = await Task.Run(() => service.BatchEnableRules(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
+                return Json(new { success = true, data = result });
+            }
+            catch (ServiceException ex)
+            {
+                return Json(new { success = false, message = ex.Message });
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex, "批量启用风控规则");
+                return Json(new { success = false, message = "系统异常，请联系管理员" });
+            }
+        }
+
+        [HttpPost("risk-rules/batch-disable")]
+        [MyAuthorize("风险控制-风控规则启停")]
+        /// <summary>批量停用风控规则</summary>
+        public async Task<JsonResult> BatchDisableRiskRules([FromBody] BatchIdsReq req)
+        {
+            try
+            {
+                var service = GetRiskRuleService();
+                var result = await Task.Run(() => service.BatchDisableRules(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
+                return Json(new
+                {
+                    success = true,
+                    data = result,
+                    cascadedAppIds = result.CascadedApplicationIds,
+                    cascadedAppCount = result.CascadedApplicationIds.Count
+                });
+            }
+            catch (ServiceException ex)
+            {
+                return Json(new { success = false, message = ex.Message });
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex, "批量停用风控规则");
+                return Json(new { success = false, message = "系统异常，请联系管理员" });
+            }
+        }
+
         [HttpGet("risk-rules/{id}/applications")]
         [MyAuthorize("风险控制-风控规则查看")]
         /// <summary>获取规则关联的应用配置列表</summary>
@@ -238,7 +299,7 @@ namespace YLErp.Web.Controllers
 
         [HttpGet("risk-rules/list")]
         [MyAuthorize("风险控制-风控规则查看")]
-        /// <summary>获取所有启用规则列表（供下拉选择）</summary>
+        /// <summary>获取所有未删除规则列表（供下拉选择）</summary>
         public async Task<JsonResult> GetAllRiskRules()
         {
             try
@@ -419,12 +480,14 @@ namespace YLErp.Web.Controllers
         [HttpPost("risk-applications/batch-enable")]
         [MyAuthorize("风险控制-风控应用启停")]
         /// <summary>批量启用应用配置</summary>
-        public async Task<JsonResult> BatchEnableRiskApplications([FromBody] List<long> ids)
+        public async Task<JsonResult> BatchEnableRiskApplications([FromBody] BatchIdsReq req)
         {
             try
             {
                 var service = GetRiskRuleService();
-                var result = await Task.Run(() => service.BatchEnableApplications(ids));
+                var result = await Task.Run(() => service.BatchEnableApplications(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
                 return Json(new { success = true, data = result });
             }
             catch (ServiceException ex)
@@ -441,12 +504,14 @@ namespace YLErp.Web.Controllers
         [HttpPost("risk-applications/batch-disable")]
         [MyAuthorize("风险控制-风控应用启停")]
         /// <summary>批量停用应用配置</summary>
-        public async Task<JsonResult> BatchDisableRiskApplications([FromBody] List<long> ids)
+        public async Task<JsonResult> BatchDisableRiskApplications([FromBody] BatchIdsReq req)
         {
             try
             {
                 var service = GetRiskRuleService();
-                var result = await Task.Run(() => service.BatchDisableApplications(ids));
+                var result = await Task.Run(() => service.BatchDisableApplications(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
                 return Json(new { success = true, data = result });
             }
             catch (ServiceException ex)
@@ -460,6 +525,30 @@ namespace YLErp.Web.Controllers
             }
         }
 
+        [HttpDelete("risk-applications/batch")]
+        [MyAuthorize("风险控制-风控应用删除")]
+        /// <summary>批量删除应用配置</summary>
+        public async Task<JsonResult> BatchDeleteRiskApplications([FromBody] BatchIdsReq req)
+        {
+            try
+            {
+                var service = GetRiskRuleService();
+                var result = await Task.Run(() => service.BatchDeleteApplications(req?.Ids));
+                if (!result.Success)
+                    return Json(new { success = false, message = result.ErrorMessage });
+                return Json(new { success = true, data = result });
+            }
+            catch (ServiceException ex)
+            {
+                return Json(new { success = false, message = ex.Message });
+            }
+            catch (Exception ex)
+            {
+                _logger.Error(ex, "批量删除应用配置");
+                return Json(new { success = false, message = "系统异常，请联系管理员" });
+            }
+        }
+
         #endregion
 
         #region Variable Management
@@ -683,7 +772,8 @@ namespace YLErp.Web.Controllers
             {
                 var service = GetRiskRuleService();
                 var bytes = await Task.Run(() => service.ExportAuditLogs(req));
-                return File(bytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "风控操作日志.xlsx");
+                var fileName = service.BuildAuditLogExportFileName(req);
+                return File(bytes, xlsxMimeType, fileName);
             }
             catch (ServiceException ex)
             {