using Hydro.Core.Model;
using Hydro.Revit.Model;
using Hydro.Revit;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using HStation.RevitDev.RevitDataExport.Common;
using static Hydro.Core.ObjectEnum;
using HStation.RevitDev.Model.ModelEnum;
using HStation.RevitDev.RevitDataExport.Entity.ElementModels;
using HStation.RevitDev.RevitDataExport.Entity;
using HStation.RevitDev.RevitDataExport.Service;
using HStation.RevitDev.RevitDataExport.Utility;
using Hydro.MapView;
using DevExpress.ClipboardSource.SpreadsheetML;
using System.Drawing;
using Autodesk.Revit.DB;
using Autodesk.Revit.UI;
using HStation.Model;
using System.Data.Linq.Mapping;
using Autodesk.Revit.DB.Plumbing;
using Hydro.CommonBase;
using static HStation.RevitDev.RevitDataExport.Enumerations;
using DevExpress.Utils.Extensions;
using System.Xml.Linq;

namespace HStation.RevitDev.RevitDataExport.Common
{
    public static class NetWorkHelper
    {
        public static CheckModel Check(RevitNetWork model)
        {
            var result = new CheckModel() { Result = true };
            var nodes = new List<string>();
            nodes.AddRange(model.Pipes.Select(c => c.Node2).ToList());
            nodes.AddRange(model.Pipes.Select(c => c.Node1).ToList());
            var otherIds = model.Junctions.Select(c => c.ID).ToList();

            var pipes = model.Pipes.Where(c => string.IsNullOrEmpty(c.Node1) || string.IsNullOrEmpty(c.Node2));
            if (pipes.Any())
            {
                result.Result = false;
                pipes.ToList().ForEach(c =>
                {
                    result.FailList.Add(new FailModel()
                    {
                        ID = c.ID,
                        Name = c.Name,
                        Type = FailType.缺少Node1或Node2连接属性,
                        ModelName = "管道",
                        FailReason = "缺少Node1或Node2连接属性"
                    });

                });
            }

            var nozzles = model.Nozzles.Where(c => !nodes.Contains(c.ID));
            if (nozzles.Any())
            {
                result.Result = false;
                nozzles.ToList().ForEach(c =>
                {
                    result.FailList.Add(new FailModel()
                    {
                        ID = c.ID,
                        Name = c.Name,
                        Type = FailType.喷头只能连接管道,
                        ModelName = "喷淋",
                        FailReason = "喷头只能连接管道"
                    });
                });
            }

            var tank = model.Tanks.Any();
            var reservos = model.Reservos.Any();
            if (!tank)
            {
                result.Result = false;
                result.FailList.Add(new FailModel()
                {
                    ID = "0",
                    Name = "水箱",
                    ModelName = "水箱",
                    Type = FailType.缺少水箱或水池对象,
                    FailReason = "缺少水箱或水池对象"
                });
            }

            return result;

        }
        public static RevitNetWork GetModelList(System.Windows.Forms.TabControl pageContainer)
        {
            var EpaModel = new RevitNetWork();
            foreach (TabPage page in pageContainer.TabPages)
            {
                var pageTitle = page.Text;
                var dgv = page.Controls[0] as DataGridView;
                switch (pageTitle)
                {
                    case "管道":
                        var pipes = GetPipeModel(dgv);
                        EpaModel.AddPipes(pipes);
                        break;
                    case "阀门":
                        var valves = GetValveModel(dgv);
                        EpaModel.AddValves(valves);
                        break;
                    case "喷淋":
                        var nozzle = GetNozzleModel(dgv);
                        EpaModel.AddNozzles(nozzle);
                        break;
                    case "消火栓":
                        var hydrantBoxes = GetHydrantBoxModel(dgv);
                        EpaModel.AddHydrantBoxs(hydrantBoxes);
                        break;
                    case "水泵":
                        var waterPump = GetWaterPumpModel(dgv);
                        EpaModel.AddPumps(waterPump);
                        break;
                    case "水箱":
                        var watertank = GetWaterTankModel(dgv);
                        EpaModel.AddTanks(watertank);
                        break;
                    case "弯头":
                    case "三通":
                    case "四通":
                    case "其他":
                        var other = GetOtherModel(dgv);
                        EpaModel.AddJunctions(other);
                        break;
                }

            }
            return EpaModel;
        }

        public static List<TimePoint> Calc(string InpFullPath)
        {
            //InpFullPath = "d:\\revitinp.inp";
            Epanet2 epanet = new Epanet2();
            var result = new List<TimePoint>();

            int err = 0;
            err = epanet.open(InpFullPath, "", "");
            if (err != 0)
            {
                string errMsg = epanet.geterror();
                throw new Exception($"{errMsg}");

            }

            var calerr = epanet.solveH();
            if (calerr != 0)
            {
                string errMsg = epanet.geterror();
                throw new Exception($"{errMsg}");

            }

            int nodeCount = 0, linkCount = 0;
            epanet.getcount((int)CountType.Node, ref nodeCount);
            epanet.getcount((int)CountType.Link, ref linkCount);

            var sb = new StringBuilder(EpanetBase2_2.MAXID);
            for (int i = 1; i < nodeCount; i++)
            {
                epanet.getnodeid(i, sb);
                var arr = System.Enum.GetValues(typeof(NodeValue));
                for (var j = 0; j < arr.Length; j++)
                {
                    float v = 0;
                    var t = (NodeValue)j;
                    epanet.getnodevalue(i, (int)t, ref v);
                    result.Add(new TimePoint()
                    {
                        Key = t.ToString() + "_" + sb.ToString(),
                        Value = v,
                    });
                }
            }

            for (int i = 1; i < linkCount; i++)
            {
                epanet.getlinkid(i, sb);
                var arr = System.Enum.GetValues(typeof(LinkValue));
                for (var j = 0; j < arr.Length; j++)
                {
                    float v = 0;
                    var t = (LinkValue)j;
                    epanet.getlinkvalue(i, (int)t, ref v);
                    result.Add(new TimePoint()
                    {
                        Key = t.ToString() + "_" + sb.ToString(),
                        Value = v,
                    });
                }
            }
            return result;
        }

