颜色分级梳理

lixiaojun

2024-11-17 c390474980cea47189c1fcc962315b9867c9e2ce

 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/06-simulation/XhsProjectSimulationCorePage.cs

@@ -101,7 +101,6 @@
                    {
                        return;
                    }
                    ApplyGrading();
                };
                _bimfaceCtrl.HydroMouseLeftClickEvent += (obj) =>
                {//鼠标左键点击事件
@@ -238,14 +237,14 @@
                    }
                    _bimfaceCtrl?.ZoomToComponent(parter.Code);
                };
                _propertyCtrl.PropertyValueChangedEvent += (parter) =>
                _propertyCtrl.PropertyValueChangedEvent += (visual) =>
                {
                    if (parter == null)
                    if (visual == null)
                    {
                        return;
                    }
                    UpdateVisualListCtrl();
                    AutoApplyGrading();
                    ApplyGradingResultList(visual);
                };
                _propertyCtrl.MarkPropertyValueChangedEvent += (visual) =>
                {
@@ -341,8 +340,6 @@
        }

        #endregion



        #region 自动匹配

@@ -495,8 +492,6 @@

        #endregion



        #region 保存信息

        //保存
@@ -527,10 +522,6 @@
        }

        #endregion





        #region 批量配置

@@ -1022,8 +1013,6 @@

        #endregion



        #region 构件查询

        //查询组件
@@ -1264,10 +1253,10 @@

        #region 颜色配置

        //所有分级列表
        //所有颜色分级配置列表
        private List<HydroGradingVmo> _allGradingList = null;

        //获取分级列表
        //获取颜色分级配置列表
        private async Task<List<HydroGradingVmo>> GetGradingList()
        {
            if (_hydroInfo == null)
@@ -1276,36 +1265,13 @@
            }
            if (_allGradingList == null)
            {
                _allGradingList = await BLLFactory<Yw.BLL.HydroGrading>.Instance.GetByModelID(_hydroInfo.ID);
                if (_allGradingList == null || _allGradingList.Count < 1)
                {
                    var config = Yw.Settings.HydroParasHelper.Hydro.Grading;
                    if (config != null && config.Items != null && config.Items.Count > 0)
                    {
                        _allGradingList = new List<HydroGradingVmo>();
                        config.Items.ForEach(x =>
                        {
                            var vmo = new HydroGradingVmo()
                            {
                                ModelID = _hydroInfo.ID,
                                Catalog = x.Catalog,
                                PropName = x.PropName,
                                SetValue = x.SetValue,
                                MinValue = x.MinValue,
                                MaxValue = x.MaxValue,
                                Color = x.Color,
                                SortCode = config.Items.IndexOf(x)
                            };
                            _allGradingList.Add(vmo);
                        });
                    }
                }
                _allGradingList = await HydroGradingHelper.GetGradingList(_hydroInfo);
            }
            return _allGradingList;
        }

        //显示配置颜色分级窗体
        private async void ShowSetGradingDlg()
        //显示颜色分级窗体
        private async void ShowGradingDlg()
        {
            if (_hydroInfo == null)
            {
@@ -1317,10 +1283,12 @@
            dlg.ReloadDataEvent += (list) =>
            {
                _allGradingList = list;
                ApplyGradingResultList(false);
            };
            dlg.ApplyDataEvent += (catalog, propName) =>
            {
                ApplyGrading(catalog, propName);
                UpdateGradingApplyList(catalog, propName);
                ApplyGradingResultList(false);
            };
            dlg.ShowDialog();
        }
@@ -1328,7 +1296,7 @@
        //配置颜色分级
        private void barBtnGradingSet_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowSetGradingDlg();
            ShowGradingDlg();
        }

        #endregion
