Merge branch 'glms/feature/1.4.2_ApprovalProcess' into glms/feature/1.4.2

2026-07-14 09:14:07 +08:00
parent 18ba0271ec f3ca4dc498
commit 623183f47f
15 changed files with 2270 additions and 285 deletions
@@ -1,4 +1,5 @@
 using YLErp.BLL;
+using YLErp.Helpers;
 using YLErp.Model;
 using YLErp.Model.Enum;
 using YLErp.Modules.TradeDalModule;
@@ -115,25 +116,35 @@ namespace YLErp.Modules.TradeModule.DealModule
            td.OptId = UserId;
            td.OptName = UserName;
            td.OptDate = OptDate;
-            if (isFromExercise)
-            {
-                td.TradeStatus = ConsTrade.行权待复核;
-            }
-            else
-            {
-                td.TradeStatus = ConsTrade.平仓待复核;
-            }

            td.CheckStatus = Convert.ToInt32(TradeCheckEnum.StatusOfOld);

-            //检查是否有交易审批流程
-            if (valuedateBLL.SystemDate.CloseReApprove == 1 && hasTradeProcess)
+            // 先设状态，使流程类别能正确推断为 CloseProcess（需求②按交易状态推断开仓/了结）
+            td.TradeStatus = isFromExercise ? ConsTrade.行权待复核 : ConsTrade.平仓待复核;
+
+            //检查是否有交易审批流程（需求②：平仓/行权按交易状态查对应流程，而非只查开仓流程）
+            var needApproval = valuedateBLL.SystemDate.CloseReApprove == 1 && TradeProcessCountByCategory(td) > 0;
+            if (needApproval)
            {
-                // 如果有审批组
-                InitTradeProcessOrder(td, UserId);
+                // 需求①：进入审批前先判断触发条件——若所有节点都不满足触发条件，跳过审批。
+                needApproval = NeedApprovalByTrigger(td);
            }

-            AddTradeOperationHistoryAndSetParentTradeInfo(false, td, isFromExercise ? "部分行权审核提交" : "平仓审核提交");
+            if (needApproval)
+            {
+                // 需要审批：保持"平仓待复核/行权待复核"，进入审批流程等待人工审批
+                InitTradeProcessOrder(td, UserId);
+                AddTradeOperationHistoryAndSetParentTradeInfo(false, td, isFromExercise ? "部分行权审核提交" : "平仓审核提交");
+            }
+            else
+            {
+                // 不需要审批：直接走平仓完成流程（与审批通过一致）
+                td.ProcessOrderId = ProcessTradeLog.审批通过;
+                td.ProcessStatus = ProcessTradeStatus.通过审批.ToString();
+                td.ProcessOptDate = DateTime.Now;
+                // 直接完成平仓
+                new TradeUnwindService(this).UnwindTrade(td, null, true, isFromExercise);
+            }
        }
    }

@@ -1,4 +1,5 @@
 using YLErp.BLL;
+using YLErp.Helpers;
 using YLErp.Model;
 using YLErp.Model.Enum;

@@ -105,12 +106,33 @@ namespace YLErp.Modules.TradeModule.DealModule
        {
            var td = DbContext.trade.Find(tradeId);
            td.OptDate = DateTime.Now;
-            td.TradeStatus = ConsTrade.行权待复核;
            td.CheckStatus = Convert.ToInt32(TradeCheckEnum.StatusOfOld);
-            if (valuedateBLL.SystemDate.CloseReApprove == 1 && hasTradeProcess)
+
+            // 先设状态，使流程类别能正确推断为 CloseProcess
+            td.TradeStatus = ConsTrade.行权待复核;
+
+            // 需求②：行权按交易状态查对应流程
+            var needApproval = valuedateBLL.SystemDate.CloseReApprove == 1 && TradeProcessCountByCategory(td) > 0;
+            if (needApproval)
            {
-                //如果有审批组
-                InitTradeProcessOrder(td,UserId);
+                // 需求①：进入审批前先判断触发条件——若所有节点都不满足触发条件，跳过审批。
+                needApproval = NeedApprovalByTrigger(td);
+            }
+
+            if (needApproval)
+            {
+                // 需要审批：保持"行权待复核"，进入审批流程等待人工审批
+                InitTradeProcessOrder(td, UserId);
+            }
+            else
+            {
+                // 不需要审批：直接完成行权
+                td.ProcessOrderId = ProcessTradeLog.审批通过;
+                td.ProcessStatus = ProcessTradeStatus.通过审批.ToString();
+                td.ProcessOptDate = DateTime.Now;
+                DbContext.SaveChanges();
+                new TradeUnwindService(this).UnwindTrade(td, null, true, true);
+                return;
            }

            DbContext.SaveChanges();
@@ -1,6 +1,7 @@
 using BaseOUDAL;
 using YLErp.BLL;
 using YLErp.BLL.Eod;
+using YLErp.Helpers;
 using YLErp.Model;
 using YLErp.Model.Enum;
 using YLErp.Modules.ClientModule;
@@ -140,7 +141,8 @@ namespace YLErp.Modules.TradeModule.DealModule
                return result;
            }
            //TODO 如果是审批组
