处理冲突

lixiaojun

2024-10-12 a8ccc992964272f6a74631e8c164e8c91e5cb6d4

 WinFrmUI/HStation.WinFrmUI.Xhs.Core/00-core/AssetsMatchingParasHelper.cs

@@ -19,7 +19,6 @@
            }
            var input = new AssetsMatchingViewModel();


            //水泵
            input.PumpMatchingList = hydroInfo.Pumps?.Select(x => Create(hydroInfo, x)).ToList();

@@ -30,7 +29,7 @@
            input.PipeMatchingList = hydroInfo.Pipes?.Select(x => Create(hydroInfo, x)).ToList();

            //弯头
            input.ElbowsMatchingList = hydroInfo.Elbows?.Select(x => Create(hydroInfo, x)).ToList();
            input.ElbowMatchingList = hydroInfo.Elbows?.Select(x => Create(hydroInfo, x)).ToList();

            //三通
            input.ThreelinkMatchingList = hydroInfo.Threelinks?.Select(x => Create(hydroInfo, x)).ToList();
@@ -210,6 +209,8 @@

        #endregion

        #region 应用

        /// <summary>
        /// 应用资产自动匹配ViewModel
        /// </summary>
@@ -227,389 +228,58 @@
            bool result = false;

            //水泵
            if (output.PumpMatchingList != null && output.PumpMatchingList.Count > 0)
            output.PumpMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Pumps != null && hydroInfo.Pumps.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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);
                                        pump.CurveQH = curveqh.Code;
                                    }
                                    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);
                                        pump.CurveQP = curveqp.Code;
                                    }
                                    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);
                                        pump.CurveQE = curveqe.Code;
                                    }
                                    else
                                    {
                                        if (!curveqe.DbLocked)
                                        {
                                            curveqe.DbId = pumpMatching.MatchingDbId;
                                            curveqe.CurveData = pumpMatching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                        }
                                    }

                                }
                                result = true;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            //阀门
            if (output.ValveMatchingList != null && output.PumpMatchingList.Count > 0)
            output.ValveMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Valves != null && hydroInfo.Valves.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            //管道
            if (output.PipeMatchingList != null && output.PipeMatchingList.Count > 0)
            output.PipeMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Pipes != null && hydroInfo.Pipes.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            //弯头
            if (output.ElbowsMatchingList != null && output.ElbowsMatchingList.Count > 0)
            output.ElbowMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Elbows != null && hydroInfo.Elbows.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            //三通
            if (output.ThreelinkMatchingList != null && output.ThreelinkMatchingList.Count > 0)
            output.ThreelinkMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Threelinks != null && hydroInfo.Threelinks.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            //四通
            if (output.FourlinkMatchingList != null && output.FourlinkMatchingList.Count > 0)
            output.FourlinkMatchingList?.ForEach(x =>
            {
                if (hydroInfo.Fourlinks != null && hydroInfo.Fourlinks.Count > 0)
                if (Apply(hydroInfo, x))
                {
                    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;
                            }
                        }
                    }
                    result = true;
                }
            }
            });

            return result;
        }
