Revit.Plugln/FWindSoft/Saga.PlugIn/ModelCheck/ConnectorCheck.cs

/* ==============================================================================
 * 功能描述：连接件检查
 * 创 建 者：Garrett
 * 创建日期：2018/10/23 15:08:55
 * ==============================================================================*/

using System;
using System.Collections.Generic;
using System.Linq;
using Autodesk.Revit.DB;
using NPOI.SS.UserModel;
using SAGA.DotNetUtils;
using SAGA.DotNetUtils.Extend;
using SAGA.DotNetUtils.Others;
using SAGA.RevitUtils.Extends;
using SAGA.RevitUtils.MEP;

namespace Saga.PlugIn.ModelCheck
{
    /// <summary>
    /// UnitCheck
    /// </summary>
    [ParseIndex(Index = 7)]
    class ConnectorCheck : ModeCheckBase
    {
        public ConnectorCheck()
        {
            Name = "连接件检查";
            RSPecificationSheet.Add("参考-连接件对照表");
        }
        public override bool Check()
        {
            if (!RBase.IsRight)
            {
                IsRight = RBase.IsRight;
                return IsRight;
            }
            IsRight = GetCheckResult();
            return IsRight;
        }

        private bool GetCheckResult()
        {
            bool unitResult = true;
            m_ProDefineConnectors = GetPreDefineConnectors();
            foreach (SagaSignCheckResult signResult in RBase.Results)
            {
                var list = Check(signResult);
                Results.AddRange(list);
            }
            return Results.All(t => t.IsRight);

        }
        /// <summary>
        /// 获取所有的设备或者部件
        /// </summary>
        /// <param name="document"></param>
        /// <returns></returns>
        private List<ModeCheckResultBase> Check(SagaSignCheckResult signResult)
        {
            List<ModeCheckResultBase> list = new List<ModeCheckResultBase>();
            var elements = signResult.RDocument.GetFamilyInstances();

            foreach (var element in elements)
            {
                if (element.IsEquipment() || element.IsEquipmentPart())
                {
                    var result = GetCheckResult(element);
                    if (result == null) continue;
                    result.RBase = signResult;
                    list.Add(result);
                }
            }
            return list;
        }

        private string m_HaveConnectorSing = "√";
        private List<DCR_Connector> m_ProDefineConnectors;

        public  List<DCR_Connector> GetPreDefineConnectors()
        {
            var list = new List<DCR_Connector>();
            var alllist = DataCheckRule.GetPreDefineConnectors();
            foreach (DCR_Connector connector in alllist)
            {
                var pipeType = connector.PipeConnector;
                var hvacType = connector.HvacConnector;
                if (pipeType == m_HaveConnectorSing || hvacType == m_HaveConnectorSing)
                {
                    list.Add(connector);
                    if (connector.PName.IsNotNullEmpty() && connector.PCode.IsNotNullEmpty())
                    {
                        //部件单独提出来当做一项
                        var pconnector = new DCR_Connector()
                        {
                            Code = connector.PCode,
                            Name = connector.Name,
                            PipeConnector = connector.PipeConnector,
                            HvacConnector = connector.HvacConnector
                        };
                        list.Add(pconnector);
                    }
                }
            }
            return list;
        }
        /// <summary>
        /// 获取检测结果
        /// </summary>
        /// <param name="fi"></param>
        /// <returns></returns>
        private ModeCheckResultBase GetCheckResult(Element element)
        {
            if (element == null) return null;
            var result = new ConnectorCheckResult();
            var code = element.GetFamilyCode();
            var defineConType = GetDefineConType(code);
            if (defineConType == null) return null;
            result.FamilyName = element.GetFamilyName();
            result.Type = code.Length == 4 ? DCElementType.Equipment : DCElementType.EuipmentPart;
            result.Id = element.Id.ToString();
            result.IsRight = true;
            CheckConType(result, element, defineConType.Item1);
            CheckConType(result, element, defineConType.Item2);
            return result;
        }
        /// <summary>
        /// 获取定义的风和水连接件类型
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        private Tuple<Domain, Domain> GetDefineConType(string code)
        {
            var item = m_ProDefineConnectors.FirstOrDefault(t => t.Code == code);
            if (item == null) return null;
            var pipeType = item.PipeConnector;
            var hvacType = item.HvacConnector;

            var pipeConType = pipeType == m_HaveConnectorSing ? Domain.DomainPiping : Domain.DomainUndefined;
            var hvacConType = hvacType == m_HaveConnectorSing ? Domain.DomainHvac : Domain.DomainUndefined;
            return new Tuple<Domain, Domain>(pipeConType, hvacConType);
        }
        /// <summary>
        /// 检查连接件类型是否存在
        /// </summary>
        /// <param name="result"></param>
        /// <param name="domain"></param>
        private void CheckConType(ConnectorCheckResult result,Element fi, Domain domain)
        {
            if (domain != Domain.DomainUndefined)
            {
                var connectors = fi.GetConnectors(domain);
                if (!connectors.Any())
                {
                    result.IsRight = false;
                    result.RMessage += $"缺少 {DomainToString(domain)} 连接件;";
                }
                else
                {
                    if (!connectors.All(t => t.IsConnected))
                    {
                        result.IsRight = false;
                        result.RMessage += $"发现 {DomainToString(domain)}连接件未连接;";
                    }
                }
            }
        }

        private string DomainToString(Domain domain)
        {
            string str = "";
            switch (domain)
            {
                case Domain.DomainPiping:
                        str = "水管";
                        break;
                case Domain.DomainHvac:
                    str = "风管";
                    break;
                    default:
                        str = "未知";
                        break;

            }
            return str;
        }


        //[DataCheckProcessAspect]
        public override void Export()
        {
            try
            {
                IWorkbook book = DCRExport.GetWorkbook();
                //ISheet sheet = book.CreateSheet(Name);
                ISheet sheet = book.GetSheet(Name);

                #region 添加数据
                int index = 3;
                //添加 共检查XXX条数据，未通过检查的如下 提示
                IRow rowTip = sheet.CreateRow(index - 1);
                rowTip.AddCell(0, $"总检查{Results.Count}条数据，未通过检查的如下", DataCheckNPOIStyle.Title);
                foreach (ConnectorCheckResult result in Results)
                {
                    SagaSignCheckResult rbase = result.RBase as SagaSignCheckResult;
                    if (rbase == null)
                        continue;
                    //数量多过，只显示有问题的
                    if (result.IsRight) continue;
                    index++;
                    IRow rowN = sheet.CreateRow(index);
                    DataCheckNPOIStyle style = result.IsRight ? DataCheckNPOIStyle.Content : DataCheckNPOIStyle.Error;
                    int j = -1;
                    rowN.AddCell(++j, result.FamilyName, style);
                    rowN.AddCell(++j, result.Type.GetDescription(), style);
                    rowN.AddCell(++j, result.Id, style);
                    string rowN4 = result.IsRight ? "通过" : "不通过";
                    rowN.AddCell(++j, rowN4, style);
                    rowN.AddCell(++j, result.RMessage, style);
                }
                #endregion

            }
            catch (Exception e)
            {
                MessageShowBase.Show(e);
            }
        }
    }
    class ConnectorCheckResult : ModeCheckResultBase
    {
        public string FamilyName { get; set; }

        public DCElementType Type { get; set; }

        public string Id { get; set; }
    }
}