-            var tradeProessQuery = TradeProcess();
+            // 需求②：按交易状态推断开仓/了结流程。了结类(平仓/行权/互换待复核)走 CloseProcess。
+            var tradeProessQuery = TradeProcessByCategory(td);
            var count = tradeProessQuery.Count();
            if (count == 0 || td.ProcessOrderId == ProcessTradeLog.审批通过)//投资规模校验已经将数据设置为已通过
            {
@@ -166,6 +168,8 @@ namespace YLErp.Modules.TradeModule.DealModule
            //{
            //    td.ProcessOrderBranch = 0;
            //}
+            // 节点触发条件(需求①)：下一节点配置了 triggerCondition 时，满足才进入审批，不满足则跳过。
+            nextOrder = AdvanceThroughTriggerNodes(tradeProessQuery, nextOrder, BuildTriggerContext(td, UserId));
            if (nextOrder==null)
            {

@@ -225,7 +229,8 @@ namespace YLErp.Modules.TradeModule.DealModule
            var childrenTrades = DbContext.trade.Where(x => childrenTradeIds.Contains(x.id)).ToList();
            var result = new TradeOpenResult(td);
            // 如果是审批组
-            var tradeProessQuery = TradeProcess();
+            // 需求②：分组了结按交易状态推断开仓/了结流程。
+            var tradeProessQuery = TradeProcessByCategory(td);
            var count = tradeProessQuery.Count();
            if (count == 0)
            {
@@ -246,6 +251,8 @@ namespace YLErp.Modules.TradeModule.DealModule
            {
                nextOrder = tradeProessQuery.FirstOrDefault(x => x.order > td.ProcessOrderId && x.node == td.ProcessOrderBranch && x.approvalGroupId == 0);
            }
+            // 节点触发条件(需求①)：分组了结推进同样支持触发条件。
+            nextOrder = AdvanceThroughTriggerNodes(tradeProessQuery, nextOrder, BuildTriggerContext(td, UserId));
            if (nextOrder == null)
            {
                SetParentTradeOpen(req, td, childrenTrades, parentTradeCash);
@@ -294,8 +294,8 @@ namespace YLErp.Modules.TradeModule.DealModule

                }
                var result = new TradeUnwindResultModel(td);
-                //存在审批流程时，走审批成功流程
-                if (valuedateBLL.SystemDate.CloseReApprove == 1 && HasTradeProcess())
+                //存在审批流程时，走审批成功流程（需求②：按交易状态查对应流程）
+                if (valuedateBLL.SystemDate.CloseReApprove == 1 && TradeProcessCountByCategory(td) > 0)
                {
                    result.ApprovalProcess = true;

@@ -462,8 +462,8 @@ namespace YLErp.Modules.TradeModule.DealModule
                        throw new ServiceException("平仓费不一致！复核不通过");
                    }
                }
-                //存在审批流程时，走审批成功流程
-                if (valuedateBLL.SystemDate.CloseReApprove == 1 && HasTradeProcess())
+                //存在审批流程时，走审批成功流程（需求②：按交易状态查对应流程）
+                if (valuedateBLL.SystemDate.CloseReApprove == 1 && TradeProcessCountByCategory(td) > 0)
                {
                    var reqModel = new TradeOpenReqModel
                    {
@@ -3079,6 +3079,8 @@ namespace YLErp.BLL
            //如果是审批组
            var approvalprocessQuery = db.approvalprocess.Where(a => a.processType == "TradeProcess");
            var tradeOpenProcessOrder = approvalprocessQuery.Count();
+            // 需求②：了结流程节点数（用于平仓/行权/互换交易展示正确的审批进度）
+            var closeProcessOrder = db.approvalprocess.Count(a => a.processType == "CloseProcess");
            var branch = approvalprocessQuery.FirstOrDefault(x => x.approvalGroupId != 0);//审批流程有分支情况
            var firstBranch = approvalprocessQuery.Where(x => (x.node == 1 && x.approvalGroupId == 0) || x.node == 0);//分支一总流程
            var secondBranch = approvalprocessQuery.Where(x => (x.node == 2 && x.approvalGroupId == 0) || x.node == 0);//分支二总流程
@@ -3286,7 +3288,7 @@ namespace YLErp.BLL
            IQueryable<TradeLinq> query = null;
            if (branch == null)
            {
-                query = GetTradeLinqQuery(predicate, approvalprocessQuery, tradeOpenProcessOrder, 0);
+                query = GetTradeLinqQuery(predicate, approvalprocessQuery, tradeOpenProcessOrder, 0, closeProcessOrder);
            }
            else
            {
@@ -3302,8 +3304,8 @@ namespace YLErp.BLL
                {
                    nodeArr.Add(approvalConditionSecend.node);
                }
-                query = GetTradeLinqQuery(predicate, firstBranch, firstCount, 1, branchIndex, nodeArr);
-                var secondQuery = GetTradeLinqQuery(predicate, secondBranch, secondCount, 2, branchIndex, nodeArr);
+                query = GetTradeLinqQuery(predicate, firstBranch, firstCount, 1, branchIndex, nodeArr, closeProcessOrder);
+                var secondQuery = GetTradeLinqQuery(predicate, secondBranch, secondCount, 2, branchIndex, nodeArr, closeProcessOrder);
                query = query.Union(secondQuery);
            }

@@ -3317,7 +3319,7 @@ namespace YLErp.BLL
            query = query.OrderByDescending(s => s.OptDate);
            return query;
        }
-        private IQueryable<TradeLinq> GetTradeLinqQuery(Expression<Func<trade, bool>> predicate, IQueryable<approvalprocess> approvalprocessQuery, int tradeOpenProcessOrder, int branchOrder)
+        private IQueryable<TradeLinq> GetTradeLinqQuery(Expression<Func<trade, bool>> predicate, IQueryable<approvalprocess> approvalprocessQuery, int tradeOpenProcessOrder, int branchOrder, int closeProcessOrder = 0)
        {
            var query = from source in db.trade.Where(predicate)
                        join process in approvalprocessQuery on source.ProcessOrderId equals process.order into pro
@@ -3369,7 +3371,7 @@ namespace YLErp.BLL
                            OptId = source.OptId,
                            OptName = source.OptName,
                            OptDate = source.OptDate,
-                            ProcessStatus = source.ProcessStatus == "审批中" ? source.ProcessStatus + " 流程" + (branchOrder != 0 && source.ProcessOrderId > branchOrder ? source.ProcessOrderId - 2 : source.ProcessOrderId - 1) + "/" + tradeOpenProcessOrder : source.ProcessStatus,
+                            ProcessStatus = source.ProcessStatus == "审批中" ? source.ProcessStatus + " 流程" + (branchOrder != 0 && source.ProcessOrderId > branchOrder ? source.ProcessOrderId - 2 : source.ProcessOrderId - 1) + "/" + (source.TradeStatus == "平仓待复核" || source.TradeStatus == "行权待复核" || source.TradeStatus == "互换待复核" ? (closeProcessOrder > 0 ? closeProcessOrder : tradeOpenProcessOrder) : tradeOpenProcessOrder) : source.ProcessStatus,
                            ProcessOrderId = source.ProcessOrderId,
                            ProcessOrderBranch = source.ProcessOrderBranch,
                            ProcessRoleId = proce.roleId,
@@ -3391,7 +3393,7 @@ namespace YLErp.BLL
                        };
            return query;
        }
-        private IQueryable<TradeLinq> GetTradeLinqQuery(Expression<Func<trade, bool>> predicate, IQueryable<approvalprocess> approvalprocessQuery, int tradeOpenProcessOrder, int node, int branchOrder, List<int?> nodeArr)
+        private IQueryable<TradeLinq> GetTradeLinqQuery(Expression<Func<trade, bool>> predicate, IQueryable<approvalprocess> approvalprocessQuery, int tradeOpenProcessOrder, int node, int branchOrder, List<int?> nodeArr, int closeProcessOrder = 0)
        {
            var tradeStatus = new string[] { "平仓待复核", "行权待复核", "互换待复核" };
            var query = from source in db.trade.Where(predicate)
@@ -3445,7 +3447,7 @@ namespace YLErp.BLL
                            OptId = source.OptId,
                            OptName = source.OptName,
                            OptDate = source.OptDate,
-                            ProcessStatus = source.ProcessStatus == "审批中" ? source.ProcessStatus + " 流程" + (branchOrder != 0 && source.ProcessOrderId > branchOrder ? source.ProcessOrderId - 2 : source.ProcessOrderId - 1) + "/" + tradeOpenProcessOrder : source.ProcessStatus,
+                            ProcessStatus = source.ProcessStatus == "审批中" ? source.ProcessStatus + " 流程" + (branchOrder != 0 && source.ProcessOrderId > branchOrder ? source.ProcessOrderId - 2 : source.ProcessOrderId - 1) + "/" + (source.TradeStatus == "平仓待复核" || source.TradeStatus == "行权待复核" || source.TradeStatus == "互换待复核" ? (closeProcessOrder > 0 ? closeProcessOrder : tradeOpenProcessOrder) : tradeOpenProcessOrder) : source.ProcessStatus,
                            ProcessOrderId = source.ProcessOrderId,
                            ProcessOrderBranch = source.ProcessOrderBranch,
                            ProcessRoleId = proce.roleId,
@@ -2,6 +2,7 @@
 using YLErp.BLL;
 using YLErp.DBModels.Consts;
 using YLErp.DBModels.Enums;
+using YLErp.Helpers;

 namespace YLErp.Modules.TradeModule
 {
@@ -46,23 +47,50 @@ namespace YLErp.Modules.TradeModule
            return _tradeProcessCount.Value;
        }
        /// <summary>
-        /// 获取所有交易审批节点
+        /// 获取所有交易审批节点(开仓流程 TradeProcess)。
        /// </summary>
-        /// <returns></returns>
        public List<approvalprocess> TradeProcess()
        {
            var tradeOrders = DbContext.approvalprocess.Where(t => t.processType == "TradeProcess").OrderBy(o => o.order).ToList();
            return tradeOrders;
        }
+
+        /// <summary>
+        /// 按交易推断流程类别(开仓/了结)获取审批节点(需求②)。
+        /// <para>了结类(平仓待复核/行权待复核/互换待复核)取 CloseProcess；开仓类取 TradeProcess。</para>
+        /// <para>未配置对应流程时返回空列表（由调用方决定是否直接通过）。</para>
+        /// </summary>
+        public List<approvalprocess> TradeProcessByCategory(trade td)
+        {
+            var category = ResolveProcessCategory(td);
+            return DbContext.approvalprocess.Where(t => t.processType == category).OrderBy(o => o.order).ToList();
+        }
+
+        /// <summary>
+        /// 按类别统计审批节点数(需求②)。
+        /// </summary>
+        public int TradeProcessCountByCategory(trade td)
+        {
+            return TradeProcessByCategory(td).Count;
+        }
+
        /// <summary>
        /// 初始化交易 审批点
        /// </summary>
        /// <param name="td"></param>
        public void InitTradeProcessOrder(trade td,int userId)
        {
+            var tradeProcess = TradeProcessByCategory(td);
+            // 该交易类别未配置审批流程 → 直接审批通过，无需审核
+            if (tradeProcess == null || tradeProcess.Count == 0)
+            {
+                td.ProcessOrderId = ProcessTradeLog.审批通过;
+                td.ProcessStatus = ProcessTradeStatus.通过审批.ToString();
+                td.ProcessOptDate = DateTime.Now;
+                return;
+            }
            td.ProcessOrderId = ProcessTradeLog.审批中;
            td.ProcessStatus = ProcessTradeStatus.审批中.ToString();
-            var tradeProcess = TradeProcess();
            var groupId = UserBLL.GetApprovalProcessGroup(userId);
            bool approvalBranch = tradeProcess.Any(x => x.approvalGroupId != 0);//审批流程有分支情况
            if (td.ProcessOrderId == 1)
@@ -88,6 +116,129 @@ namespace YLErp.Modules.TradeModule
            {
                td.ProcessOrderId = 2;
            }
+
+            // 需求①：进入审批流程时即应用触发条件——从起始节点开始，跳过所有不满足触发条件的节点。
+            // 若所有节点均不满足 → 直接审批通过（无需任何人审核）。
+            ApplyTriggerFromStart(tradeProcess, td, userId);
+        }
+
+        /// <summary>
+        /// 从当前 ProcessOrderId 起点开始，按触发条件跳过无需审批的节点(需求①)。
+        /// <para>场景：交易提交进入审批流程时，若节点1、2配置的触发条件均不满足，则直接跳到节点3；
+        /// 若全部节点都不满足，则直接审批通过。</para>
+        /// </summary>
+        private void ApplyTriggerFromStart(List<approvalprocess> tradeProcess, trade td, int userId)
+        {
+            if (tradeProcess == null || tradeProcess.Count == 0) return;
+
+            // 取当前起点节点（主干 node=0）
+            var current = tradeProcess.FirstOrDefault(x => x.order == td.ProcessOrderId && x.node == 0);
+            // 若起点不在主干（如分支调整后 ProcessOrderId=2），取该 order 的主干节点
+            if (current == null)
+            {
+                current = tradeProcess.FirstOrDefault(x => x.order >= td.ProcessOrderId && x.node == 0);
+            }
+            if (current == null) return;
+
+            var ctx = BuildTriggerContext(td, userId);
+            var target = ConditionEvaluator.FindFirstTriggeredNode(tradeProcess, current, ctx);
+            if (target == null)
+            {
+                // 所有节点都不满足触发条件 → 直接审批通过，无需审核
+                td.ProcessOrderId = ProcessTradeLog.审批通过;
+                td.ProcessStatus = ProcessTradeStatus.通过审批.ToString();
+                td.ProcessOptDate = DateTime.Now;
+                return;
+            }
+            // target 即为第一个满足触发条件、需实际审批的节点
+            if (target.order != td.ProcessOrderId)
+            {
+                td.ProcessOrderId = target.order;
+            }
+        }
+
+        /// <summary>
+        /// 节点触发条件(需求①)：在已确定下一审批节点 nextOrder 后，若该节点配置了 triggerCondition，
+        /// 则只有「满足触发条件」才进入该节点审批；不满足则跳过该节点，继续向后寻找，直到找到可进入的节点或抵达流程末尾。
+        /// <para>语义：triggerCondition 为空 → 无条件进入审批；非空 → 满足才进入，不满足则跳过。</para>
+        /// <para>非侵入式：原有分支推进逻辑不变，仅在其结果之上叠加触发判断循环。</para>
+        /// </summary>
+        /// <param name="tradeProcess">当前流程的全部节点(已按 order 排序)</param>
+        /// <param name="nextOrder">原逻辑计算出的下一节点(可能为 null)</param>
+        /// <param name="ctx">条件求值业务上下文（已含 trade、本次交易名义本金等）</param>
+        /// <returns>最终应推进到的节点；若应结束流程则返回 null</returns>
+        protected static approvalprocess AdvanceThroughTriggerNodes(
+            List<approvalprocess> tradeProcess,
+            approvalprocess nextOrder,
+            ConditionContext ctx)
+        {
+            // 不满足触发条件的节点需跳过：循环向后找第一个可进入的节点。
+            while (nextOrder != null && !string.IsNullOrWhiteSpace(nextOrder.triggerCondition))
+            {
+                if (ConditionEvaluator.Evaluate(nextOrder.triggerCondition, ctx))
+                {
+                    break; // 满足触发条件 → 进入该节点审批，停止跳过。
+                }
+
+                // 不满足触发条件 → 跳过该节点，向后取下一个主干节点(node=0)，继续判断。
+                nextOrder = tradeProcess.FirstOrDefault(x => x.order > nextOrder.order && x.node == 0);
+            }
+            return nextOrder;
+        }
+
+        /// <summary>
+        /// 构建触发条件求值上下文：从 trade 及其关联的 trade_cash 取本次交易名义本金（了结场景）。
+        /// <para>本次交易名义本金 = 本次了结操作的 trade_cash.UnwindStockEqvNotional 绝对值。</para>
+        /// </summary>
+        protected ConditionContext BuildTriggerContext(trade td, int userId)
+        {
+            var ctx = new ConditionContext
+            {
+                UserId = userId,
+                Trade = td,
+                ProcessCategory = ResolveProcessCategory(td),
+                InitGroupId = UserBLL.GetApprovalProcessGroup(userId)
+            };
+            // 了结场景：当次平仓名义本金 = 期初名义本金 × 平仓比例(UnwindPercentRate)，取绝对值
+            if (td != null && ctx.ProcessCategory == ProcessCategoryConst.Close)
+            {
+                var tc = DbContext.trade_cash
+                    .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);
+                }
+            }
+            return ctx;
+        }
+
+        /// <summary>
+        /// 需求①：判断按触发条件是否需要审批。
+        /// <para>取该交易类别的审批流程，若所有节点配置的触发条件都不满足当前业务，则无需审批（返回 false）。</para>
+        /// <para>若无审批流程或节点无触发条件，返回 true（需要审批）。</para>
+        /// </summary>
+        protected bool NeedApprovalByTrigger(trade td)
+        {
+            var tradeProcess = TradeProcessByCategory(td);
+            if (tradeProcess == null || tradeProcess.Count == 0) return true;
+
+            var start = tradeProcess.FirstOrDefault(x => x.node == 0);
+            if (start == null) start = tradeProcess.OrderBy(x => x.order).First();
+
+            var ctx = BuildTriggerContext(td, UserId);
+            var target = ConditionEvaluator.FindFirstTriggeredNode(tradeProcess, start, ctx);
+            return target != null;
+        }
+
+        /// <summary>
+        /// 按交易状态推断流程类别：开仓(TradeProcess) / 了结(CloseProcess)。需求②。
+        /// <para>委托给 ProcessCategoryConst.Resolve，供全局复用。</para>
+        /// </summary>
+        protected static string ResolveProcessCategory(trade td)
+        {
+            return ProcessCategoryConst.Resolve(td);
        }
        /// <summary>
        /// 添加交易操作日志
@@ -521,4 +672,31 @@ namespace YLErp.Modules.TradeModule
            return rateCalcModeValue;
        }
    }
+
+    /// <summary>
+    /// 交易流程类别常量(需求②)：对应 approvalprocess.processType 的取值。
+    /// </summary>
+    public static class ProcessCategoryConst
+    {
+        /// <summary>开仓审批流程</summary>
+        public const string Open = "TradeProcess";
+
+        /// <summary>了结/平仓/行权审批流程</summary>
+        public const string Close = "CloseProcess";
+
+        /// <summary>
+        /// 按交易状态推断流程类别：处于平仓/行权/互换待复核的交易视为「了结」类操作。
+        /// </summary>
+        public static string Resolve(trade td)
+        {
+            if (td == null) return Open;
+            if (td.TradeStatus == ConsTrade.平仓待复核
+                || td.TradeStatus == ConsTrade.行权待复核
+                || td.TradeStatus == ConsTrade.互换待复核)
+            {
+                return Close;
+            }
+            return Open;
+        }
+    }
 }