@@ -1341,818 +1309,35 @@
        //获取颜色分级应用列表
        private List<HydroGradingApplyViewModel> GetGradingApplyList()
        {
            if (_hydroInfo == null)
            {
                return default;
            }
            if (_allGradingApplyList == null)
            {
                _allGradingApplyList = new List<HydroGradingApplyViewModel>();

                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
                {
                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
                    {
                        Code = Yw.Hydro.ParterCatalog.Pump,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Pump),
                        PropName = Yw.Hydro.ParterProp.LinkStatus
                    });
                }
                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
                {
                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
                    {
                        Code = Yw.Hydro.ParterCatalog.Valve,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Valve),
                        PropName = Yw.Hydro.ParterProp.LinkStatus
                    });
                }
                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                {
                    _allGradingApplyList.Add(new HydroGradingApplyViewModel()
                    {
                        Code = Yw.Hydro.ParterCatalog.Pipe,
                        Name = Yw.WinFrmUI.HydroParterCatalogHelper.GetName(Yw.Hydro.ParterCatalog.Pipe),
                        PropName = HydroVisualCalcuProp.CalcuFlow
                    });
                }
                _allGradingApplyList = HydroGradingHelper.GetApplyList(_hydroInfo);
            }
            return _allGradingApplyList;
        }

        //获取颜色分级应用结果列表
        private async Task<List<HydroGradingApplyResultViewModel>> GetGradingApplyResultList()
        //更新颜色分级应用列表
        private void UpdateGradingApplyList(string catalog, string propName)
        {
            if (_hydroInfo == null)
            {
                return default;
            }

            //所有分级列表
            var allGradingList = await GetGradingList();
            if (allGradingList == null || allGradingList.Count < 1)
            {
                return default;
            }

            //所有分级应用列表
            var allGradingApplyList = GetGradingApplyList();
            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
            {
                return default;
                return;
            }

            //所有计算结果列表
            var allCalcuResultList = GetCalcuResultList();

            //所有应用结果列表
            var allGradingApplyResultList = new List<HydroGradingApplyResultViewModel>();
            allGradingApplyList.ForEach(x =>
            {
                var allCatalogGradingList = allGradingList.Where(t => t.Catalog == x.Code).ToList();
                if (allCatalogGradingList != null || allCatalogGradingList.Count > 0)
                {
                    switch (x.Code)
                    {
                        case Yw.Hydro.ParterCatalog.Pump:
                            {
                                if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
                                {
                                    foreach (var pump in _hydroInfo.Pumps)
                                    {
                                        switch (x.PropName)
                                        {
                                            case Yw.Hydro.ParterProp.LinkStatus:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var grading = gradingList.Meet(pump.LinkStatus);
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pump.Code,
                                                                Color = grading.Color
                                                            };
                                                            allGradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pump.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ParterCatalog.Valve:
                            {
                                if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
                                {
                                    foreach (var valve in _hydroInfo.Valves)
                                    {
                                        switch (x.PropName)
                                        {
                                            case Yw.Hydro.ParterProp.LinkStatus:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var grading = gradingList.Meet(valve.LinkStatus);
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = valve.Code,
                                                                Color = grading.Color
                                                            };
                                                            allGradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = valve.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        case Yw.Hydro.ParterCatalog.Pipe:
                            {
                                if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                                {
                                    foreach (var pipe in _hydroInfo.Pipes)
                                    {
                                        switch (x.PropName)
                                        {
                                            case HydroVisualCalcuProp.CalcuFlow:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuFlow.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuVelocity:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuVelocity.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            case HydroVisualCalcuProp.CalcuHeadLoss:
                                                {
                                                    var gradingList = allCatalogGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                                    if (gradingList != null && gradingList.Count > 0)
                                                    {
                                                        var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                        if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                        {
                                                            if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                            {
                                                                var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                                if (grading != null)
                                                                {
                                                                    var result = new HydroGradingApplyResultViewModel()
                                                                    {
                                                                        Code = pipe.Code,
                                                                        Color = grading.Color
                                                                    };
                                                                    allGradingApplyResultList.Add(result);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                break;
                                            default: break;
                                        }
                                    }
                                }
                            }
                            break;
                        default: break;
                    }
                }
            });

            return allGradingApplyResultList;
        }

        //获取颜色分级应用结果列表
        private async Task<List<HydroGradingApplyResultViewModel>> GetGradingApplyResultList(string catalog, string propName)
        {
            if (_hydroInfo == null)
            {
                return default;
            }

            //所有分级列表
            var allGradingList = await GetGradingList();
            if (allGradingList == null || allGradingList.Count < 1)
            {
                return default;
            }
            var currentGradingList = allGradingList.Where(x => x.Catalog == catalog).ToList();
            if (currentGradingList.Count < 1)
            {
                return default;
            }

            //所有分级应用列表
            var allGradingApplyList = GetGradingApplyList();
            if (allGradingApplyList == null || allGradingApplyList.Count < 1)
            {
                return default;
            }

            //当前分级应用
            var gradingApply = allGradingApplyList.Find(x => x.Code == catalog);
            if (gradingApply == null)
            {
                return default;
            }
            gradingApply.PropName = propName;

            //所有计算结果
            var allCalcuResultList = GetCalcuResultList();

            //应用结果列表
            var gradingApplyResultList = new List<HydroGradingApplyResultViewModel>();

            switch (catalog)
            {
                case Yw.Hydro.ParterCatalog.Pump:
                    {
                        if (_hydroInfo.Pumps != null && _hydroInfo.Pumps.Count > 0)
                        {
                            foreach (var pump in _hydroInfo.Pumps)
                            {
                                switch (propName)
                                {
                                    case Yw.Hydro.ParterProp.LinkStatus:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var grading = gradingList.Meet(pump.LinkStatus);
                                                if (grading != null)
                                                {
                                                    var result = new HydroGradingApplyResultViewModel()
                                                    {
                                                        Code = pump.Code,
                                                        Color = grading.Color
                                                    };
                                                    gradingApplyResultList.Add(result);
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuFlow:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuFlow.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pump.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuVelocity:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuVelocity.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pump.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuHeadLoss:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pump.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pump.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    default: break;
                                }
                            }
                        }
                    }
                    break;
                case Yw.Hydro.ParterCatalog.Valve:
                    {
                        if (_hydroInfo.Valves != null && _hydroInfo.Valves.Count > 0)
                        {
                            foreach (var valve in _hydroInfo.Valves)
                            {
                                switch (propName)
                                {
                                    case Yw.Hydro.ParterProp.LinkStatus:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == Yw.Hydro.ParterProp.LinkStatus).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var grading = gradingList.Meet(valve.LinkStatus);
                                                if (grading != null)
                                                {
                                                    var result = new HydroGradingApplyResultViewModel()
                                                    {
                                                        Code = valve.Code,
                                                        Color = grading.Color
                                                    };
                                                    gradingApplyResultList.Add(result);
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuFlow:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuFlow.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = valve.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuVelocity:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuVelocity.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = valve.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuHeadLoss:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == valve.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = valve.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    default: break;
                                }
                            }
                        }
                    }
                    break;
                case Yw.Hydro.ParterCatalog.Pipe:
                    {
                        if (_hydroInfo.Pipes != null && _hydroInfo.Pipes.Count > 0)
                        {
                            foreach (var pipe in _hydroInfo.Pipes)
                            {
                                switch (propName)
                                {
                                    case HydroVisualCalcuProp.CalcuFlow:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuFlow).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuFlow.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuFlow.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pipe.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuVelocity:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuVelocity).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuVelocity.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuVelocity.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pipe.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    case HydroVisualCalcuProp.CalcuHeadLoss:
                                        {
                                            var gradingList = currentGradingList.Where(x => x.PropName == HydroVisualCalcuProp.CalcuHeadLoss).OrderBy(t => t.SortCode).ToList();
                                            if (gradingList != null && gradingList.Count > 0)
                                            {
                                                var calcuResult = allCalcuResultList?.Find(t => t.Code == pipe.Code);
                                                if (calcuResult is HydroCalcuLinkResult calcuLinkResult)
                                                {
                                                    if (calcuLinkResult.CalcuHeadLoss.HasValue)
                                                    {
                                                        var grading = gradingList.Meet(Math.Abs(calcuLinkResult.CalcuHeadLoss.Value));
                                                        if (grading != null)
                                                        {
                                                            var result = new HydroGradingApplyResultViewModel()
                                                            {
                                                                Code = pipe.Code,
                                                                Color = grading.Color
                                                            };
                                                            gradingApplyResultList.Add(result);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        break;
                                    default: break;
                                }
                            }
                        }
                    }
                    break;
                default: break;
            }

            return gradingApplyResultList;
        }

        //颜色分级是否应用了
        private bool _isGradingApply = false;
        //颜色分级应用编码列表
        private List<string> _allGradingApplyCodeList = null;

        //应用颜色分级
        private async void ApplyGrading()
        {
            if (_hydroInfo == null)
            var apply = allGradingApplyList.Find(x => x.Catalog == catalog);
            if (apply == null)
            {
                return;
            }
            _isGradingApply = true;
            var allGradingApplyResultList = await GetGradingApplyResultList();
            if (allGradingApplyResultList == null || allGradingApplyResultList.Count < 1)
            {
                CancelApplyGrading();
                return;
            }
            var objGroupList = allGradingApplyResultList.GroupBy(x => x.Color).ToList();
            objGroupList.ForEach(async x =>
            {
                await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
            });
            _allGradingApplyCodeList = allGradingApplyResultList.Select(x => x.Code).Distinct().ToList();
            apply.PropName = propName;
        }

        //应用颜色分级
        private async void ApplyGrading(string catalog, string propName)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            _isGradingApply = true;
            var allGradingApplyResultList = await GetGradingApplyResultList(catalog, propName);
            if (allGradingApplyResultList == null || allGradingApplyResultList.Count < 1)
            {
                return;
            }
            var objGroupList = allGradingApplyResultList.GroupBy(x => x.Color).ToList();
            objGroupList.ForEach(async x =>
            {
                await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1);
            });
            var codeList = allGradingApplyResultList.Select(x => x.Code);
            if (_allGradingApplyCodeList == null)
            {
                _allGradingApplyCodeList = new List<string>();
            }
            _allGradingApplyCodeList.AddRange(codeList);
            _allGradingApplyCodeList = _allGradingApplyCodeList.Distinct().ToList();
        }

        //自动应用颜色分级
        private void AutoApplyGrading()
        {
            if (!_isGradingApply)
            {
                return;
            }
            ApplyGrading();
        }

        //取消应用颜色分级
        private async void CancelApplyGrading()
        {
            if (_hydroInfo == null)
            {
                return;
            }
            _isGradingApply = false;
            if (_allGradingApplyCodeList != null && _allGradingApplyCodeList.Count > 0)
            {
                await _bimfaceCtrl?.RestoreComponentsColor(_allGradingApplyCodeList);
            }
        }

        //显示应用颜色分级窗体
        private void ShowApplyGradingDlg()
        //显示颜色分级应用窗体
        private void ShowGradingApplyDlg()
        {
            if (_hydroInfo == null)
            {
@@ -2168,7 +1353,7 @@
            dlg.ReloadDataEvent += (obj) =>
            {
                _allGradingApplyList = obj;
                ApplyGrading();
                ApplyGradingResultList(false);
            };
            dlg.ShowDialog();
        }
@@ -2176,13 +1361,122 @@
        //应用颜色分级
        private void barBtnGradingApply_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            ShowApplyGradingDlg();
            ShowGradingApplyDlg();
        }

        //取消应用分级
        private void batBtnCancelGradingApply_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        #endregion

        #region 应用结果

        //所有颜色分级结果列表
        private List<HydroGradingResultViewModel> _allGradingResultList = null;

        //获取颜色分级结果列表
        //UseCache是否使用缓存
        private async Task<List<HydroGradingResultViewModel>> GetGradingResultList(bool useCache = true)
        {
            CancelApplyGrading();
            if (_hydroInfo == null)
            {
                return default;
            }
            var allGradingList = await GetGradingList();
            var allGradingApplyList = GetGradingApplyList();
            var allCalcuResultList = GetCalcuResultList();
            if (!useCache)
            {
                _allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
            }
            if (_allGradingResultList == null)
            {
                _allGradingResultList = HydroGradingHelper.GetResultList(_hydroInfo, allGradingList, allGradingApplyList, allCalcuResultList);
            }
            return _allGradingResultList;
        }

        #endregion

        #region 结果展示

        //颜色分级是否显示
        private bool _isGradingVisible = false;

        //应用颜色分级结果列表
        //UseCache是否使用缓存
        private async void ApplyGradingResultList(bool useCache = true)
        {
            if (_hydroInfo == null)
            {
                return;
            }
            var allGradingResultList = await GetGradingResultList(useCache);
            if (allGradingResultList == null || allGradingResultList.Count < 1)
            {
                return;
            }
            if (_isGradingVisible)
            {
                var groupList = allGradingResultList.GroupBy(x => x.Color).ToList();
                groupList.ForEach(async x => await _bimfaceCtrl?.OverrideComponentsColor(x.Select(t => t.Code).Distinct().ToList(), x.Key, 1));
            }
            else
            {
                var codes = allGradingResultList.Select(x => x.Code).Distinct().ToList();
                await _bimfaceCtrl?.RestoreComponentsColor(codes);
            }
        }

        //应用颜色分级结果列表
        private async void ApplyGradingResultList(Yw.Model.HydroVisualInfo visual)
        {
            if (visual == null)
            {
                return;
            }
            var allGradingList = await GetGradingList();
            var allGradingApplyList = GetGradingApplyList();
            var allGradingResultList = await GetGradingResultList(true);
            var allCalcuResultList = GetCalcuResultList(true);
            var oldResult = allGradingResultList?.Find(x => x.Code == visual.Code);
            if (oldResult != null)
            {
                allGradingResultList.Remove(oldResult);
            }
            var newResult = HydroGradingHelper.GetResult(visual, allGradingList, allGradingApplyList, allCalcuResultList);
            if (newResult != null)
            {
                allGradingResultList.Add(newResult);
            }
            if (_isGradingVisible)
            {
                if (newResult == null)
                {
                    if (oldResult != null)
                    {
                        await _bimfaceCtrl?.RestoreComponentsColor(oldResult.Code);
                    }
                }
                else
                {
                    await _bimfaceCtrl?.OverrideComponentsColor(newResult.Code, newResult.Color, 1);
                }
            }
        }

        //应用颜色分级结果列表
        private void ApplyGradingResultList(List<Yw.Model.HydroVisualInfo> visualList)
        {
            if (visualList == null || visualList.Count < 1)
            {
                return;
            }
            visualList.ForEach(x => ApplyGradingResultList(x));
        }

        //颜色分级展示
        private void barCkGrading_CheckedChanged(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
        {
            _isGradingVisible = this.barCkGrading.Checked;
            ApplyGradingResultList(true);
        }

        #endregion
@@ -2566,7 +1860,7 @@
                {
                    UpdateMarkList(visualList);
                    UpdateSelectedProperty();
                    AutoApplyGrading();
                    ApplyGradingResultList();
                };
            }
            return _visualListCtrl;
@@ -3290,7 +2584,7 @@
                    ShowCalcuFailedCtrl();
                    TipFormHelper.ShowError("计算失败！");
                }
                AutoApplyGrading();
                ApplyGradingResultList(false);
                UpdateVisualListCtrl();
                ShowSelectedProperty();
            };
@@ -3490,5 +2784,6 @@




    }
}