        public static MapViewNetWork GetModelList(ExternalCommandData data)
        {
            UIDocument uidoc = data.Application.ActiveUIDocument;
            Document doc = uidoc.Document;
            var EpaModel = new MapViewNetWork();
            var values = Enum.GetValues(typeof(RevitType));
            foreach (var value in values)
            {
                var revitType = (RevitType)value;
                if (revitType.IsRequired())
                {
                    var models = RevitMepElementService.GetElementModels(revitType);

                    switch (revitType)
                    {
                        case RevitType.RFT_Pump:
                            {
                                var subModels = ModelFactory.Convert2Sub<PumbModel2>(models);
                                foreach (var p in subModels)
                                {
                                    var ds = new Dataset(p.编号 + "_Head", null, 2);
                                    p.额定功率 = string.IsNullOrEmpty(p.额定功率) ? "7" : p.额定功率;
                                    p.额定扬程 = string.IsNullOrEmpty(p.额定扬程) ? "10" : p.额定扬程;
                                    p.额定流量 = string.IsNullOrEmpty(p.额定流量) ? "1" : p.额定流量;
                                    p.额定转速 = string.IsNullOrEmpty(p.额定转速) ? "1000" : p.额定转速;
                                    var curve = OnePointHelper.GetQhPtList(double.Parse(p.额定流量), double.Parse(p.额定扬程), double.Parse(p.额定转速));
                                    ds.Data = curve;
                                    EpaModel.dict_dataset.Add(p.编号 + "_Head", ds);
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Links.Add(new Hydro.MapView.PumpViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Node1 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                        Node2 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                                        额定功率 = double.Parse(p.额定功率),
                                        HeadCurve = "PumpDefault",
                                        额定扬程 = double.Parse(p.额定扬程),
                                        额定流量 = double.Parse(p.额定流量),
                                        额定转速 = double.Parse(string.IsNullOrEmpty(p.额定转速) ? "1500" : p.额定转速),
                                        //Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_Blocker:
                            {
                                var subModels = ModelFactory.Convert2Sub<BlockerModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_Converter:
                            {
                                var subModels = ModelFactory.Convert2Sub<ConvertorModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_Elbow:
                            {
                                var subModels = ModelFactory.Convert2Sub<ElbowModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_FourJoint:
                            {
                                var subModels = ModelFactory.Convert2Sub<SiTongModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }


                        case RevitType.RFT_Pipe:
                            {
                                var subModels = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(models);
                                foreach (var p in subModels)
                                {
                                    EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Diameter = float.Parse(string.IsNullOrEmpty(p.直径) ? "1" : p.直径),
                                        Length = float.Parse(string.IsNullOrEmpty(p.长度) ? "0.1" : p.长度) / 1000,
                                        MinorLoss = float.Parse(string.IsNullOrEmpty(p.比摩阻) ? "0.1" : p.比摩阻),
                                        Roughness = float.Parse(string.IsNullOrEmpty(p.压力损失) ? "0.1" : p.压力损失),
                                        Node1 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                        Node2 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_HeatExchanger:
                            {
                                var subModels = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.HeatExchangerModel>(models);
                                foreach (var p in subModels)
                                {
                                    EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Diameter = float.Parse(string.IsNullOrEmpty(p.直径) ? "1" : p.直径),
                                        Length = float.Parse(string.IsNullOrEmpty(p.长度) ? "0.1" : p.长度) / 1000,
                                        MinorLoss = float.Parse(string.IsNullOrEmpty(p.比摩阻) ? "0.1" : p.比摩阻),
                                        Roughness = float.Parse(string.IsNullOrEmpty(p.压力损失) ? "0.1" : p.压力损失),
                                        Node1 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                        Node2 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_WindTurbine:
                            {
                                var subModels = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.ValveModel>(models);
                                foreach (var p in subModels)
                                {
                                    EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Diameter = float.Parse(string.IsNullOrEmpty(p.公称直径) ? "1" : p.公称直径),
                                        Length = 0.1f,// float.Parse(string.IsNullOrEmpty(p.) ? "0" : p.长度) / 1000,
                                        MinorLoss = 0,// float.Parse(string.IsNullOrEmpty(p.比摩阻) ? "0" : p.比摩阻),
                                        Roughness = 0,// float.Parse(string.IsNullOrEmpty(p.压力损失) ? "0" : p.压力损失),
                                        Node1 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                        Node2 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_CoolingTower:
                        case RevitType.RFT_Shower:
                            {
                                var subModels = ModelFactory.Convert2Sub<ShowerModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.NozzleViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                        FlowCoefficient = string.IsNullOrEmpty(p.喷射系数) ? 0 : float.Parse(p.喷射系数),
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_ThreeJoint:
                            {
                                var subModels = ModelFactory.Convert2Sub<SanTongModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y
                                    });
                                }
                                break;
                            }

                        case RevitType.RFT_Valve:
                            {
                                var subModels = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.ValveModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    p.公称直径 = string.IsNullOrEmpty(p.公称直径) ? "1" : p.公称直径;
                                    EpaModel.Nodes.Add(new ValveNodeViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Node1 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                        Node2 = p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                                        Diameter = float.Parse(p.公称直径),
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                        Status = StatusType.OPEN,
                                        Position = new System.Drawing.PointF()
                                        {
                                            X = op.getCenter.x,
                                            Y = op.getCenter.y
                                        }
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_WaterBox:
                            {
                                var subModels = ModelFactory.Convert2Sub<WaterBoxModel>(models);

                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new TankViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                        InitLevel = string.IsNullOrEmpty(p.初始水位) ? 2 : float.Parse(p.初始水位),
                                        MaxLevel = string.IsNullOrEmpty(p.最高水位) ? 5 : float.Parse(p.最高水位),
                                        MinLevel = string.IsNullOrEmpty(p.最低水位) ? 1 : float.Parse(p.最低水位),
                                        Status = StatusType.OPEN,
                                    });
                                }
                                break;
                            }

                        case RevitType.RFT_WaterMeterFlow:
                        case RevitType.RFT_WaterMeterPress:
                        case RevitType.RFT_WaterMeter:
                            {
                                var subModels = ModelFactory.Convert2Sub<WaterMeterModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new MeterViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_WaterPool:
                            {
                                var subModels = ModelFactory.Convert2Sub<WaterPoolModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.AddReservos(new ReservoisModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                        Head = float.Parse(p.总水头),
                                        Status = StatusType.OPEN
                                    });
                                }
                                break;
                            }
                        case RevitType.RFT_FireHydrant:
                            {
                                var subModels = ModelFactory.Convert2Sub<FireHydrantModel>(models);
                                foreach (var p in subModels)
                                {
                                    var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                                    EpaModel.Nodes.Add(new Hydro.MapView.NozzleViewModel()
                                    {
                                        ID = p.编号,
                                        Name = p.名称,
                                        Floor = p.楼层,
                                        Elev = op.getCenter.z,
                                        X = op.getCenter.x,
                                        Y = op.getCenter.y,
                                        FlowCoefficient = string.IsNullOrEmpty(p.喷射系数) ? 0 : float.Parse(p.喷射系数),
                                    });
                                }
                                break;
                            }
                            //case RevitType.RFT_Unknown:
                            //case RevitType.RFT_Others:
                            //    {
                            //        var subModels = ModelFactory.Convert2Others(models);
                            //        foreach (var p in subModels)
                            //        {
                            //            var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                            //            EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                            //            {
                            //                ID = p.编号,
                            //                Name = p.名称,
                            //                Floor = p.楼层,
                            //                Elev = op.getCenter.z,
                            //                X = op.getCenter.x,
                            //                Y = op.getCenter.y
                            //            });
                            //        }
                            //        break;
                            //    }
                    }
                }
            }

            var hem = RevitMepElementService.GetElementModels(RevitType.RFT_HeatExchanger);
            var mtids = RevitMepElementService.GetElementModels(RevitType.RFT_Blocker);
            var gdids = RevitMepElementService.GetElementModels(RevitType.RFT_Pipe);
            var pumpids = RevitMepElementService.GetElementModels(RevitType.RFT_Pump);
            var gdjids = RevitMepElementService.GetElementModels(RevitType.RFT_Converter);
            var subModelshem = ModelFactory.Convert2Sub<HeatExchangerModel>(hem);
            var subModelpump = ModelFactory.Convert2Sub<PumbModel2>(pumpids);
            var modelPipe = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(gdids);
            var pipes = EpaModel.pipes.Where(c => string.IsNullOrEmpty(c.Node1) || string.IsNullOrEmpty(c.Node2)).ToList();
            var nodes = new List<string>();
            var allPipeNodes = modelPipe.Select(c => c.连接构件.Split(',')).ToList();
            var allothers = GetOtherModelLits();
            var allothersids = allothers.Select(c => c.编号).ToList();
            foreach (var item in allPipeNodes)
            {
                nodes.AddRange(item);
            }
            if (pipes.Any())
            {
                pipes.ToList().ForEach(c =>
                {
                    var elemId = new ElementId(int.Parse(c.ID));
                    var elem = doc.GetElement(elemId);

                    var box = BoundingBoxHelper.BoundingBoxSerialize(elem.get_BoundingBox(null));
                    var op = JsonHelper.ToObject<ObjectPosition>(box);
                    EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                    {
                        ID = "1000" + c.ID,
                        Name = "闷头",
                        Elev = op.getCenter.z,
                        X = op.getCenter.x,
                        Y = op.getCenter.y
                    });
                    if (string.IsNullOrEmpty(c.Node1)) c.Node1 = "10000" + c.ID;
                    if (string.IsNullOrEmpty(c.Node2)) c.Node2 = "10000" + c.ID;
                });
            }   //管道未连接修正

            var nozzles = EpaModel.Nozzles.Where(c => !nodes.Contains(c.ID));
            if (nozzles.Any())  //喷头不能直接节点
            {
                nozzles.ToList().ForEach(c =>
                {
                    var gj = EpaModel.Junctions.FirstOrDefault(b => b.ID == c.Node1 || b.ID == c.Node2);
                    if (gj != null)
                    {
                        var gjid = gj.ID;
                        var pipe = EpaModel.Links.FirstOrDefault(b => b.Node1 == gjid || b.Node2 == gjid);
                        c.Node1 = pipe.ID;
                        if (pipe.Node1.Equals(gjid)) pipe.Node1 = c.ID;
                        if (pipe.Node2.Equals(gjid)) pipe.Node2 = c.ID;
                    }
                });
            }

            //节点不能连接节点，并修正

            var allconnectids = string.Join(",", allothers.Select(c => c.连接构件));
            var others = allothers.Where(c => allconnectids.Contains(c.编号)).Select(c => c.编号).ToList();
            //var s = JsonHelper.ToJson(others);
            foreach (var p in others)
            {
                var n = allothers.First(c => c.编号.Equals(p));
                var pr = allothers.First(c => c.连接构件.Contains(n.编号));
                var pi = EpaModel.Links.Where(b => b.Node1.Equals(pr.编号) || b.Node2.Equals(pr.编号) || b.Node1.Equals(n.编号) || b.Node2.Equals(n.编号));
                EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                {
                    ID = n.编号 + "_" + pr.编号,
                    Name = "虚拟管道",
                    Floor = n.楼层,
                    Diameter = pi.FirstOrDefault() == null ? 0f : pi.FirstOrDefault().Diameter,
                    Length = 0.01f,
                    MinorLoss = 0f,
                    Roughness = 0f,
                    Node1 = n.编号,// p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                    Node2 = pr.编号// p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                });
            }



            foreach (var p in subModelshem)
            {
                var node1 = "";
                var node2 = "";
                if (p.连接构件.Contains(","))
                {
                    //if (p.编号 == "823978")
                    //{
                    //    var a = 0;
                    //}
                    var connectids = p.连接构件.Split(',');
                    var pipes1 = new LinkViewModelList();
                    foreach (var item in connectids)
                    {
                        if (mtids.Contains(item))
                        {
                            var ju = EpaModel.Nodes.FirstOrDefault(x => x.ID == item);
                            EpaModel.Nodes.Remove(ju);
                        }

                        if (gdids.Contains(item))
                        {
                            var nwpipe = EpaModel.Links.FirstOrDefault(x => x.ID == item);
                            pipes1.Add(nwpipe);
                        }
                    }
                    if (pipes1.Count == 2)//如果换热器连了两个管道
                    {
                        var item1 = pipes1[0].ID;
                        var pipe1 = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item1 }).FirstOrDefault();
                        var olepipe1 = EpaModel.Links.FirstOrDefault(x => x.ID == item1);
                        var op1 = JsonHelper.ToObject<ObjectPosition>(pipe1.包围框);
                        var jid1 = "2000" + p.编号 + pipe1.编号;
                        olepipe1.Node1 = (olepipe1.Node1 == p.编号) ? jid1 : olepipe1.Node1;
                        olepipe1.Node2 = (olepipe1.Node2 == p.编号) ? jid1 : olepipe1.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid1,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op1.getCenter.z,
                            X = op1.getCenter.x,
                            Y = op1.getCenter.y
                        });
                        node1 = jid1;

                        var item2 = pipes1[1].ID;
                        var pipe2 = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item2 }).FirstOrDefault();
                        var olepipe2 = EpaModel.Links.FirstOrDefault(x => x.ID == item2);
                        var op2 = JsonHelper.ToObject<ObjectPosition>(pipe2.包围框);
                        var jid2 = "2000" + p.编号 + pipe2.编号;
                        olepipe2.Node1 = (olepipe2.Node1 == p.编号) ? jid2 : olepipe2.Node1;
                        olepipe2.Node2 = (olepipe2.Node2 == p.编号) ? jid2 : olepipe2.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid2,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op2.getCenter.z,
                            X = op2.getCenter.x,
                            Y = op2.getCenter.y
                        });
                        node2 = jid2;



                    }
                    if (pipes1.Count == 1)//如果换热器连了一个管道
                    {
                        var item = pipes1[0].ID;
                        var pipe = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item }).FirstOrDefault();
                        var olepipe = EpaModel.Links.FirstOrDefault(x => x.ID == item);
                        var op = JsonHelper.ToObject<ObjectPosition>(pipe.包围框);
                        var jid = "2000" + p.编号 + pipe.编号;
                        olepipe.Node1 = (olepipe.Node1 == p.编号) ? jid : olepipe.Node1;
                        olepipe.Node2 = (olepipe.Node2 == p.编号) ? jid : olepipe.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op.getCenter.z,
                            X = op.getCenter.x,
                            Y = op.getCenter.y
                        });
                        node1 = jid;
                        var ju = EpaModel.Nodes.FirstOrDefault(x => p.连接构件.Contains(x.ID));
                        node2 = ju.ID;
                    }

