HStation/XHS.V1.0.git

			@@ -1,4 +1,5 @@
			using System;
			using StackExchange.Profiling.Internal;
			using System;
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			@@ -13,35 +14,73 @@
			{

			//创建资产自动匹配ViewModel
			public static AssetsAutoMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo)
			public static AssetsMatchingViewModel Create(Yw.Model.HydroModelInfo hydroInfo)
			{
			var input = new AssetsAutoMatchingViewModel();
			input.PumpMatchingModels = hydroInfo.Pumps?.Select(x => new PumpMatchingViewModel()
			var input = new AssetsMatchingViewModel();

			//水泵
			input.PumpMatchingList = hydroInfo.Pumps?.Select(x => new PumpMatchingViewModel()
			{
			ID = x.ID,
			Code = x.Code,
			Name = x.Name,
			DbId = x.DbId,
			DbLocked = x.DbLocked,
			ChartDbID = hydroInfo.Curves?.Find(t => t.Code == x.CurveQH)?.DbId,
			ModelType = x.ModelType,
			DbId = x.DbId,
			CurveDbId = hydroInfo.Curves?.Find(t => t.Code == x.CurveQH)?.DbId,
			RatedP = x.RatedP,
			RatedH = x.RatedH,
			RatedN = x.RatedN,
			RatedQ = x.RatedQ,
			}).ToList();
			input.ElbowsMatchingModels = hydroInfo.Elbows?.Select(x => new ElbowsMatchingViewModel()

			//阀门
			input.ValveMatchingList = hydroInfo.Valves?.Select(x => new ValveMatchingViewModel()
			{
			ID = x.ID,
			Name = x.Name,
			Code = x.Code,
			Dbid = x.DbId,
			Name = x.Name,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			Caliber = x.Caliber,
			Material = x.Material
			DbId = x.DbId,
			Diameter = x.Diameter,
			Material = x.Material,
			MinorLoss = x.MinorLoss,
			ValveType = x.ValveType
			}).ToList();
			input.ThreeLinkMatchingModels = hydroInfo.Threelinks?.Select(x => new ThreeLinkMatchingViewModel()

			//管道
			input.PipeMatchingList = hydroInfo.Pipes?.Select(x => new PipeMatchingViewModel()
			{
			ID = x.ID,
			Code = x.Code,
			Name = x.Name,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			DbId = x.DbId,
			Diameter = x.Diameter,
			Material = x.Material,
			Roughness = x.Roughness,
			MinorLoss = x.MinorLoss,
			eAlgorithmType = HStation.Assets.eAlgorithmType.Hazen
			}).ToList();

			//弯头
			input.ElbowsMatchingList = hydroInfo.Elbows?.Select(x => new ElbowsMatchingViewModel()
			{
			ID = x.ID,
			Code = x.Code,
			Name = x.Name,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			DbId = x.DbId,
			Caliber = x.Caliber,
			Material = x.Material,
			MinorLoss = x.MinorLoss
			}).ToList();

			//三通
			input.ThreelinkMatchingList = hydroInfo.Threelinks?.Select(x => new ThreelinkMatchingViewModel()
			{
			ID = x.ID,
			Name = x.Name,
			@@ -52,46 +91,431 @@
			Caliber = x.Caliber,
			Material = x.Material
			}).ToList();
			input.FourLinkMatchingModels = hydroInfo.Fourlinks?.Select(x => new FourLinkMatchingViewModel()

			//四通
			input.FourlinkMatchingList = hydroInfo.Fourlinks?.Select(x => new FourlinkMatchingViewModel()
			{
			ID = x.ID,
			Name = x.Name,
			Code = x.Code,
			Dbid = x.DbId,
			DbId = x.DbId,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			Caliber = x.Caliber,
			Material = x.Material
			}).ToList();
			input.PipeLineMatchingModels = hydroInfo.Pipes?.Select(x => new PipeLineMatchingViewModel()
			{
			ID = x.ID,
			Name = x.Name,
			Code = x.Code,
			DbId = x.DbId,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			Caliber = x.Diameter,//这里是数值
			Material = x.Material
			}).ToList();
			input.ValveMatchingModels = hydroInfo.Pipes?.Select(x => new ValveMatchingViewModel()
			{
			ID = x.ID,
			Name = x.Name,
			Code = x.Code,
			DbId = x.DbId,
			DbLocked = x.DbLocked,
			ModelType = x.ModelType,
			Caliber = x.Diameter,//这里是数值
			Material = x.Material//怎么没有阀门类型
			}).ToList();

			return input;
			}

			//应用资产自动匹配ViewModel
			public static void Apply(Yw.Model.HydroModelInfo hydroInfo, AssetsAutoMatchingViewModel output)
			public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, AssetsMatchingViewModel output)
			{
			if (hydroInfo == null)
			{
			return false;
			}
			if (output == null)
			{
			return false;
			}

			bool result = false;

			//水泵
			if (output.PumpMatchingList != null && output.PumpMatchingList.Count > 0)
			{
			if (hydroInfo.Pumps != null && hydroInfo.Pumps.Count > 0)
			{
			foreach (var pumpMatching in output.PumpMatchingList)
			{
			var pump = hydroInfo.Pumps.Find(x => x.Code == pumpMatching.Code);
			if (pump != null)
			{
			pump.DbLocked = pumpMatching.DbLocked;
			pump.ModelType = pumpMatching.ModelType;
			pump.RatedP = pumpMatching.RatedP;
			pump.RatedQ = pumpMatching.RatedQ;
			pump.RatedH = pumpMatching.RatedH;
			pump.RatedN = pumpMatching.RatedN;

			if (!pump.DbLocked)
			{
			if (!string.IsNullOrEmpty(pumpMatching.MatchingModelType))
			{
			pump.ModelType = pumpMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(pumpMatching.MatchingDbId))
			{
			pump.DbId = pumpMatching.MatchingDbId;
			}
			if (pumpMatching.MatchingRatedP.HasValue)
			{
			pump.RatedP = pumpMatching.MatchingRatedP.Value;
			}
			if (pumpMatching.MatchingRatedQ.HasValue)
			{
			pump.RatedQ = pumpMatching.MatchingRatedQ.Value;
			}
			if (pumpMatching.MatchingRatedH.HasValue)
			{
			pump.RatedH = pumpMatching.MatchingRatedH.Value;
			}
			if (pumpMatching.MatchingRatedN.HasValue)
			{
			pump.RatedN = pumpMatching.MatchingRatedN.Value;
			}

			if (!string.IsNullOrEmpty(pumpMatching.MatchingCurveDbId))
			{
			//流量扬程曲线
			var curveqh = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
			if (curveqh == null)
			{
			curveqh = new Yw.Model.HydroCurveInfo();
			curveqh.Catalog = Yw.Hydro.ParterCatalog.Curve;
			curveqh.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", GetAllCodeList(hydroInfo));
			curveqh.Name = "匹配";
			curveqh.ModelType = string.Empty;
			curveqh.DbLocked = false;
			curveqh.DbId = pumpMatching.MatchingCurveDbId;
			curveqh.CurveType = Yw.WinFrmUI.HydroCurve.PumpQH;
			curveqh.CurveData = pumpMatching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			if (hydroInfo.Curves == null)
			{
			hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
			}
			hydroInfo.Curves.Add(curveqh);
			}
			else
			{
			if (!curveqh.DbLocked)
			{
			curveqh.DbId = pumpMatching.MatchingDbId;
			curveqh.CurveData = pumpMatching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			}
			}

			//流量功率曲线
			var curveqp = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQP);
			if (curveqp == null)
			{
			curveqp = new Yw.Model.HydroCurveInfo();
			curveqp.Catalog = Yw.Hydro.ParterCatalog.Curve;
			curveqp.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", GetAllCodeList(hydroInfo));
			curveqp.Name = "匹配";
			curveqp.ModelType = string.Empty;
			curveqp.DbLocked = false;
			curveqp.DbId = pumpMatching.MatchingCurveDbId;
			curveqp.CurveType = Yw.WinFrmUI.HydroCurve.PumpQP;
			curveqp.CurveData = pumpMatching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			if (hydroInfo.Curves == null)
			{
			hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
			}
			hydroInfo.Curves.Add(curveqp);
			}
			else
			{
			if (!curveqp.DbLocked)
			{
			curveqp.DbId = pumpMatching.MatchingDbId;
			curveqp.CurveData = pumpMatching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			}
			}

			//流量效率曲线
			var curveqe = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQE);
			if (curveqe == null)
			{
			curveqe = new Yw.Model.HydroCurveInfo();
			curveqe.Catalog = Yw.Hydro.ParterCatalog.Curve;
			curveqe.Code = Yw.Untity.UniqueHelper.CreateFromFirst("curve", GetAllCodeList(hydroInfo));
			curveqe.Name = "匹配";
			curveqe.ModelType = string.Empty;
			curveqe.DbLocked = false;
			curveqe.DbId = pumpMatching.MatchingCurveDbId;
			curveqe.CurveType = Yw.WinFrmUI.HydroCurve.PumpQE;
			curveqe.CurveData = pumpMatching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			if (hydroInfo.Curves == null)
			{
			hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
			}
			hydroInfo.Curves.Add(curveqe);
			}
			else
			{
			if (!curveqe.DbLocked)
			{
			curveqe.DbId = pumpMatching.MatchingDbId;
			curveqe.CurveData = pumpMatching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
			}
			}

			}
			}
			}
			}
			}
			}

			//阀门
			if (output.ValveMatchingList != null && output.PumpMatchingList.Count > 0)
			{
			if (hydroInfo.Valves != null && hydroInfo.Valves.Count > 0)
			{
			foreach (var valveMatching in output.ValveMatchingList)
			{
			var valve = hydroInfo.Valves.Find(x => x.Code == valveMatching.Code);
			if (valve != null)
			{
			valve.DbLocked = valveMatching.DbLocked;
			valve.ModelType = valveMatching.ModelType;
			valve.Diameter = valveMatching.Diameter;
			valve.Material = valveMatching.Material;
			valve.MinorLoss = valveMatching.MinorLoss;
			valve.ValveType = valveMatching.ValveType;
			valve.ValveSetting = valveMatching.ValveSetting;

			if (!valve.DbLocked)
			{
			if (!string.IsNullOrEmpty(valveMatching.MatchingModelType))
			{
			valve.ModelType = valveMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(valveMatching.MatchingDbId))
			{
			valve.DbId = valveMatching.MatchingDbId;
			}
			if (valveMatching.MatchingDiameter.HasValue)
			{
			valve.Diameter = valveMatching.MatchingDiameter.Value;
			}
			if (!string.IsNullOrEmpty(valveMatching.MatchingMaterial))
			{
			valve.Material = valveMatching.MatchingMaterial;
			}
			if (valveMatching.MatchingMinorLoss.HasValue)
			{
			valve.MinorLoss = valveMatching.MatchingMinorLoss.Value;
			}
			if (!string.IsNullOrEmpty(valveMatching.MatchingValveType))
			{
			valve.ValveType = valveMatching.MatchingValveType;
			}
			if (!string.IsNullOrEmpty(valveMatching.MatchingValveSetting))
			{
			valve.ValveSetting = valveMatching.MatchingValveSetting;
			}
			result = true;
			}
			}
			}
			}
			}

			//管道
			if (output.PipeMatchingList != null && output.PipeMatchingList.Count > 0)
			{
			if (hydroInfo.Pipes != null && hydroInfo.Pipes.Count > 0)
			{
			foreach (var pipeMatching in output.PipeMatchingList)
			{
			var pipe = hydroInfo.Pipes.Find(x => x.Code == pipeMatching.Code);
			if (pipe != null)
			{
			pipe.DbLocked = pipeMatching.DbLocked;
			pipe.ModelType = pipeMatching.ModelType;
			pipe.Diameter = pipeMatching.Diameter;
			pipe.Material = pipeMatching.Material;
			pipe.Roughness = pipeMatching.Roughness;
			pipe.MinorLoss = pipeMatching.MinorLoss;

			if (!pipe.DbLocked)
			{
			if (!string.IsNullOrEmpty(pipeMatching.MatchingModelType))
			{
			pipe.ModelType = pipeMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(pipeMatching.MatchingDbId))
			{
			pipe.DbId = pipeMatching.MatchingDbId;
			}
			if (pipeMatching.MatchingDiameter.HasValue)
			{
			pipe.Diameter = pipeMatching.MatchingDiameter.Value;
			}
			if (!string.IsNullOrEmpty(pipeMatching.MatchingMaterial))
			{
			pipe.Material = pipeMatching.MatchingMaterial;
			}
			if (pipeMatching.MatchingRoughness.HasValue)
			{
			pipe.Roughness = pipeMatching.MatchingRoughness.Value;
			}
			if (pipeMatching.MatchingMinorLoss.HasValue)
			{
			pipe.MinorLoss = pipeMatching.MatchingMinorLoss.Value;
			}

			result = true;
			}
			}
			}
			}
			}

			//弯头
			if (output.ElbowsMatchingList != null && output.ElbowsMatchingList.Count > 0)
			{
			if (hydroInfo.Elbows != null && hydroInfo.Elbows.Count > 0)
			{
			foreach (var elbowsMatching in output.ElbowsMatchingList)
			{
			var elbows = hydroInfo.Elbows.Find(x => x.Code == elbowsMatching.Code);
			if (elbows != null)
			{
			elbows.DbLocked = elbowsMatching.DbLocked;
			elbows.ModelType = elbowsMatching.ModelType;
			elbows.Caliber = elbowsMatching.Caliber;
			elbows.Material = elbowsMatching.Material;
			elbows.MinorLoss = elbowsMatching.MinorLoss;

			if (!elbows.DbLocked)
			{
			if (!string.IsNullOrEmpty(elbowsMatching.MatchingModelType))
			{
			elbows.ModelType = elbowsMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(elbowsMatching.MatchingDbId))
			{
			elbows.DbId = elbowsMatching.MatchingDbId;
			}
			if (elbowsMatching.MatchingCaliber.HasValue)
			{
			elbows.Caliber = elbowsMatching.MatchingCaliber.Value;
			}
			if (!string.IsNullOrEmpty(elbowsMatching.MatchingMaterial))
			{
			elbows.Material = elbowsMatching.MatchingMaterial;
			}
			if (elbowsMatching.MatchingMinorLoss.HasValue)
			{
			elbows.MinorLoss = elbowsMatching.MatchingMinorLoss.Value;
			}

			result = true;
			}
			}
			}
			}
			}

			//三通
			if (output.ThreelinkMatchingList != null && output.ThreelinkMatchingList.Count > 0)
			{
			if (hydroInfo.Threelinks != null && hydroInfo.Threelinks.Count > 0)
			{
			foreach (var threelinkMatching in output.ThreelinkMatchingList)
			{
			var threelink = hydroInfo.Threelinks.Find(x => x.Code == threelinkMatching.Code);
			if (threelink != null)
			{
			threelink.DbLocked = threelinkMatching.DbLocked;
			threelink.ModelType = threelinkMatching.ModelType;
			threelink.Caliber = threelinkMatching.Caliber;
			threelink.Material = threelinkMatching.Material;
			threelink.MinorLoss = threelinkMatching.MinorLoss;

			if (!threelink.DbLocked)
			{
			if (!string.IsNullOrEmpty(threelinkMatching.MatchingModelType))
			{
			threelink.ModelType = threelinkMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(threelinkMatching.MatchingDbId))
			{
			threelink.DbId = threelinkMatching.MatchingDbId;
			}
			if (threelinkMatching.MatchingCaliber.HasValue)
			{
			threelink.Caliber = threelinkMatching.MatchingCaliber.Value;
			}
			if (!string.IsNullOrEmpty(threelinkMatching.MatchingMaterial))
			{
			threelink.Material = threelinkMatching.MatchingMaterial;
			}
			if (threelinkMatching.MatchingMinorLoss.HasValue)
			{
			threelink.MinorLoss = threelinkMatching.MatchingMinorLoss.Value;
			}

			result = true;
			}
			}
			}
			}
			}

			//四通
			if (output.FourlinkMatchingList != null && output.FourlinkMatchingList.Count > 0)
			{
			if (hydroInfo.Fourlinks != null && hydroInfo.Fourlinks.Count > 0)
			{
			foreach (var fourlinkMatching in output.FourlinkMatchingList)
			{
			var fourlink = hydroInfo.Fourlinks.Find(x => x.Code == fourlinkMatching.Code);
			if (fourlink != null)
			{
			fourlink.DbLocked = fourlinkMatching.DbLocked;
			fourlink.ModelType = fourlinkMatching.ModelType;
			fourlink.Caliber = fourlinkMatching.Caliber;
			fourlink.Material = fourlinkMatching.Material;
			fourlink.MinorLoss = fourlinkMatching.MinorLoss;

			if (!fourlink.DbLocked)
			{
			if (!string.IsNullOrEmpty(fourlinkMatching.MatchingModelType))
			{
			fourlink.ModelType = fourlinkMatching.MatchingModelType;
			}
			if (!string.IsNullOrEmpty(fourlinkMatching.MatchingDbId))
			{
			fourlink.DbId = fourlinkMatching.MatchingDbId;
			}
			if (fourlinkMatching.MatchingCaliber.HasValue)
			{
			fourlink.Caliber = fourlinkMatching.MatchingCaliber.Value;
			}
			if (!string.IsNullOrEmpty(fourlinkMatching.MatchingMaterial))
			{
			fourlink.Material = fourlinkMatching.MatchingMaterial;
			}
			if (fourlinkMatching.MatchingMinorLoss.HasValue)
			{
			fourlink.MinorLoss = fourlinkMatching.MatchingMinorLoss.Value;
			}

			result = true;
			}
			}
			}
			}
			}

			return result;
			}

			//获取所有编码列表
			private static List<string> GetAllCodeList(Yw.Model.HydroModelInfo hydroInfo)
			{
			if (hydroInfo == null)
			{
			return default;
			}
			var allParterList = hydroInfo.GetAllParters();
			return allParterList?.Select(x => x.Code).Distinct().ToList();
			}

			}
			}