@@ -617,57 +287,57 @@
        /// <summary>
        /// 应用泵自动匹配ViewModel
        /// </summary>
        public static bool ApplyPump(Yw.Model.HydroModelInfo hydroInfo, PumpMatchingViewModel pumpMatching)
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, PumpMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (pumpMatching == null)
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var pump = hydroInfo.Pumps?.Find(x => x.Code == pumpMatching.Code);
            var pump = hydroInfo.Pumps?.Find(x => x.Code == matching.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;
                pump.DbLocked = matching.DbLocked;
                pump.ModelType = matching.ModelType;
                pump.RatedP = matching.RatedP;
                pump.RatedQ = matching.RatedQ;
                pump.RatedH = matching.RatedH;
                pump.RatedN = matching.RatedN;

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

                    if (!string.IsNullOrEmpty(pumpMatching.MatchingCurveDbId))
                    if (!string.IsNullOrEmpty(matching.MatchingCurveDbId))
                    {
                        //流量扬程曲线
                        var curveqh = hydroInfo.Curves?.Find(x => x.Code == pump.CurveQH);
@@ -679,9 +349,9 @@
                            curveqh.Name = "匹配";
                            curveqh.ModelType = string.Empty;
                            curveqh.DbLocked = false;
                            curveqh.DbId = pumpMatching.MatchingCurveDbId;
                            curveqh.DbId = matching.MatchingCurveDbId;
                            curveqh.CurveType = Yw.WinFrmUI.HydroCurve.PumpQH;
                            curveqh.CurveData = pumpMatching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            curveqh.CurveData = matching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
@@ -693,8 +363,8 @@
                        {
                            if (!curveqh.DbLocked)
                            {
                                curveqh.DbId = pumpMatching.MatchingDbId;
                                curveqh.CurveData = pumpMatching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                curveqh.DbId = matching.MatchingDbId;
                                curveqh.CurveData = matching.MatchingCurveQH?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

@@ -708,9 +378,9 @@
                            curveqp.Name = "匹配";
                            curveqp.ModelType = string.Empty;
                            curveqp.DbLocked = false;
                            curveqp.DbId = pumpMatching.MatchingCurveDbId;
                            curveqp.DbId = matching.MatchingCurveDbId;
                            curveqp.CurveType = Yw.WinFrmUI.HydroCurve.PumpQP;
                            curveqp.CurveData = pumpMatching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            curveqp.CurveData = matching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
@@ -722,8 +392,8 @@
                        {
                            if (!curveqp.DbLocked)
                            {
                                curveqp.DbId = pumpMatching.MatchingDbId;
                                curveqp.CurveData = pumpMatching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                curveqp.DbId = matching.MatchingDbId;
                                curveqp.CurveData = matching.MatchingCurveQP?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

@@ -737,9 +407,9 @@
                            curveqe.Name = "匹配";
                            curveqe.ModelType = string.Empty;
                            curveqe.DbLocked = false;
                            curveqe.DbId = pumpMatching.MatchingCurveDbId;
                            curveqe.DbId = matching.MatchingCurveDbId;
                            curveqe.CurveType = Yw.WinFrmUI.HydroCurve.PumpQE;
                            curveqe.CurveData = pumpMatching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            curveqe.CurveData = matching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            if (hydroInfo.Curves == null)
                            {
                                hydroInfo.Curves = new List<Yw.Model.HydroCurveInfo>();
@@ -751,12 +421,13 @@
                        {
                            if (!curveqe.DbLocked)
                            {
                                curveqe.DbId = pumpMatching.MatchingDbId;
                                curveqe.CurveData = pumpMatching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                                curveqe.DbId = matching.MatchingDbId;
                                curveqe.CurveData = matching.MatchingCurveQE?.Select(x => new Yw.Model.Hydro.CurvePoint(x.X, x.Y)).ToList();
                            }
                        }

                    }

                    result = true;
                }
            }
@@ -764,6 +435,292 @@
            return result;
        }

        /// <summary>
        /// 应用阀门自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ValveMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var valve = hydroInfo.Valves?.Find(x => x.Code == matching.Code);
            if (valve != null)
            {
                valve.DbLocked = matching.DbLocked;
                valve.ModelType = matching.ModelType;
                valve.Diameter = matching.Diameter;
                valve.Material = matching.Material;
                valve.MinorLoss = matching.MinorLoss;
                valve.ValveType = matching.ValveType;
                //valve.ValveSetting = matching.ValveSetting;

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

        /// <summary>
        /// 应用管道自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, PipeMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var pipe = hydroInfo.Pipes?.Find(x => x.Code == matching.Code);
            if (pipe != null)
            {
                pipe.DbLocked = matching.DbLocked;
                pipe.ModelType = matching.ModelType;
                pipe.Diameter = matching.Diameter;
                pipe.Material = matching.Material;
                pipe.Roughness = matching.Roughness;
                pipe.MinorLoss = matching.MinorLoss;

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

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用弯头自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ElbowMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var elbow = hydroInfo.Elbows?.Find(x => x.Code == matching.Code);
            if (elbow != null)
            {
                elbow.DbLocked = matching.DbLocked;
                elbow.ModelType = matching.ModelType;
                elbow.Caliber = matching.Caliber;
                elbow.Material = matching.Material;
                elbow.MinorLoss = matching.MinorLoss;

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

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用三通自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, ThreelinkMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var threelink = hydroInfo.Threelinks?.Find(x => x.Code == matching.Code);
            if (threelink != null)
            {
                threelink.DbLocked = matching.DbLocked;
                threelink.ModelType = matching.ModelType;
                threelink.Caliber = matching.Caliber;
                threelink.Material = matching.Material;
                threelink.MinorLoss = matching.MinorLoss;

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

                    result = true;
                }
            }
            return result;
        }

        /// <summary>
        /// 应用四通自动匹配ViewModel
        /// </summary>
        public static bool Apply(Yw.Model.HydroModelInfo hydroInfo, FourlinkMatchingViewModel matching)
        {
            if (hydroInfo == null)
            {
                return false;
            }
            if (matching == null)
            {
                return false;
            }

            bool result = false;

            var fourlink = hydroInfo.Fourlinks?.Find(x => x.Code == matching.Code);
            if (fourlink != null)
            {
                fourlink.DbLocked = matching.DbLocked;
                fourlink.ModelType = matching.ModelType;
                fourlink.Caliber = matching.Caliber;
                fourlink.Material = matching.Material;
                fourlink.MinorLoss = matching.MinorLoss;

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

                    result = true;
                }
            }
            return result;
        }

        #endregion

        //获取所有编码列表
        private static List<string> GetAllCodeList(Yw.Model.HydroModelInfo hydroInfo)
        {