水力模块联动修改

lixiaojun

2024-12-30 c22cc4c60e9ff156fc25b39a5c024cc758df354b

 WinFrmUI/HStation.WinFrmUI.Xhs.Core/03-simulation/00-core/04-monitor/02-value/SimulationMonitorValueHelper.cs

@@ -1,4 +1,6 @@
using Yw.Vmo;
using DevExpress.Xpo.Helpers;
using Yw.Hydro;
using Yw.Vmo;

namespace HStation.WinFrmUI
{
@@ -10,75 +12,129 @@
        /// <summary>
        /// 
        /// </summary>
        public SimulationMonitorValueHelper(SimulationVisualListHelper visualListHelper, SimulationMonitorHelper monitorHelper)
        public SimulationMonitorValueHelper
            (
                SimulationVisualListHelper visualListHelper,
                SimulationMonitorHelper monitorHelper,
                SimulationCalcuResultHelper calcuResultHelper
            )
        {
            _visualListHelper = visualListHelper;
            _monitorHelper = monitorHelper;
            _calcuResultHelper = calcuResultHelper;
            _calcuResultHelper.InitialEvent += async () => await Update();
        }

        private SimulationVisualListHelper _visualListHelper = null;//可见列表辅助类
        private SimulationMonitorHelper _monitorHelper = null;//监测点辅助类     
        private List<HydroMonitorValueViewModel> _allMonitorValueList = null;//所有监测值列表
        private readonly SimulationVisualListHelper _visualListHelper = null;//可见列表辅助类
        private readonly SimulationMonitorHelper _monitorHelper = null;//监测点辅助类     
        private readonly SimulationCalcuResultHelper _calcuResultHelper = null;//计算结果辅助类
        private List<HydroMonitorValueViewModel> _allList = null;//所有监测值列表

        /// <summary>
        /// 获取
        /// 获取所有
        /// </summary>
        public async Task<List<HydroMonitorValueViewModel>> Get()
        public async Task<List<HydroMonitorValueViewModel>> GetAll()
        {
            if (_allMonitorValueList == null)
            if (_allList == null)
            {
                _allMonitorValueList = new List<HydroMonitorValueViewModel>();
                _allList = new List<HydroMonitorValueViewModel>();
                var allVisualDict = _visualListHelper.GetVisualDict();
                if (allVisualDict != null && allVisualDict.Count > 0)
                {
                    var allMonitorList = await _monitorHelper.Get();
                    var allMonitorList = await _monitorHelper.GetAll();
                    if (allMonitorList != null && allMonitorList.Count > 0)
                    {
                        foreach (var monitor in allMonitorList)
                        {
                            if (allVisualDict.ContainsKey(monitor.Relation))
                            if (allVisualDict.ContainsKey(monitor.Parter))
                            {
                                var visual = allVisualDict[monitor.Relation];
                                var vm = new HydroMonitorValueViewModel(monitor, visual);
                                _allMonitorValueList.Add(vm);
                                var visual = allVisualDict[monitor.Parter];
                                double? propValue = null;
                                var calcuVisualResult = _calcuResultHelper.GetVisual(monitor.Parter);
                                if (calcuVisualResult != null)
                                {
                                    propValue = calcuVisualResult.GetCalcuValue(monitor.PropName);
                                }
                                var vm = new HydroMonitorValueViewModel(monitor, visual, propValue);
                                _allList.Add(vm);
                            }
                        }
                    }
                }
            }
            return _allMonitorValueList;
            return _allList;
        }

        /// <summary>
        /// 获取对接列表
        /// </summary>
        public async Task<List<HydroMonitorValueViewModel>> GetDockingList()
        {
            var all = await GetAll();
            return all.Where(x => x.Vmo.SourceType == eSourceType.Docking).ToList();
        }

        /// <summary>
        /// 获取分析列表
        /// </summary>
        public async Task<List<HydroMonitorValueViewModel>> GetAnalyseList()
        {
            var all = await GetAll();
            return all.Where(x => x.Vmo.SourceType == eSourceType.Analyse).ToList();
        }

        /// <summary>
        /// 更新
        /// </summary>
        public async void Update(string code, List<HydroMonitorVmo> monitorList)
        public async Task Update()
        {
            var visual = _visualListHelper.GetVisual(code);
            if (visual == null)
            var all = await GetAll();
            foreach (var item in all)
            {
                return;
                if (!item.PropValue.HasValue)
                {
                    var calcuVisualResult = _calcuResultHelper.GetVisual(item.Vmo.Parter);
                    if (calcuVisualResult != null)
                    {
                        var propValue = calcuVisualResult.GetCalcuValue(item.Vmo.PropName);
                        if (propValue.HasValue)
                        {
                            item.UpdatePropValue(propValue.Value);
                        }
                    }
                }
            }
        }

            var allMonitorValueList = await Get();
            var monitorValueList = allMonitorValueList.Where(x => x.Vmo.Relation == code).ToList();
            monitorValueList?.ForEach(x =>
        /// <summary>
        /// 更新
        /// </summary>
        public async Task Update(string code, eSourceType sourceType, List<HydroMonitorValueViewModel> valueList)
        {
            var all = await GetAll();
            all.RemoveAll(x => x.Vmo.Parter == code && x.Vmo.SourceType == sourceType);
            if (valueList != null && valueList.Count > 0)
            {
                var result = monitorList?.Exists(t => t.Relation == x.Vmo.Relation && t.PropName == x.Vmo.PropName);
                if (!(result.HasValue && result.Value))
                {
                    allMonitorValueList.Remove(x);
                }
            });
            monitorList?.ForEach(x =>
            {
                var result = monitorValueList?.Exists(t => t.Vmo.Relation == x.Relation && t.Vmo.PropName == x.PropName);
                if (!(result.HasValue && result.Value))
                {
                    var vm = new HydroMonitorValueViewModel(x, visual);
                    allMonitorValueList.Add(vm);
                }
            });
                all.AddRange(valueList);
            }
        }

        /// <summary>
        /// 重置
        /// </summary>
        public async Task Reset(List<HydroWorkingMonitorViewModel> allWorkingMonitorList)
        {
            var all = await GetAll();
            all.UpdateMonitorValue(allWorkingMonitorList);
        }

        /// <summary>
        /// 重置
        /// </summary>
        public async void Reset(string monitorInfo)
        {
            var allMonitorValueList = await GetAll();
            allMonitorValueList.UpdateMonitorValue(monitorInfo);
        }