                    #region old
                    //foreach (var item in connectids)
                    //{
                    //    if (mtids.Contains(item))
                    //    {
                    //        var ju = EpaModel.Nodes.FirstOrDefault(x => x.ID == item);
                    //        EpaModel.Nodes.Remove(ju);
                    //    }
                    //    else if (gdids.Contains(item))
                    //    {
                    //        var pipe = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item }).FirstOrDefault();
                    //        var nwpipe = EpaModel.Links.FirstOrDefault(x => x.ID == item);
                    //        var op = JsonHelper.ToObject<ObjectPosition>(pipe.包围框);
                    //        var jid = "2000" + p.编号 + pipe.编号;
                    //        nwpipe.Node1 = nwpipe.Node1 == p.编号 ? jid : p.编号;
                    //        nwpipe.Node2 = nwpipe.Node2 == p.编号 ? jid : p.编号;
                    //        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                    //        {
                    //            ID = jid,
                    //            Name = "增加临时件",
                    //            Floor = p.楼层,
                    //            Elev = op.getCenter.z,
                    //            X = op.getCenter.x,
                    //            Y = op.getCenter.y
                    //        });

                    //        node1 = string.IsNullOrEmpty(node1) ? jid : node1;
                    //        node2 = !string.IsNullOrEmpty(node1) && !string.IsNullOrEmpty(node2) ? jid : node2;
                    //    }
                    //    else
                    //    {
                    //        node2 = item;
                    //    }
                    //}
                    #endregion
                }
                else
                {
                    node1 = p.连接构件;
                    node2 = p.连接构件;
                }
                EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                {
                    ID = p.编号,
                    Name = p.名称,
                    Floor = p.楼层,
                    Diameter = float.Parse(string.IsNullOrEmpty(p.直径) ? "0" : p.直径),
                    Length = float.Parse(string.IsNullOrEmpty(p.长度) ? "0" : p.长度) / 1000,
                    MinorLoss = float.Parse(string.IsNullOrEmpty(p.比摩阻) ? "0" : p.比摩阻),
                    Roughness = float.Parse(string.IsNullOrEmpty(p.压力损失) ? "0" : p.压力损失),
                    Node1 = node1,// p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                    Node2 = node2// p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                });
            }

            var wtb = RevitMepElementService.GetElementModels(RevitType.RFT_WindTurbine);
            var subModelwtb = ModelFactory.Convert2Sub<HeatExchangerModel>(wtb);

            foreach (var p in subModelwtb)
            {
                var node1 = "";
                var node2 = "";
                if (p.连接构件.Contains(","))
                {
                    //if (p.编号 == "823978")
                    //{
                    //    var a = 0;
                    //}
                    var connectids = p.连接构件.Split(',');
                    var pipes1 = new LinkViewModelList();
                    foreach (var item in connectids)
                    {
                        if (mtids.Contains(item))
                        {
                            var ju = EpaModel.Nodes.FirstOrDefault(x => x.ID == item);
                            EpaModel.Nodes.Remove(ju);
                        }

                        if (gdids.Contains(item))
                        {
                            var nwpipe = EpaModel.Links.FirstOrDefault(x => x.ID == item);
                            pipes1.Add(nwpipe);
                        }
                    }
                    if (pipes1.Count == 2)//如果换热器连了两个管道
                    {
                        var item1 = pipes1[0].ID;
                        var pipe1 = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item1 }).FirstOrDefault();
                        var olepipe1 = EpaModel.Links.FirstOrDefault(x => x.ID == item1);
                        var op1 = JsonHelper.ToObject<ObjectPosition>(pipe1.包围框);
                        var jid1 = "2000" + p.编号 + pipe1.编号;
                        olepipe1.Node1 = (olepipe1.Node1 == p.编号) ? jid1 : olepipe1.Node1;
                        olepipe1.Node2 = (olepipe1.Node2 == p.编号) ? jid1 : olepipe1.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid1,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op1.getCenter.z,
                            X = op1.getCenter.x,
                            Y = op1.getCenter.y
                        });
                        node1 = jid1;

                        var item2 = pipes1[1].ID;
                        var pipe2 = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item2 }).FirstOrDefault();
                        var olepipe2 = EpaModel.Links.FirstOrDefault(x => x.ID == item2);
                        var op2 = JsonHelper.ToObject<ObjectPosition>(pipe2.包围框);
                        var jid2 = "2000" + p.编号 + pipe2.编号;
                        olepipe2.Node1 = (olepipe2.Node1 == p.编号) ? jid2 : olepipe2.Node1;
                        olepipe2.Node2 = (olepipe2.Node2 == p.编号) ? jid2 : olepipe2.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid2,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op2.getCenter.z,
                            X = op2.getCenter.x,
                            Y = op2.getCenter.y
                        });
                        node2 = jid2;



                    }
                    if (pipes1.Count == 1)//如果换热器连了一个管道
                    {
                        var item = pipes1[0].ID;
                        var pipe = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(new List<string>() { item }).FirstOrDefault();
                        var olepipe = EpaModel.Links.FirstOrDefault(x => x.ID == item);
                        var op = JsonHelper.ToObject<ObjectPosition>(pipe.包围框);
                        var jid = "2000" + p.编号 + pipe.编号;
                        olepipe.Node1 = (olepipe.Node1 == p.编号) ? jid : olepipe.Node1;
                        olepipe.Node2 = (olepipe.Node2 == p.编号) ? jid : olepipe.Node2;
                        EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                        {
                            ID = jid,
                            Name = "增加临时件",
                            Floor = p.楼层,
                            Elev = op.getCenter.z,
                            X = op.getCenter.x,
                            Y = op.getCenter.y
                        });
                        node1 = jid;
                        var ju = EpaModel.Nodes.FirstOrDefault(x => p.连接构件.Contains(x.ID));
                        node2 = ju.ID;
                    }
                }
                else
                {
                    node1 = p.连接构件;
                    node2 = p.连接构件;
                }
                EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                {
                    ID = p.编号,
                    Name = p.名称,
                    Floor = p.楼层,
                    Diameter = float.Parse(string.IsNullOrEmpty(p.直径) ? "0" : p.直径),
                    Length = float.Parse(string.IsNullOrEmpty(p.长度) ? "0" : p.长度) / 1000,
                    MinorLoss = float.Parse(string.IsNullOrEmpty(p.比摩阻) ? "0" : p.比摩阻),
                    Roughness = float.Parse(string.IsNullOrEmpty(p.压力损失) ? "0" : p.压力损失),
                    Node1 = node1,// p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                    Node2 = node2// p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                });
            }

            var modelsWBX = RevitMepElementService.GetElementModels(RevitType.RFT_WaterBox);
            var subModelsWBX = ModelFactory.Convert2Sub<WaterBoxModel>(modelsWBX);

            foreach (var p in subModelsWBX)  //节点连接水箱修正
            {
                if (p.连接构件.Contains(","))
                {
                    var connectids = p.连接构件.Split(',');
                    foreach (var item in connectids)
                    {
                        if (gdjids.Contains(item))
                        {
                            var gdj = EpaModel.Nodes.FirstOrDefault(x => x.ID == item);
                            var gd = EpaModel.Links.FirstOrDefault(x => x.Node2 == item || x.Node1 == item);
                            EpaModel.Links.Add(new Hydro.MapView.PipeViewModel()
                            {
                                ID = p.编号,
                                Name = p.名称,
                                Floor = p.楼层,
                                Diameter = gd.Diameter,
                                Length = 0.01f,
                                MinorLoss = 0f,
                                Roughness = 0f,
                                Node1 = p.编号,// p.连接构件.Contains(",") ? p.连接构件.Split(',')[0] : p.连接构件,
                                Node2 = item// p.连接构件.Contains(",") ? p.连接构件.Split(',')[1] : p.连接构件,
                            });
                        }

                    }
                }
            }

            foreach (var p in subModelpump)//水泵连接件处理，如果连接的管道，增加连接节点
            {
                if (p.连接构件.Contains(","))
                {
                    var connectids = p.连接构件.Split(',');
                    foreach (var item in connectids)
                    {
                        if (gdids.Contains(item))
                        {
                            var op = JsonHelper.ToObject<ObjectPosition>(p.包围框);
                            var pipe = EpaModel.Links.FirstOrDefault(c => c.ID == item);
                            var newId = "2000" + item + pipe.ID;
                            var pump = EpaModel.Links.FirstOrDefault(x => x.ID == p.编号);
                            pump.Node1 = (pump.Node1 == pipe.ID) ? newId : pump.Node1;
                            pump.Node2 = (pump.Node2 == pipe.ID) ? newId : pump.Node2;

                            pipe.Node1 = (pipe.Node1 == p.编号) ? newId : pipe.Node1;
                            pipe.Node2 = (pipe.Node2 == p.编号) ? newId : pipe.Node2;

                            EpaModel.Nodes.Add(new Hydro.MapView.JunctionViewModel()
                            {
                                ID = newId,
                                Name = "增加临时件",
                                Floor = p.楼层,
                                Elev = op.getCenter.z,
                                X = op.getCenter.x,
                                Y = op.getCenter.y
                            });
                        }
                    }
                }
            }

            return EpaModel;
        }

        public static List<ElementModel> GetOtherModelLits()
        {
            var list = new List<ElementModel>();
            var modelsThreeJoin = RevitMepElementService.GetElementModels(RevitType.RFT_ThreeJoint);
            var subModelsThreeJoin = ModelFactory.Convert2Sub<SanTongModel>(modelsThreeJoin);
            list.AddRange(subModelsThreeJoin);

            var modelsFourJoint = RevitMepElementService.GetElementModels(RevitType.RFT_FourJoint);
            var subModelsFourJoint = ModelFactory.Convert2Sub<SanTongModel>(modelsFourJoint);
            list.AddRange(subModelsFourJoint);

            var modelsConverter = RevitMepElementService.GetElementModels(RevitType.RFT_Converter);
            var subModelsConverter = ModelFactory.Convert2Sub<SanTongModel>(modelsConverter);
            list.AddRange(subModelsConverter);

            //var modelsOthers = RevitMepElementService.GetElementModels(RevitType.RFT_Others);
            //var subModelsOthers = ModelFactory.Convert2Sub<SanTongModel>(modelsOthers);
            //list.AddRange(subModelsOthers);

            var modelsElbow = RevitMepElementService.GetElementModels(RevitType.RFT_Elbow);
            var subModelsElbow = ModelFactory.Convert2Sub<SanTongModel>(modelsElbow);
            list.AddRange(subModelsElbow);

            var modelsBlocker = RevitMepElementService.GetElementModels(RevitType.RFT_Blocker);
            var subModelsBlocker = ModelFactory.Convert2Sub<SanTongModel>(modelsBlocker);
            list.AddRange(subModelsBlocker);

            return list;
        }

        public static List<CheckResultViewModel> Check(ExternalCommandData data)
        {
            var retDict = new List<CheckResultViewModel>();
            var ids = new List<ElementId>();
            UIDocument uidoc = data.Application.ActiveUIDocument;
            Document doc = uidoc.Document;

            var idsPipe = RevitMepElementService.GetElementModels(RevitType.RFT_Pipe);
            var modelPipe = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(idsPipe);
            var allids = GlobalResource.RevitModels.GetAllIds();
            //nodes.AddRange(model.Pipes.Select(c => c.Node2).ToList());
            //nodes.AddRange(model.Pipes.Select(c => c.Node1).ToList());
            //var otherIds = model.Junctions.Select(c => c.ID).ToList();
            var modelsWBX = RevitMepElementService.GetElementModels(RevitType.RFT_WaterBox);
            var subModelsWBX = ModelFactory.Convert2Sub<WaterBoxModel>(modelsWBX);
            var modelsWP = RevitMepElementService.GetElementModels(RevitType.RFT_WaterPool);
            var subModelsWP = ModelFactory.Convert2Sub<WaterBoxModel>(modelsWP);

            var tank = modelsWBX.Any();
            var reservos = subModelsWP.Any();
            if (!tank && !reservos)
            {
                var errorType = CheckResultType.CRT_NoReser;
                var elemId = new ElementId(0);
                ids.Add(elemId);
                if (!retDict.Any(c => c.CheckResultType == errorType))
                {
                    retDict.Add(new CheckResultViewModel()
                    {
                        CheckResultType = errorType,
                        ElementIds = new List<ElementId>(),
                        Result = false
                    });
                }
                //retDict[errorType].Add(elemId);
            }
            else
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_NoReser,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            var idsPipes = RevitMepElementService.GetElementModels(RevitType.RFT_Pipe);
            var modelPipes = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PipeModel>(idsPipes);
            foreach (var item in modelPipes)
            {
                if (string.IsNullOrEmpty(item.长度))
                {
                    var errorType = CheckResultType.CRT_PipeLengthIsZero;
                    var elemId = new ElementId(int.Parse(item.编号));
                    ids.Add(elemId);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(elemId);
                }

                if (string.IsNullOrEmpty(item.直径))
                {
                    var errorType = CheckResultType.CRT_PipeDiamterIsZero;
                    var elemId = new ElementId(int.Parse(item.编号));
                    ids.Add(elemId);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(elemId);
                }

                if (!string.IsNullOrEmpty(item.连接构件))
                {

                    var spids = item.连接构件.Split(',');
                    foreach (var sp in spids)
                    {
                        if (!allids.Contains(sp))
                        {
                            var errorType = CheckResultType.CRT_PipeConnectNoObject;
                            var elemId = new ElementId(int.Parse(item.编号));
                            ids.Add(elemId);
                            if (!retDict.Any(c => c.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    ConnectIds = "",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                            s.ElementIds.Add(elemId);
                        }
                    }

                    if (!item.连接构件.Contains(","))
                    {
                        var errorType = CheckResultType.CRT_PipeConnectError;
                        var elemId = new ElementId(int.Parse(item.编号));
                        ids.Add(elemId);
                        if (!retDict.Any(c => c.CheckResultType == errorType))
                        {
                            retDict.Add(new CheckResultViewModel()
                            {
                                CheckResultType = errorType,
                                ElementIds = new List<ElementId>(),
                                ConnectIds = "",
                                Result = false
                            });
                        }
                        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                        s.ElementIds.Add(elemId);
                    }

                }

                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_Pipe.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }



            var idsFamen = RevitMepElementService.GetElementModels(RevitType.RFT_Valve);
            var modelFamen = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.ValveModel>(idsFamen);
            foreach (var item in modelFamen)
            {
                var elemId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(elemId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_Valve.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(elemId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(elemId);
                        }
                    });
                }

                //if (string.IsNullOrEmpty(item.公称直径))
                //{
                //    var errorType = CheckResultType.CRT_PipeDiamterIsZero;
                //    var elemId = new ElementId(int.Parse(item.编号));
                //    ids.Add(elemId);
                //    if (!retDict.Any(c => c.CheckResultType == errorType))
                //    {
                //        retDict.Add(new CheckResultViewModel()
                //        {
                //            CheckResultType = errorType,
                //            ElementIds = new List<ElementId>(),
                //            Result = false
                //        });
                //    }
                //    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //    s.ElementIds.Add(elemId);
                //}
            }


            var idsPumps = RevitMepElementService.GetElementModels(RevitType.RFT_Pump);
            var modelPumps = ModelFactory.Convert2Sub<HStation.RevitDev.RevitDataExport.Entity.ElementModels.PumbModel2>(idsPumps);
            foreach (var item in modelPumps)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_Pump.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
                //    if (string.IsNullOrEmpty(item.额定流量))
                //    {
                //        var errorType = CheckResultType.CRT_PumpNotFlow;
                //        var elemId = new ElementId(int.Parse(item.编号));
                //        ids.Add(elemId);
                //        if (!retDict.Any(c => c.CheckResultType == errorType))
                //        {
                //            retDict.Add(new CheckResultViewModel()
                //            {
                //                CheckResultType = errorType,
                //                ElementIds = new List<ElementId>(),
                //                Result = false
                //            });
                //        }
                //        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //        s.ElementIds.Add(elemId);
                //    }

                //    if (string.IsNullOrEmpty(item.额定扬程))
                //    {
                //        var errorType = CheckResultType.CRT_PumpNotHead;
                //        var elemId = new ElementId(int.Parse(item.编号));
                //        ids.Add(elemId);
                //        if (!retDict.Any(c => c.CheckResultType == errorType))
                //        {
                //            retDict.Add(new CheckResultViewModel()
                //            {
                //                CheckResultType = errorType,
                //                ElementIds = new List<ElementId>(),
                //                Result = false
                //            });
                //        }
                //        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //        s.ElementIds.Add(elemId);
                //    }

                //    if (string.IsNullOrEmpty(item.额定功率))
                //    {
                //        var errorType = CheckResultType.CRT_PumpNotP;
                //        var elemId = new ElementId(int.Parse(item.编号));
                //        ids.Add(elemId);
                //        if (!retDict.Any(c => c.CheckResultType == errorType))
                //        {
                //            retDict.Add(new CheckResultViewModel()
                //            {
                //                CheckResultType = errorType,
                //                ElementIds = new List<ElementId>(),
                //                Result = false
                //            });
                //        }
                //        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //        s.ElementIds.Add(elemId);
                //    }

                //    if (string.IsNullOrEmpty(item.额定转速))
                //    {
                //        var errorType = CheckResultType.CRT_PumpNotRpt;
                //        var elemId = new ElementId(int.Parse(item.编号));
                //        ids.Add(elemId);
                //        if (!retDict.Any(c => c.CheckResultType == errorType))
                //        {
                //            retDict.Add(new CheckResultViewModel()
                //            {
                //                CheckResultType = errorType,
                //                ElementIds = new List<ElementId>(),
                //                Result = false
                //            });
                //        }
                //        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //        s.ElementIds.Add(elemId);
                //    }
                //}

                //if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PumpNotFlow))
                //{
                //    retDict.Add(new CheckResultViewModel()
                //    {
                //        CheckResultType = CheckResultType.CRT_PumpNotFlow,
                //        ElementIds = new List<ElementId>() { new ElementId(0) },
                //        Result = true
                //    });
                //}

                //if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PumpNotHead))
                //{
                //    retDict.Add(new CheckResultViewModel()
                //    {
                //        CheckResultType = CheckResultType.CRT_PumpNotHead,
                //        ElementIds = new List<ElementId>() { new ElementId(0) },
                //        Result = true
                //    });
                //}

                //if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PumpNotP))
                //{
                //    retDict.Add(new CheckResultViewModel()
                //    {
                //        CheckResultType = CheckResultType.CRT_PumpNotP,
                //        ElementIds = new List<ElementId>() { new ElementId(0) },
                //        Result = true
                //    });
                //}

                //if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PumpNotRpt))
                //{
                //    retDict.Add(new CheckResultViewModel()
                //    {
                //        CheckResultType = CheckResultType.CRT_PumpNotRpt,
                //        ElementIds = new List<ElementId>() { new ElementId(0) },
                //        Result = true
                //    });
            }


            var idsWBM = RevitMepElementService.GetElementModels(RevitType.RFT_WaterBox);
            var modelWBMs = ModelFactory.Convert2Sub<WaterBoxModel>(idsWBM);
            foreach (var item in modelWBMs)
            {
                double initLevel = 0;
                double maxLevel = 0;
                double minLevel = 0;
                if (string.IsNullOrEmpty(item.初始水位))
                {
                    var errorType = CheckResultType.CRT_TankNoInitLevel;
                    var ele = new ElementId(int.Parse(item.编号));
                    ids.Add(ele);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(ele);
                }
                else initLevel = double.Parse(item.初始水位);

                if (string.IsNullOrEmpty(item.最低水位))
                {
                    var errorType = CheckResultType.CRT_TankNoMinLevel;
                    var ele = new ElementId(int.Parse(item.编号));
                    ids.Add(ele);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(ele);
                }
                else minLevel = double.Parse(item.最低水位);

                if (string.IsNullOrEmpty(item.最高水位))
                {
                    var errorType = CheckResultType.CRT_TankNoMaxLevel;
                    var ele = new ElementId(int.Parse(item.编号));
                    ids.Add(ele);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(ele);
                }
                else maxLevel = double.Parse(item.最高水位);

                if (maxLevel<initLevel || initLevel < minLevel || maxLevel < minLevel)
                {
                    var errorType = CheckResultType.CRT_TankLevelError;
                    var ele = new ElementId(int.Parse(item.编号));
                    ids.Add(ele);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Message = "最高水位＞初始水位＞最低水位",
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(ele);
                }

                var elemId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(elemId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterBox.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(elemId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(elemId);
                        }
                    });
                }

            }

            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_TankNoInitLevel))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_TankNoInitLevel,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_TankNoMinLevel))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_TankNoMinLevel,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_TankNoMaxLevel))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_TankNoMaxLevel,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            var idsFHM = RevitMepElementService.GetElementModels(RevitType.RFT_FireHydrant);
            var modelFHM = ModelFactory.Convert2Sub<FireHydrantModel>(idsFHM);
            foreach (var item in modelFHM)
            {
                if (string.IsNullOrEmpty(item.喷射系数))
                {
                    var errorType = CheckResultType.CRT_NoFlowCoefficient;
                    var elemId = new ElementId(int.Parse(item.编号));
                    ids.Add(elemId);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(elemId);
                }

                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_FireHydrant.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }


            }



            var idsShower = RevitMepElementService.GetElementModels(RevitType.RFT_Shower);
            var modelShower = ModelFactory.Convert2Sub<ShowerModel>(idsShower);
            foreach (var item in modelShower)
            {
                //if (string.IsNullOrEmpty(item.喷射系数))
                //{
                //    var errorType = CheckResultType.CRT_NoFlowCoefficient;
                //    var elemId = new ElementId(int.Parse(item.编号));
                //    ids.Add(elemId);
                //    if (!retDict.Any(c => c.CheckResultType == errorType))
                //    {
                //        retDict.Add(new CheckResultViewModel()
                //        {
                //            CheckResultType = errorType,
                //            ElementIds = new List<ElementId>(),
                //            Result = false
                //        });
                //    }
                //    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //    s.ElementIds.Add(elemId);
                //}

                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_Shower.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }
            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_NoFlowCoefficient))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_NoFlowCoefficient,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            var idsCool = RevitMepElementService.GetElementModels(RevitType.RFT_CoolingTower);
            var modelCool = ModelFactory.Convert2Sub<ShowerModel>(idsCool);
            foreach (var item in modelCool)
            {
                if (string.IsNullOrEmpty(item.喷射系数))
                {
                    var errorType = CheckResultType.CRT_NoFlowCoefficient;
                    var elemId = new ElementId(int.Parse(item.编号));
                    ids.Add(elemId);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(elemId);
                }

                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_CoolingTower.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }
            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_NoFlowCoefficient))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_NoFlowCoefficient,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            var idsWP = RevitMepElementService.GetElementModels(RevitType.RFT_WaterPool);
            var modelWP = ModelFactory.Convert2Sub<WaterPoolModel>(idsWP);
            foreach (var item in modelWP)
            {
                if (string.IsNullOrEmpty(item.总水头))
                {
                    var errorType = CheckResultType.CRT_PoolNoHead;
                    var elemId = new ElementId(int.Parse(item.编号));
                    ids.Add(elemId);
                    if (!retDict.Any(c => c.CheckResultType == errorType))
                    {
                        retDict.Add(new CheckResultViewModel()
                        {
                            CheckResultType = errorType,
                            ElementIds = new List<ElementId>(),
                            Result = false
                        });
                    }
                    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                    s.ElementIds.Add(elemId);
                }

                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterPool.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }
            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PoolNoHead))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_PoolNoHead,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }
            var idsHec = RevitMepElementService.GetElementModels(RevitType.RFT_HeatExchanger);
            var modelHec = ModelFactory.Convert2Sub<HeatExchangerModel>(idsHec);
            foreach (var item in modelHec)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_HeatExchanger.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
                //    if (string.IsNullOrEmpty(item.直径))
                //    {
                //        var errorType = CheckResultType.CRT_PipeDiamterIsZero;
                //        var elemId = new ElementId(int.Parse(item.编号));
                //        ids.Add(elemId);
                //        if (!retDict.Any(c => c.CheckResultType == errorType))
                //        {
                //            retDict.Add(new CheckResultViewModel()
                //            {
                //                CheckResultType = errorType,
                //                ElementIds = new List<ElementId>(),
                //                Result = false
                //            });
                //        }
                //        var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //        s.ElementIds.Add(elemId);
                //    }
            }

            var idsWpl = RevitMepElementService.GetElementModels(RevitType.RFT_WaterPool);
            var modelWpl = ModelFactory.Convert2Sub<WaterPoolModel>(idsWpl);
            foreach (var item in modelWpl)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterPool.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }

            var idsWmf = RevitMepElementService.GetElementModels(RevitType.RFT_WaterMeterFlow);
            var modelWmf = ModelFactory.Convert2Sub<WaterMeterModel>(idsWmf);
            foreach (var item in modelWpl)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterMeterFlow.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }

            var idsWme = RevitMepElementService.GetElementModels(RevitType.RFT_WaterMeter);
            var modelWme = ModelFactory.Convert2Sub<WaterMeterModel>(idsWme);
            foreach (var item in modelWme)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterMeter.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }

            var idsWmp = RevitMepElementService.GetElementModels(RevitType.RFT_WaterMeterPress);
            var modelWmp = ModelFactory.Convert2Sub<WaterMeterPressModel>(idsWmf);
            foreach (var item in modelWmp)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WaterMeterPress.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
            }

            var idsWtb = RevitMepElementService.GetElementModels(RevitType.RFT_WindTurbine);
            var modelWtb = ModelFactory.Convert2Sub<WindTurbineModel>(idsWtb);
            foreach (var item in modelWtb)
            {
                var eId = new ElementId(int.Parse(item.编号));
                var elem = doc.GetElement(eId);
                var parameters = elem.Parameters;
                var listparams = new List<string>();
                foreach (Parameter param in parameters)
                {
                    var name = param.Definition.Name;
                    listparams.Add(name);
                }
                var eleparams = GlobalResource.GetParamsList().Where(c => c.FamilyType == RevitType.RFT_WindTurbine.GetDescriptioin());
                if (eleparams.Any())
                {
                    eleparams.ForEach(c =>
                    {
                        if (!listparams.Any(d => d == c.ParamsName))
                        {
                            var errorType = CheckResultType.CRT_NotParams;
                            ids.Add(eId);
                            if (!retDict.Any(r => r.CheckResultType == errorType))
                            {
                                retDict.Add(new CheckResultViewModel()
                                {
                                    CheckResultType = errorType,
                                    ElementIds = new List<ElementId>(),
                                    Message = "[ " + c.ParamsName + "]",
                                    Result = false
                                });
                            }
                            var s = retDict.FirstOrDefault(ce => ce.CheckResultType == errorType);
                            s.ElementIds.Add(eId);
                        }
                    });
                }
                //if (string.IsNullOrEmpty(item.直径))
                //{
                //    var errorType = CheckResultType.CRT_PipeDiamterIsZero;
                //    var elemId = new ElementId(int.Parse(item.编号));
                //    ids.Add(elemId);
                //    if (!retDict.Any(c => c.CheckResultType == errorType))
                //    {
                //        retDict.Add(new CheckResultViewModel()
                //        {
                //            CheckResultType = errorType,
                //            ElementIds = new List<ElementId>(),
                //            Result = false
                //        });
                //    }
                //    var s = retDict.FirstOrDefault(c => c.CheckResultType == errorType);
                //    s.ElementIds.Add(elemId);
                //}
            }

            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PipeLengthIsZero))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_PipeLengthIsZero,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            if (!retDict.Any(c => c.CheckResultType == CheckResultType.CRT_PipeDiamterIsZero))
            {
                retDict.Add(new CheckResultViewModel()
                {
                    CheckResultType = CheckResultType.CRT_PipeDiamterIsZero,
                    ElementIds = new List<ElementId>() { new ElementId(0) },
                    Result = true
                });
            }

            return retDict;

        }

        private static List<Hydro.Revit.Model.PipeViewModel> GetPipeModel(DataGridView dgv)
        {
            var pipeModels = new List<Hydro.Revit.Model.PipeViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseLinkModel(dgv, i);
                    var pipeModel = new Hydro.Revit.Model.PipeViewModel();
                    foreach (var item in typeof(LinkModel).GetProperties())
                    {
                        item.SetValue(pipeModel, item.GetValue(baseModel));
                    }
                    pipeModel.Node1 = baseModel.Node1;
                    pipeModel.Node2 = baseModel.Node2;
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];

                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                pipeModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                pipeModel.PositionJson = cell.Value.ToString(); break;
                            case "楼层":
                                pipeModel.Floor = cell.Value.ToString(); break;
                        }

                    }
                    pipeModels.Add(pipeModel);
                }
            }
            return pipeModels;
        }

        private static List<Hydro.Revit.Model.NozzleViewModel> GetNozzleModel(DataGridView dgv)
        {
            var nozzleModels = new List<Hydro.Revit.Model.NozzleViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseNodeModel(dgv, i);
                    if (!baseModel.Name.Contains("喷")) { continue; }
                    var nozzleModel = new Hydro.Revit.Model.NozzleViewModel();

                    foreach (var item in typeof(NodeModel).GetProperties())
                    {
                        item.SetValue(nozzleModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                nozzleModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                nozzleModel.PositionJson = cell.Value.ToString(); break;
                            case "K系数":
                                nozzleModel.FlowCoefficient = cell.Value == null ? 0 : float.Parse(cell.Value.ToString()); break;
                            case "连接点1":
                                nozzleModel.Node1 = cell.Value == null ? "" : cell.Value.ToString(); break;
                            case "连接点2":
                                nozzleModel.Node2 = cell.Value == null ? "" : cell.Value.ToString(); break;
                            case "楼层":
                                nozzleModel.Floor = cell.Value.ToString(); break;
                        }

                    }
                    nozzleModels.Add(nozzleModel);
                }
            }
            return nozzleModels;
        }

        private static List<WaterPumpViewModel> GetWaterPumpModel(DataGridView dgv)
        {
            var waterPumps = new List<WaterPumpViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseLinkModel(dgv, i);
                    var waterPumpsModel = new WaterPumpViewModel();

                    foreach (var item in typeof(LinkModel).GetProperties())
                    {
                        item.SetValue(waterPumpsModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                waterPumpsModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                waterPumpsModel.PositionJson = cell.Value.ToString(); break;
                            case "楼层":
                                waterPumpsModel.Floor = cell.Value.ToString(); break;
                        }
                    }
                    waterPumps.Add(waterPumpsModel);
                }
            }
            return waterPumps;
        }

        private static List<HydrantBoxViewModel> GetHydrantBoxModel(DataGridView dgv)
        {
            var hydrantBox = new List<HydrantBoxViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseNodeModel(dgv, i);
                    var hydrantModel = new HydrantBoxViewModel();

                    foreach (var item in typeof(NodeModel).GetProperties())
                    {
                        item.SetValue(hydrantModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                hydrantModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                hydrantModel.PositionJson = cell.Value.ToString(); break;
                            case "楼层":
                                hydrantModel.Floor = cell.Value.ToString(); break;
                        }
                    }
                    hydrantBox.Add(hydrantModel);
                }
            }
            return hydrantBox;
        }

        private static List<WaterTankViewModel> GetWaterTankModel(DataGridView dgv)
        {
            var hydrantBox = new List<WaterTankViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseNodeModel(dgv, i);
                    var hydrantModel = new WaterTankViewModel();

                    foreach (var item in typeof(NodeModel).GetProperties())
                    {
                        item.SetValue(hydrantModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                hydrantModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                hydrantModel.PositionJson = cell.Value.ToString(); break;
                            case "水位":
                                hydrantModel.InitLevel = float.Parse(cell.Value.ToString());
                                break;
                            case "最低水位":
                                hydrantModel.MinLevel = float.Parse(cell.Value.ToString());
                                break;
                            case "最高水位":
                                hydrantModel.MaxLevel = float.Parse(cell.Value.ToString());
                                break;
                            case "楼层":
                                hydrantModel.Floor = cell.Value.ToString(); break;
                        }
                    }
                    hydrantModel.Elev = 0;
                    hydrantBox.Add(hydrantModel);
                }
            }
            return hydrantBox;
        }

        private static List<Hydro.Revit.Model.JunctionViewModel> GetOtherModel(DataGridView dgv)
        {
            var otherModels = new List<Hydro.Revit.Model.JunctionViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseNodeModel(dgv, i);
                    var otherModel = new Hydro.Revit.Model.JunctionViewModel();

                    foreach (var item in typeof(NodeModel).GetProperties())
                    {
                        item.SetValue(otherModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                otherModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                otherModel.PositionJson = cell.Value.ToString(); break;
                            case "楼层":
                                otherModel.Floor = cell.Value.ToString(); break;
                            case "连接点1":
                                otherModel.Node1 = cell.Value.ToString(); break;
                            case "连接点2":
                                otherModel.Node2 = cell.Value.ToString(); break;
                            case "连接点3":
                                otherModel.Node1 += "," + cell.Value.ToString(); break;
                            case "连接点4":
                                otherModel.Node1 += "," + cell.Value.ToString(); break;
                        }
                    }
                    otherModels.Add(otherModel);
                }
            }
            return otherModels;
        }

        private static List<Hydro.Revit.Model.ValveViewModel> GetValveModel(DataGridView dgv)
        {
            var valveModels = new List<Hydro.Revit.Model.ValveViewModel>();
            if (dgv != null)
            {
                for (var i = 0; i < dgv.Rows.Count; i++)
                {
                    var baseModel = GetBaseLinkModel(dgv, i);
                    var valveModel = new Hydro.Revit.Model.ValveViewModel();

                    foreach (var item in typeof(LinkModel).GetProperties())
                    {
                        item.SetValue(valveModel, item.GetValue(baseModel));
                    }
                    for (var j = 0; j < dgv.Columns.Count; j++)
                    {
                        var col = dgv.Columns[j];
                        var cell = dgv.Rows[i].Cells[j];
                        switch (col.HeaderText)
                        {
                            case "系统类型":
                                valveModel.SystemType = cell.Value.ToString(); break;
                            case "包围框":
                                valveModel.PositionJson = cell.Value.ToString(); break;
                            case "楼层":
                                valveModel.Floor = cell.Value.ToString(); break;
                            case "直径":
                                valveModel.Diameter = float.Parse(cell.Value.ToString()); break;
                        }

                    }
                    valveModels.Add(valveModel);
                }
            }
            return valveModels;
        }

        private static NodeModel GetBaseNodeModel(DataGridView dgv, int rowIndex)
        {
            var baseModel = new NodeModel();
            for (var j = 0; j < dgv.Columns.Count; j++)
            {
                var col = dgv.Columns[j];
                var cell = dgv.Rows[rowIndex].Cells[j];
                switch (col.HeaderText)
                {
                    case "名称":
                        baseModel.Name = cell.Value.ToString(); break;
                    case "ID":
                        baseModel.ID = cell.Value.ToString(); break;
                    case "包围框":
                        var ps = cell.Value.ToString();
                        var p = JsonHelper.ToObject<PositionModel>(ps);
                        baseModel.Elev = p.getCenter.z / 1000;
                        baseModel.X = p.getCenter.x;
                        baseModel.Y = p.getCenter.y;
                        break;
                }
            }
            return baseModel;
        }

        private static LinkModel GetBaseLinkModel(DataGridView dgv, int rowIndex)
        {
            var baseModel = new LinkModel();
            for (var j = 0; j < dgv.Columns.Count; j++)
            {
                var col = dgv.Columns[j];

                var cell = dgv.Rows[rowIndex].Cells[j];
                switch (col.HeaderText)
                {
                    case "名称":
                        baseModel.Name = cell.Value.ToString(); break;
                    case "ID":
                        baseModel.ID = cell.Value.ToString(); break;
                }
                if (col.HeaderText.Contains("连接点1"))
                    baseModel.Node1 = cell.Value.ToString();
                if (col.HeaderText.Contains("连接点2"))
                    baseModel.Node2 = cell.Value.ToString();
                if (col.HeaderText.Contains("直径"))
                    baseModel.Diameter = float.Parse(cell.Value.ToString());
                if (col.HeaderText.Contains("长度"))
                    baseModel.Length = float.Parse(cell.Value.ToString());
                if (col.HeaderText.Contains("比摩阻"))
                    baseModel.Roughness = float.Parse(cell.Value.ToString() == "" ? "0" : cell.Value.ToString());
            }
            return baseModel;
        }

    }
}