Optimize GradeConfig Implementation

Model/GradeLevel/Entity/DatabaseEntity/BaseEntity.cs

@@ -2,5 +2,8 @@
 
 public class BaseEntity
 {
+    /// <summary>
+    /// 唯一签名
+    /// </summary>
     public string Sign { get; set; } = string.Empty;
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelDataSet.cs

@@ -5,12 +5,36 @@
 /// </summary>
 public class GradeLevelDataSet: BaseEntity
 {
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属Mst名称
+    /// </summary>
     public string Mst_Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 数据名
+    /// </summary>
     public string Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 数据英文名
+    /// </summary>
     public string EName { get; set; } = string.Empty;
+    /// <summary>
+    /// 数据在Json中的Key
+    /// </summary>
     public string KName { get; set; } = string.Empty;
+    /// <summary>
+    /// 数据单位
+    /// </summary>
     public string Unit {set; get;} = string.Empty;
+    /// <summary>
+    /// 是否用于切工等级评定 0否1是
+    /// </summary>
     public int HasCut { get; set; } = 0;
+    /// <summary>
+    /// 是否用于对称等级评定 0否1是
+    /// </summary>
     public int HasSym { get; set; } = 0;
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelMst.cs

@@ -4,10 +4,28 @@
 /// </summary>
 public class GradeLevelMst : BaseEntity
 {
+    /// <summary>
+    /// 定级标准名称
+    /// </summary>
     public string Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 定级标准名称 英文
+    /// </summary>
     public string EName { get; set; } = string.Empty;
+    /// <summary>
+    /// 运行模式 -1通用 0实验室 1工厂
+    /// </summary>
     public int RunMode { get; set; } = -1;
+    /// <summary>
+    /// 形状 0圆形 1椭圆 2梨形
+    /// </summary>
     public int Shape { get; set; } = 0;
+    /// <summary>
+    /// 冠数量
+    /// </summary>
     public int Crown { get; set; } = 8;
+    /// <summary>
+    /// 亭数量
+    /// </summary>
     public int Pavilion { get; set; } = 8;
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelSet.cs

@@ -5,11 +5,32 @@
 /// </summary>
 public class GradeLevelSet : BaseEntity
 {
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属Mst的名称
+    /// </summary>
     public string Mst_Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 设定类型 0切工等级 1对称等级
+    /// </summary>
     public int Set_Type { get; set; } = 0;
+    /// <summary>
+    /// 级别名称
+    /// </summary>
     public string Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 级别名称英文
+    /// </summary>
     public string EName { get; set; } = string.Empty;
+    /// <summary>
+    /// 级别名称简称
+    /// </summary>
     public string AName { get; set; } = string.Empty;
+    /// <summary>
+    /// 级别顺序：由小到大代表由差到好，数值越大越好
+    /// </summary>
     public int Short { get; set; } = 0;
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelSetDtl.cs

@@ -4,11 +4,32 @@
 /// </summary>
 public class GradeLevelSetDtl: BaseEntity
 {
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属树签名
+    /// </summary>
     public string Tree_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属数据签名
+    /// </summary>
     public string DataSet_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 适用等级签名
+    /// </summary>
     public string Level_Sign { get; set; } = string.Empty; 
+    /// <summary>
+    /// 此等级最大值
+    /// </summary>
     public double Max_Value { get; set; }
+    /// <summary>
+    /// 此等级最小值
+    /// </summary>
     public double Min_Value { get; set; }
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelTotalSet.cs

@@ -5,10 +5,28 @@
 /// </summary>
 public class GradeLevelTotalSet: BaseEntity
 {
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属Mst的名称
+    /// </summary>
     public string Mst_Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 设定类型 0切工等级 1对称等级
+    /// </summary>
     public int Set_Type { get; set; } = 0;
+    /// <summary>
+    /// 统计方式：0最大值 1最小值 2平均值
+    /// </summary>
     public int Statistics { get; set; } = 0;
+    /// <summary>
+    /// 参与评级的数据名 ,分割 关联GradeLevelDataSet.Name
+    /// </summary>
     public string DataNames { get; set; } = string.Empty;
+    /// <summary>
+    /// 参与评级的数据签名 ,分割 关联GradeLevelDataSet.Sign
+    /// </summary>
     public string DataSigns { get; set; } = string.Empty;
 }

Model/GradeLevel/Entity/DatabaseEntity/GradeLevelTreeSet.cs

@@ -4,16 +4,45 @@
 /// </summary>
 public class GradeLevelTreeSet: BaseEntity
 {
+    /// <summary>
+    /// 所属Mst的签名
+    /// </summary>
     public string Mst_Sign { get; set; } = string.Empty;
+    /// <summary>
+    /// 所属Mst的名称
+    /// </summary>
     public string Mst_Name { get; set; } = string.Empty;
+    /// <summary>
+    /// 节点名
+    /// </summary>
     public string Header { get; set; } = string.Empty;
+    /// <summary>
+    /// 节点类型：0顶级 1切工节点 2对称节点
+    /// </summary>
     public int NodeType { get; set; } = 0;
+    /// <summary>
+    /// 是否含有数据 0否1是
+    /// </summary>
     public int HasData { get; set; } = 0;
+    /// <summary>
+    /// 是否为顶级节点，只有Root、父级为Root的切工节点、父级为root的对称节点为1
+    /// </summary>
     public int IsTop { get; set; } = 0;
+    /// <summary>
+    /// 维度值
+    /// </summary>
     public string DimensionValue { get; set; } = string.Empty;
+    /// <summary>
+    /// 维度数据签名 关联GradeLevelDataSet.Sign
+    /// </summary>
     public string DimensionSign { get; set; } = string.Empty;
+    /// <summary>
+    /// 父级节点签名
+    /// </summary>
     public string ParentSign { get; set; } = string.Empty;
-
+/// <summary>
+/// 节点下评级设定明细
+/// </summary>
     private List<GradeLevelSetDtl> _setDtls = new List<GradeLevelSetDtl>();
 
     public List<GradeLevelSetDtl> GetLevelSetDtls()

Model/GradeLevel/Exceptions/NotGradeSetException.cs

@@ -7,4 +7,10 @@ public class NotGradeSetException : Exception
     {
         
     }
+    
+    public NotGradeSetException(string message)
+        :base(message)
+    {
+        
+    }
 }

Model/GradeLevel/GradeLevelCalculator.cs

@@ -7,57 +7,380 @@ using BrilliantSightClient.Model.GradeLevel.Helper;
 using BrilliantSightClient.Model.GradeResult.Entity;
 using BrilliantSightClient.Model.GradeResult.Entity.Enums;
 using BrilliantSightClient.Model.Helper;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace BrilliantSightClient.Model.GradeLevel;
 
 public class GradeLevelCalculator
 {
     AlgorithmResultEntity _diamondResult;
-    
+    private JToken _diamondData;
     GradeLevelMst _masterLevel;
 
     private List<GradeLevelSet> _gradeLevelCutSets;
     private List<GradeLevelSet> _gradeLevelSymSets;
     
+    private List<GradeLevelDataSet> _gradeLevelDataSets;
+    
+    private List<GradeLevelTreeSet> _gradeLevelCutTreeSets;
+    private List<GradeLevelTreeSet> _gradeLevelSymTreeSets;
+    
+    private List<GradeLevelSetDtl> _gradeLevelSetDtls;
+    
+    private GradeLevelTotalSet _gradeLevelCutTotalSet;
+    private GradeLevelTotalSet _gradeLevelSymTotalSet;
+    
     
     public GradeLevelCalculator(AlgorithmResultEntity entity)
     {
         _diamondResult = entity;
-
-        var masterSql = $"select * from GRADE_LEVEL_MST where NAME = '{entity.Standard}' and RUNMODE = {Common.RunMode} or RUNMODE = -1 " +
-                        $" and SHAPE = {EntityHelper.GetValueFromName<DiamondShape>(entity.Shape)} and CROWN = {entity.CrownType} and PAVILION = {entity.PavType}" ;
+        _diamondData = JToken.Parse(JsonConvert.SerializeObject(entity.Measurements));
+        var masterSql = $"select * from GRADE_LEVEL_MST where NAME = '{entity.Standard}' and RUNMODE = {Common.RunMode} or RUNMODE = -1  and SHAPE = {EntityHelper.GetValueFromName<DiamondShape>(entity.Shape)} and CROWN = '{entity.CrownType.Replace("P","")}' and PAVILION = '{entity.PavType.Replace("P","")}'" ;
         var masterLevel = DataBaseHelper.ExecuteQuery<GradeLevelMst>(masterSql);
-        if (masterLevel.Count == 0)
+        if (masterLevel.Count == 0) 
             throw new NotGradeSetException();
         _masterLevel = masterLevel.First();
 
         var setsSql = $"select * from GRADE_LEVEL_SET where MST_SIGN = '{_masterLevel.Sign}'";
         var levelSets = DataBaseHelper.ExecuteQuery<GradeLevelSet>(setsSql);
-        if (masterLevel.Count == 0)
+        if (levelSets.Count == 0)
             throw new NotGradeSetException();
         _gradeLevelCutSets = levelSets.FindAll(x => x.Set_Type == GradeType.Cut.GetValue());
         _gradeLevelSymSets = levelSets.FindAll(x => x.Set_Type == GradeType.Sym.GetValue());
+        
+        var dataSetSql = $"select * from GRADE_LEVEL_DATA_SET where MST_SIGN = '{_masterLevel.Sign}'";
+        _gradeLevelDataSets = DataBaseHelper.ExecuteQuery<GradeLevelDataSet>(dataSetSql);
+        
+        var treeSetSql = $"select * from GRADE_LEVEL_TREE_SET where MST_SIGN = '{_masterLevel.Sign}'";
+        var treeSets = DataBaseHelper.ExecuteQuery<GradeLevelTreeSet>(treeSetSql);
+        _gradeLevelCutTreeSets = treeSets.FindAll(x => x.NodeType - 1 == GradeType.Cut.GetValue());
+        _gradeLevelSymTreeSets = treeSets.FindAll(x => x.NodeType - 1 == GradeType.Sym.GetValue());
+        
+        var setDtlSql =  $"select * from GRADE_LEVEL_SET_DTL where MST_SIGN = '{_masterLevel.Sign}'";
+        _gradeLevelSetDtls = DataBaseHelper.ExecuteQuery<GradeLevelSetDtl>(setDtlSql);
+        
+        var totalSetSql = $"select * from GRADE_LEVEL_TOTAL_SET where MST_SIGN = '{_masterLevel.Sign}'";
+        var totalSets = DataBaseHelper.ExecuteQuery<GradeLevelTotalSet>(totalSetSql);
+        _gradeLevelCutTotalSet = totalSets.FindAll(x => x.Set_Type == GradeType.Cut.GetValue()).First();
+        _gradeLevelSymTotalSet = totalSets.FindAll(x => x.Set_Type == GradeType.Sym.GetValue()).First();
+        
     }
 
-    public GradeLevelSet GetCutGradeLevelSet(string key, double maxVal, double minVal)
+    public GradeLevelSet? GetCutGradeLevelSet(string key, double maxVal, double minVal)
     {
-        return null;
+        GradeLevelDataSet? dataSet = _gradeLevelDataSets.FirstOrDefault(x => x.KName.Equals(key));
+        if (dataSet == null) return null;
+        //检查是否多维度
+        if (_gradeLevelCutTreeSets.Count > 1)
+        {
+            //多维度
+            List<GradeLevelTreeSet> cutTree = _gradeLevelCutTreeSets.FindAll(x => x.IsTop == 0);
+            if(cutTree.Count <= 0) return null;
+            GradeLevelDataSet? dimensionKey = _gradeLevelDataSets.FirstOrDefault(x => cutTree.First().DimensionSign == x.Sign);
+            if (dimensionKey == null) return null;
+            string dimensionTreeSign = DimensionTreeSign(dimensionKey, cutTree);
+            if ("1".Equals(dimensionTreeSign) || "-1".Equals(dimensionTreeSign))
+            {
+                return _gradeLevelCutSets.OrderBy(set => set.Short).FirstOrDefault();
+            }
+
+            return GetFinalCutGrade(dimensionTreeSign, key, maxVal, minVal);
+        }
+        else
+        {
+            //单维度
+            return GetFinalCutGrade(_gradeLevelCutTreeSets.First().Sign, key, maxVal, minVal);
+        }
+        
     }
     
     public GradeLevelSet GetCutTotalGradeLevelSet(List<DataInfo> dataInfos)
     {
-        return null;
+        return CalculateTotalGrade(dataInfos, _gradeLevelCutTotalSet, _gradeLevelCutSets);
     }
     
-    public GradeLevelSet GetSymGradeLevelSet(string key, double devVal)
+    public GradeLevelSet? GetSymGradeLevelSet(string key, double devVal)
     {
-        return null;
+        GradeLevelDataSet? dataSet = _gradeLevelDataSets.FirstOrDefault(x => x.KName.Equals(key));
+        if (dataSet == null) return null;
+    
+        // 检查是否多维度
+        if (_gradeLevelSymTreeSets.Count > 1)
+        {
+            // 多维度
+            List<GradeLevelTreeSet> symTree = _gradeLevelSymTreeSets.FindAll(x => x.IsTop == 0);
+            if (symTree.Count <= 0) return null;
+        
+            GradeLevelDataSet? dimensionKey = _gradeLevelDataSets.FirstOrDefault(x => symTree.First().DimensionSign == x.Sign);
+            if (dimensionKey == null) return null;
+        
+            string dimensionTreeSign = DimensionTreeSign(dimensionKey, symTree);
+            if ("1".Equals(dimensionTreeSign) || "-1".Equals(dimensionTreeSign))
+            {
+                return _gradeLevelSymSets.OrderBy(set => set.Short).FirstOrDefault();
+            }
+
+            return GetFinalSymGrade(dimensionTreeSign, key, devVal);
+        }
+        else
+        {
+            // 单维度
+            return GetFinalSymGrade(_gradeLevelSymTreeSets.First().Sign, key, devVal);
+        }
+
     }
     
     public GradeLevelSet GetSymTotalGradeLevelSet(List<DataInfo> dataInfos)
     {
-        return null;
+        return CalculateTotalGrade(dataInfos, _gradeLevelSymTotalSet, _gradeLevelSymSets);
     }
 
+    private string DimensionTreeSign( GradeLevelDataSet dimensionKey,List<GradeLevelTreeSet> cutTree)
+    {
+        string dimensionTreeSign = string.Empty;
+        try
+        {
+            // 从JToken中获取对应路径的值
+            JToken? dimensionValueToken = _diamondData.SelectToken(dimensionKey.KName);
+            if (dimensionValueToken == null || !dimensionValueToken.HasValues)
+                return string.Empty;
     
+            // 转换为double并进行计算
+            if (double.TryParse(dimensionValueToken.ToString(), out double dimensionValue))
+            {
+                // 乘以100并四舍五入取整
+                int roundedValue = (int)Math.Round(dimensionValue * 100, MidpointRounding.AwayFromZero);
+        
+                // 获取所有维度值并排序
+                var dimensionValues = cutTree
+                    .Where(x => !string.IsNullOrEmpty(x.DimensionValue))
+                    .Select(x => 
+                    {
+                        if (int.TryParse(x.DimensionValue, out int value))
+                            return new { Value = value, Sign = x.Sign };
+                        return null;
+                    })
+                    .Where(x => x != null)
+                    .OrderBy(x => x.Value)
+                    .ToList();
+            
+                if (dimensionValues.Any())
+                {
+                    // 判断属于哪个区间
+                    var matchedDimension = dimensionValues.FirstOrDefault(x => x.Value == roundedValue);
+                    if (matchedDimension != null)
+                    {
+                        dimensionTreeSign = matchedDimension.Sign;
+                    }
+                    else if (roundedValue > dimensionValues.Max(x => x.Value))
+                    {
+                        dimensionTreeSign = "1"; // 大于所有维度值
+                    }
+                    else if (roundedValue < dimensionValues.Min(x => x.Value))
+                    {
+                        dimensionTreeSign = "-1"; // 小于所有维度值
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // 处理异常，返回空白
+            dimensionTreeSign = string.Empty;
+        }
+
+        return dimensionTreeSign;
+    }
+    
+    public GradeLevelSet? GetFinalCutGrade(string treeSign, string key, double maxVal, double minVal)
+    {
+        // 通过TreeSign和Key关联获取子集
+        var dataSet = _gradeLevelDataSets.FirstOrDefault(ds => ds.KName == key);
+        if (dataSet == null) return null;
+        
+        var filteredDtls = _gradeLevelSetDtls
+            .Where(dtl => dtl.Tree_Sign == treeSign && dtl.DataSet_Sign == dataSet.Sign)
+            .ToList();
+        
+        if (!filteredDtls.Any()) return null;
+        
+        // 查找最大值和最小值对应的区间
+        var maxValDtls = filteredDtls
+            .Where(dtl => maxVal >= dtl.Min_Value && maxVal <= dtl.Max_Value)
+            .ToList();
+        
+        var minValDtls = filteredDtls
+            .Where(dtl => minVal >= dtl.Min_Value && minVal <= dtl.Max_Value)
+            .ToList();
+        
+        // 获取对应的GradeLevelSet集合
+        var associatedLevelSets = _gradeLevelCutSets
+            .Where(ls => filteredDtls.Any(dtl => dtl.Level_Sign == ls.Sign))
+            .ToList();
+        
+        // 处理最大值的情况
+        GradeLevelSet? maxLevel = null;
+        if (maxValDtls.Any())
+        {
+            // 若有多个区间，取最差的（Short值最大）
+            if (maxValDtls.Count > 1)
+            {
+                maxLevel = associatedLevelSets
+                    .Where(ls => maxValDtls.Any(dtl => dtl.Level_Sign == ls.Sign))
+                    .OrderBy(ls => ls.Short)
+                    .FirstOrDefault();
+            }
+            else
+            {
+                maxLevel = associatedLevelSets
+                    .FirstOrDefault(ls => ls.Sign == maxValDtls.First().Level_Sign);
+            }
+        }
+        
+        // 处理最小值的情况
+        GradeLevelSet? minLevel = null;
+        if (minValDtls.Any())
+        {
+            // 若有多个区间，取最差的（Short值最大）
+            if (minValDtls.Count > 1)
+            {
+                minLevel = associatedLevelSets
+                    .Where(ls => minValDtls.Any(dtl => dtl.Level_Sign == ls.Sign))
+                    .OrderBy(ls => ls.Short)
+                    .FirstOrDefault();
+            }
+            else
+            {
+                minLevel = associatedLevelSets
+                    .FirstOrDefault(ls => ls.Sign == minValDtls.First().Level_Sign);
+            }
+        }
+        
+        // 若最大值和最小值都找到对应的区间，返回较差的一个
+        if (maxLevel != null && minLevel != null)
+        {
+            return maxLevel.Short > minLevel.Short ? minLevel : maxLevel;
+        }
+        
+        // 若只有一个找到区间，返回该区间对应的级别
+        if (maxLevel != null) return maxLevel;
+        if (minLevel != null) return minLevel;
+        
+        // 若都没找到，返回子集中最差的级别
+        return associatedLevelSets.OrderBy(ls => ls.Short).FirstOrDefault();
+    }
+    private GradeLevelSet? GetFinalSymGrade(string treeSign, string key, double devVal)
+    {
+        // 通过TreeSign和Key关联获取子集
+        var dataSet = _gradeLevelDataSets.FirstOrDefault(ds => ds.KName == key);
+        if (dataSet == null) return null;
+        
+        var filteredDtls = _gradeLevelSetDtls
+            .Where(dtl => dtl.Tree_Sign == treeSign && dtl.DataSet_Sign == dataSet.Sign)
+            .ToList();
+        
+        if (!filteredDtls.Any()) return null;
+        
+        // 查找偏差值对应的区间
+        var devValDtls = filteredDtls
+            .Where(dtl => devVal >= dtl.Min_Value && devVal <= dtl.Max_Value)
+            .ToList();
+        
+        // 获取对应的GradeLevelSet集合
+        var associatedLevelSets = _gradeLevelSymSets
+            .Where(ls => filteredDtls.Any(dtl => dtl.Level_Sign == ls.Sign))
+            .ToList();
+        
+        // 处理偏差值的情况
+        GradeLevelSet? devLevel = null;
+        if (devValDtls.Any())
+        {
+            // 若有多个区间，取最差的（Short值最大）
+            if (devValDtls.Count > 1)
+            {
+                devLevel = associatedLevelSets
+                    .Where(ls => devValDtls.Any(dtl => dtl.Level_Sign == ls.Sign))
+                    .OrderBy(ls => ls.Short)
+                    .FirstOrDefault();
+            }
+            else
+            {
+                devLevel = associatedLevelSets
+                    .FirstOrDefault(ls => ls.Sign == devValDtls.First().Level_Sign);
+            }
+        }
+        
+        // 若找到对应的区间，返回该区间对应的级别
+        if (devLevel != null) return devLevel;
+        
+        // 若没找到，返回子集中最差的级别
+        return associatedLevelSets.OrderBy(ls => ls.Short).FirstOrDefault();
+    }
+
+    private GradeLevelSet CalculateTotalGrade(List<DataInfo> dataInfos, GradeLevelTotalSet totalSet, List<GradeLevelSet> levelSets)
+    {
+        // 解析参与评级的数据签名
+        var dataSigns = totalSet.DataSigns.Split(',', StringSplitOptions.RemoveEmptyEntries);
+        
+        // 找出所有参与评级的项目对应的评级
+        var gradeLevels = new List<GradeLevelSet>();
+        
+        foreach (var dataSign in dataSigns)
+        {
+            var dataSet = _gradeLevelDataSets.FirstOrDefault(ds => ds.Sign == dataSign);
+            if (dataSet == null) continue;
+            
+            var dataInfo = dataInfos.FirstOrDefault(di => di.TestItemId == dataSet.KName);
+            if (dataInfo == null) continue;
+            
+            GradeLevelSet? gradeLevel = null;
+            
+            if (totalSet.Set_Type == GradeType.Cut.GetValue())
+            {
+                // 切工评级
+                gradeLevel = GetCutGradeLevelSet(dataSet.KName, double.Parse(dataInfo.Max), double.Parse(dataInfo.Min));
+            }
+            else if (totalSet.Set_Type == GradeType.Sym.GetValue())
+            {
+                // 对称评级
+                gradeLevel = GetSymGradeLevelSet(dataSet.KName, double.Parse(dataInfo.Dev));
+            }
+            
+            if (gradeLevel != null)
+            {
+                gradeLevels.Add(gradeLevel);
+            }
+        }
+        
+        // 若没有找到任何评级，返回默认最差评级
+        if (!gradeLevels.Any())
+        {
+            return levelSets.OrderByDescending(ls => ls.Short).FirstOrDefault() 
+                ?? throw new NotGradeSetException("无法计算总评级，没有找到有效的评级数据");
+        }
+        
+        // 根据统计方式聚合评级
+        switch (totalSet.Statistics)
+        {
+            case 0: // 最大值（最差）
+                return gradeLevels.OrderByDescending(ls => ls.Short).First();
+                
+            case 1: // 最小值（最好）
+                return gradeLevels.OrderBy(ls => ls.Short).First();
+                
+            case 2: // 平均值
+                // 计算平均Short值
+                double averageShort = gradeLevels.Average(ls => ls.Short);
+                
+                // 找到最接近平均值的等级
+                return levelSets
+                    .OrderBy(ls => Math.Abs(ls.Short - averageShort))
+                    .FirstOrDefault() 
+                    ?? throw new NotGradeSetException("无法计算平均评级，没有找到匹配的等级");
+                    
+            default:
+                throw new NotSupportedException($"不支持的统计方式: {totalSet.Statistics}");
+        }
+    }
 }

Model/GradeResult/Helper/ViewDataInfoHelper.cs

@@ -1,6 +1,7 @@
 using BrilliantSightClient.Model.Entity.ApiEntity;
 using BrilliantSightClient.Model.Extension;
 using BrilliantSightClient.Model.GradeLevel;
+using BrilliantSightClient.Model.GradeLevel.Entity.DatabaseEntity;
 using BrilliantSightClient.Model.GradeLevel.Helper;
 using BrilliantSightClient.Model.GradeResult.Entity;
 using BrilliantSightClient.Model.GradeResult.Entity.Enums;
@@ -23,19 +24,33 @@ public class ViewDataInfoHelper
         if(shape == -1) throw new Exception("Unsupported shapes");
         string viewDataSql = $"SELECT * FROM ViewData WHERE Shape = {shape} AND Specifications = '{result.PavType}-{result.CrownType}' AND RunMode = {Common.RunMode}";
         List<ViewData> showViewData = DataBaseHelper.ExecuteQuery<ViewData>(viewDataSql);
+        
+        GradeLevelCalculator levelCalculator = new GradeLevelCalculator(result);
         foreach (var viewData in showViewData)
         {
             DataInfo dataInfo = new DataInfo();
             dataInfo.TestItemId = viewData.InfoPath;
             dataInfo.TestItemName = "Name".Equals(MultilingualHelper.getString("ColumnNameBase"))? viewData.Name : viewData.EName;
+            double dev =0 , max=0, min = 0;
             if(!viewData.AvgKey.IsNullOrEmpty())
                 dataInfo.Avg = DoubleDataFormatHelper.FormatDouble(jData[viewData.AvgKey], viewData.AvgType.ToAccuracy());
-            if(!viewData.DevKey.IsNullOrEmpty())
+            if (!viewData.DevKey.IsNullOrEmpty())
+            {
                 dataInfo.Dev = DoubleDataFormatHelper.FormatDouble(jData[viewData.DevKey], viewData.DevType.ToAccuracy());
-            if(!viewData.MaxKey.IsNullOrEmpty())
+                dev = double.Parse(dataInfo.Dev);
+            }
+            if (!viewData.MaxKey.IsNullOrEmpty())
+            {
                 dataInfo.Max = DoubleDataFormatHelper.FormatDouble(jData[viewData.MaxKey], viewData.MaxType.ToAccuracy());
-            if(!viewData.MinKey.IsNullOrEmpty())
+                max = double.Parse(dataInfo.Max);
+            }
+
+            if (!viewData.MinKey.IsNullOrEmpty())
+            {
                 dataInfo.Min = DoubleDataFormatHelper.FormatDouble(jData[viewData.MinKey], viewData.MinType.ToAccuracy());
+                min = double.Parse(dataInfo.Min);
+            }
+
             if (!viewData.DtlKey.IsNullOrEmpty())
             {
                 List<string> dtlDoubles = GenerateDtlDoubles(jData, viewData);
@@ -47,9 +62,13 @@ public class ViewDataInfoHelper
                 dataInfo.Dtl6 = dtlDoubles[5];
                 dataInfo.Dtl7 = dtlDoubles[6];
                 dataInfo.Dtl8 = dtlDoubles[7];
+                
+              
             }
-
-            GradeLevelCalculator levelCalculator = new GradeLevelCalculator(result);
+            GradeLevelSet? cutLevel = levelCalculator.GetCutGradeLevelSet(dataInfo.TestItemId, max, min);
+            dataInfo.CutLevel =  cutLevel==null?string.Empty:cutLevel.Name;
+            GradeLevelSet? symLevel =levelCalculator.GetSymGradeLevelSet(dataInfo.TestItemId, dev);
+            dataInfo.SymLevel = symLevel==null?-1:symLevel.Short;
             dataInfos.Add(dataInfo);
         }