009_DI-Elec/newFront/c#前端/SWS.CAD/ViewModels/LeftPanelViewModel.cs

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Prism.Commands;
using Prism.Events;
using Prism.Ioc;
using SWS.CAD.Event;
using SWS.CAD.Views;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Markup;
using System.Windows.Media;
using Teigha.GraphicsSystem;
using Telerik.Windows.Controls;
using Unity;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel;
using MessageBox = System.Windows.MessageBox;
using Application = Bricscad.ApplicationServices.Application;
using SWS.CAD.CADFunc;
using Teigha.DatabaseServices;
using Bricscad.EditorInput;
using SWS.CAD.Views.CustomControl;
using DryIoc;
using Path = System.IO.Path;
using ImageSource = System.Windows.Media.ImageSource;
using Prism.Services.Dialogs;
using SWS.Commons;
using SWS.Model;
using SWS.Service;
using SWS.WPF.Views;
using SWS.CAD.Base;
namespace SWS.CAD.ViewModels
{
    public class LeftPanelViewModel : ViewModelBase
    {
        #region 图纸列表的右键功能 
        public ICommand ExcuteCommand { get; set; }
        /// <summary>
        /// 创建图纸
        /// </summary>
        public ICommand Command_CreateDwg { get; set; }
        /// <summary>
        /// 打开图纸
        /// </summary>
        public ICommand Command_OpenDwg { get; set; }
        /// <summary>
        /// 删除图纸
        /// </summary>
        public ICommand Command_DeleteDwg { get; set; }
        /// <summary>
        /// 图纸属性
        /// </summary>
        public ICommand Command_EditPropertyDwg { get; set; }

        /// <summary>
        /// 检入
        /// </summary>
        public ICommand Command_CheckInDwg { get; set; }
        /// <summary>
        /// 检出
        /// </summary>
        public ICommand Command_CheckOutDwg { get; set; }
        /// <summary>
        /// 释放
        /// </summary>
        public ICommand Command_FreeDwg { get; set; }
        /// <summary>
        /// 浏览所在文件夹
        /// </summary>
        public ICommand Command_OpenDwgFileFolder { get; set; }
        /// <summary>
        /// 上移
        /// </summary>
        public ICommand Command_UpDwg { get; set; }
        /// <summary>
        /// 下移
        /// </summary>
        public ICommand Command_DownDwg { get; set; }
        /// <summary>
        /// 生成文件材料表
        /// </summary>
        public ICommand Command_GenerateFileMaterial { get; set; }
        /// <summary>
        /// 修订
        /// </summary>
        public ICommand Command_ReviseDwg { get; set; }
        /// <summary>
        /// 发布
        /// </summary>
        public ICommand Command_PublishDwg { get; set; }
        /// <summary>
        /// 检入记录
        /// </summary>
        public ICommand Command_CheckInRecordDwg { get; set; }
        /// <summary>
        /// 检入审核
        /// </summary>
        public ICommand Command_CheckInAuditDwg { get; set; }
        /// <summary>
        /// 发布记录
        /// </summary>
        public ICommand Command_PublishRecordDwg { get; set; }
        /// <summary>
        /// 操作记录
        /// </summary>
        public ICommand Command_OperateRecordDwg { get; set; }
        /// <summary>
        /// 改变选中的设计浏览节点
        /// </summary>
        public ICommand Common_SelectedDesign { get; set; }
        /// <summary>
        /// 双击设计浏览节点
        /// </summary>
        public ICommand Common_DoubleClickDesign { get; set; }
        /// <summary>
        /// 只读打开图纸
        /// </summary>
        public ICommand Command_ReadOnlyOpenDwg { get; set; }
        /// <summary>
        /// 刷新历史版次
        /// </summary>
        public ICommand Command_RefreshHistoryDwg { get; set; }
        /// <summary>
        /// 图元双击事件
        /// </summary>
        public ICommand Command_TagDoubleClick { get; set; }
        /// <summary>
        /// 图元关联元件
        /// </summary>
        public ICommand Command_Guanlian { get; set; }

        private void onExecuteCommand(Model.TreeModel obj)
        {
            if (obj != null)
            {
                if (obj.NodeType == "0")
                {
                    //目前后台逻辑，此时0为文件夹
                }
                else if (obj.NodeType == "1")
                {

                }
            }
        }

        #endregion

        #region 目录列表的右键功能
        /// <summary>
        /// 目录属性
        /// </summary>
        public ICommand Command_EditDrawingCatalogue { get; set; }
        #endregion
        #region binding
        private bool _LoginOK;

        public bool LoginOK
        {
            get { return _LoginOK; }
            set { _LoginOK = value; RaisePropertyChanged(nameof(LoginOK)); }
        }

        public ICommand window_loaded { get; }


        private string _curProjName;

        public string curProjName
        {
            get { return _curProjName; }
            set { _curProjName = value; RaisePropertyChanged(nameof(curProjName)); }
        }

        private ObservableCollection<Model.TreeModel> drawings;
        /// <summary>
        /// 图纸目录树
        /// </summary>
        public ObservableCollection<Model.TreeModel> Drawings
        {
            get { return this.drawings; }
            set
            {
                if (value != this.drawings)
                {
                    this.drawings = value;
                    RaisePropertyChanged(nameof(drawings));
                }
            }
        }
        private ObservableCollection<Model.TreeModel> _historyDrawings;
        /// <summary>
        /// 历史版次图纸树
        /// </summary>
        public ObservableCollection<Model.TreeModel> historyDrawings
        {
            get { return this._historyDrawings; }
            set
            {
                if (value != this._historyDrawings)
                {
                    this._historyDrawings = value;
                    RaisePropertyChanged(nameof(historyDrawings));
                }
            }
        }

        private ObservableCollection<Model.TreeModel> _objectTypeTree;
        /// <summary>
        /// 放置元件列表
        /// </summary>
        public ObservableCollection<Model.TreeModel> objectTypeTree
        {
            get { return _objectTypeTree; }
            set { _objectTypeTree = value; RaisePropertyChanged(nameof(objectTypeTree)); }
        }
        private Model.TreeModel _selectType;
        /// <summary>
        /// 选中的元件树节点
        /// </summary>
        public Model.TreeModel selectType
        {
            get { return _selectType; }
            set
            {
                if (_selectType != value)
                {
                    eventAggregator.GetEvent<treeNodeChangeEvent>().Publish(value);
                    GetLibrary(value.ID);
                }
                if (value == null)
                { isEnabledGuanlian = false; }
                else if (value.ChildNodes.Any())
                { isEnabledGuanlian = false; }
                else { isEnabledGuanlian = true; }
                _selectType = value;
                RaisePropertyChanged(nameof(selectType));
            }
        }
        private ObservableCollection<Model.TreeModel> _designTree;
        /// <summary>
        /// 设计浏览列表
        /// </summary>
        public ObservableCollection<Model.TreeModel> designTree
        {
            get { return _designTree; }
            set { _designTree = value; RaisePropertyChanged(nameof(designTree)); }
        }
        private Model.TreeModel _selectDesign;
        /// <summary>
        /// 选中的设计浏览树节点
        /// </summary>
        public Model.TreeModel selectDesign
        {
            get { return _selectDesign; }
            set
            {
                _selectDesign = value;
                RaisePropertyChanged(nameof(selectDesign));
            }
        }

        private Model.TreeModel _selectedNode;

        public Model.TreeModel selectedNode
        {
            get { return _selectedNode; }
            set
            {
                if (value != null && value.Text.ToLower().EndsWith(".dwg"))
                {
                    var dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(value.NodeExtData.ToString());
                    eventAggregator.GetEvent<drawingChangeEvent>().Publish(dwgObj);
                }
                _selectedNode = value;
                RaisePropertyChanged(nameof(selectedNode));
            }
        }
        private ObservableCollection<ec_library_file> _listLibrary;
        /// <summary>
        /// 图元列表
        /// </summary>
        public ObservableCollection<ec_library_file> listLibrary
        {
            get { return _listLibrary; }
            set { _listLibrary = value; RaisePropertyChanged(nameof(listLibrary)); }
        }
        private ec_library_file _selectedTag = new ec_library_file();

        public ec_library_file selectedTag
        {
            get { return _selectedTag; }
            set
            {
                _selectedTag = value;
                RaisePropertyChanged(nameof(selectedTag));
            }
        }
        private bool _isEnabledGuanlian = false;
        /// <summary>
        /// 图元关联元件   功能是否启用
        /// </summary>
        public bool isEnabledGuanlian
        {
            get { return _isEnabledGuanlian; }
            set
            {
                _isEnabledGuanlian = value;
                if (value)
                { guanlianImage = guanlian1Image; }
                RaisePropertyChanged(nameof(isEnabledGuanlian));
            }
        }
        private ImageSource _guanlianImage;
        /// <summary>
        /// 元件关联图元
        /// </summary>
        public ImageSource guanlianImage
        {
            get
            {
                return _guanlianImage;
            }
            set { _guanlianImage = value; RaisePropertyChanged(nameof(guanlianImage)); }
        }
        private ImageSource _guanlian1Image;
        /// <summary>
        /// 元件关联图元
        /// </summary>
        public ImageSource guanlian1Image
        {
            get
            {
                return _guanlian1Image;
            }
            set { _guanlian1Image = value; RaisePropertyChanged(nameof(guanlian1Image)); }
        }
        private ImageSource _guanlian2Image;
        /// <summary>
        /// 元件关联图元 Enable为false时灰色
        /// </summary>
        public ImageSource guanlian2Image
        {
            get
            {
                return _guanlian2Image;
            }
            set { _guanlian2Image = value; RaisePropertyChanged(nameof(guanlian2Image)); }
        }
        #endregion 
        ObjectTypeService objectTypeService { get; set; }
        ObservableCollection<Model.TreeModel> originDrawings = new ObservableCollection<Model.TreeModel>();
        ProjectService _projectService;
        DrawingServce _dwgService;
        ConfigService _configService;
        AnnexesService _annexesService;
        NotificationService _notificationService;
        EnginedataService _enginedataService;
        DataItemService _dataItemService;
        IEventAggregator eventAggregator;
        private readonly IDialogService _dialogService;
        private bool isCheckIn = false;//是否正在进行检入 关联云线
        private bool isIOassociationChannel = false;//是否正在进行位号关联通道
        private bool isObjectTypeGuanlian = false;//是否正在进行元件关联图元 关联云线
        public LeftPanelViewModel(
            DrawingServce httpService, ProjectService projectServ,
            ConfigService configService, IEventAggregator eventAggregator)
        {
            LoginOK = false;
            _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _annexesService = GlobalObject.container.Resolve<AnnexesService>();
            _notificationService = GlobalObject.container.Resolve<NotificationService>();
            _enginedataService = GlobalObject.container.Resolve<EnginedataService>();
            _dataItemService = GlobalObject.container.Resolve<DataItemService>();
            _dwgService = httpService;
            _configService = configService;
            _projectService = projectServ;
            this.eventAggregator = eventAggregator;
            ExcuteCommand = new DelegateCommand<Model.TreeModel>(onExecuteCommand);
            Command_CreateDwg = new DelegateCommand<Model.TreeModel>(onCreateDwg);
            Command_OpenDwg = new DelegateCommand<Model.TreeModel>(onOpenDwg);
            Command_DeleteDwg = new DelegateCommand<Model.TreeModel>(onDeleteDwg);
            Command_EditPropertyDwg = new DelegateCommand<Model.TreeModel>(onPropertyDwg);
            Command_OpenDwgFileFolder = new DelegateCommand<Model.TreeModel>(onOpenDwgFileFolder);
            Command_CheckInDwg = new DelegateCommand<Model.TreeModel>(onCheckInDwg);
            Command_CheckOutDwg = new DelegateCommand<Model.TreeModel>(onCheckOutDwg);
            Command_FreeDwg = new DelegateCommand<Model.TreeModel>(onFreeDwg);
            Command_UpDwg = new DelegateCommand<Model.TreeModel>(onUpDwg);
            Command_DownDwg = new DelegateCommand<Model.TreeModel>(onDownDwg);
            Command_GenerateFileMaterial = new DelegateCommand<Model.TreeModel>(onGenerateFileMaterialDwg);
            Command_ReviseDwg = new DelegateCommand<Model.TreeModel>(onReviseDwg);
            Command_PublishDwg = new DelegateCommand<Model.TreeModel>(onPublishDwg);
            Command_CheckInRecordDwg = new DelegateCommand<Model.TreeModel>(onCheckInRecordDwg);
            Command_CheckInAuditDwg = new DelegateCommand<Model.TreeModel>(onCheckInAuditDwg);
            Command_PublishRecordDwg = new DelegateCommand<Model.TreeModel>(onPublishRecordDwg);
            Command_OperateRecordDwg = new DelegateCommand<Model.TreeModel>(onOperateRecordDwg);
            Common_SelectedDesign = new DelegateCommand<Model.TreeModel>(onDesignSelectedChange);
            Common_DoubleClickDesign = new DelegateCommand<Model.TreeModel>(onDesignDoubleClick);
            Command_ReadOnlyOpenDwg = new DelegateCommand<Model.TreeModel>(onReadOnlyOpenDwg);
            Command_RefreshHistoryDwg = new DelegateCommand<Model.TreeModel>(onRefreshHistoryDwg);
            Command_TagDoubleClick = new DelegateCommand<object>(onTagDoubleClick);
            Command_Guanlian = new DelegateCommand<object>(onGuanlian);
            Command_EditDrawingCatalogue = new DelegateCommand<Model.TreeModel>(onEditDrawingCatalogue);
            window_loaded = new Telerik.Windows.Controls.DelegateCommand(onWindow_loaded);
            eventAggregator.GetEvent<loginEvent>().Subscribe(onEnterProjOK, ThreadOption.UIThread, true);
            eventAggregator.GetEvent<checkInEvent>().Subscribe(CheckInDwg, ThreadOption.UIThread, true);
            eventAggregator.GetEvent<IORelationEvent>().Subscribe(ChangeIORelation, ThreadOption.UIThread, true);
            objectTypeService = GlobalObject.container.Resolve<ObjectTypeService>();
            listLibrary = new ObservableCollection<ec_library_file>();
            designTree = new ObservableCollection<Model.TreeModel>();
            objectTypeTree = new ObservableCollection<Model.TreeModel>();
            guanlian1Image = GlobalObject.ImageSourceFromEmbeddedResourceStream(@"SWS.CAD.Images.guanlian.png");
            guanlian2Image = GlobalObject.ImageSourceFromEmbeddedResourceStream(@"SWS.CAD.Images.guanlian2.png");
            guanlianImage = guanlian2Image;
        }

        #region 树节点名称加入状态 自己检出、别人检出、未检出
        /// <summary>
        /// 图纸树节点 加入状态:自己检出、别人检出、未检出
        /// </summary>
        /// <param name="trees"></param>
        /// <returns></returns>
        private ObservableCollection<Model.TreeModel> CheckInOutStatus(ObservableCollection<Model.TreeModel> trees)
        {
            foreach (Model.TreeModel node in trees)
            {
                if (node.NodeType == "0"||node.ChildNodes!=null&&node.ChildNodes.Any())
                { CheckInOutStatus(node.ChildNodes); }
                foreach (var item in node.ChildNodes)
                {
                    ec_drawing_file dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(item.NodeExtData.ToString());
                    UpdateNode(item, dwgObj);
                }
            }
            return trees;
        }
        /// <summary>
        /// 修改节点UI信息
        /// </summary>
        /// <param name="item"></param>
        /// <param name="dwgObj"></param>
        private void UpdateNode(Model.TreeModel item, ec_drawing_file dwgObj)
        {
            if (dwgObj.IsCheckOut == 0)
            {
                item.CheckInOutStatus = 0;
                item.Glyph = "&#xe61f;";//修改节点图标为 未检出
                item.ToolTipText = "未检出";
                item.FontColor = new SolidColorBrush(Colors.Yellow); //图纸名称字体颜色：黄色
            }
            else if (dwgObj.IsCheckOut == 1 && dwgObj.CheckOutUserID == GlobalObject.userInfo.userId)
            {
                item.CheckInOutStatus = 1;
                item.Glyph = "&#xe00a;";//修改节点图标为 自己检出
                item.ToolTipText = "自己检出";
                item.FontColor = new SolidColorBrush(Colors.LightBlue);//图纸名称字体颜色：浅蓝
            }
            else if (dwgObj.IsCheckOut == 1 && dwgObj.CheckOutUserID != GlobalObject.userInfo.userId)
            {
                item.CheckInOutStatus = 2;
                item.Glyph = "&#xe113;";//修改节点图标为 别人检出
                var userName = GlobalObject.GetUserNameById(dwgObj.CheckOutUserID);
                userName = string.IsNullOrEmpty(userName) ? dwgObj.CheckOutUserID : userName;
                item.ToolTipText = "别人检出:" + userName;
                item.FontColor = new SolidColorBrush(Colors.LightPink);//图纸名称字体颜色：浅分红
            }
            item.OrderNo = dwgObj.OrderID;
            item.NodeExtData = JsonConvert.SerializeObject(dwgObj);
        }
        #endregion

        #region 选中项目 
        /// <summary>
        /// 选中项目
        /// </summary>
        /// <param name="obj"></param>
        async void onEnterProjOK(JToken obj)
        {
            //图纸目录树
            var data = obj.First(x => (string)x["Name"] == "图纸树（按目录）")["data"];
            if (Drawings != null)
            {
                Drawings.Clear();
            }
            originDrawings = JsonConvert.DeserializeObject<ObservableCollection<Model.TreeModel>>(data.ToString());
            Drawings = new ObservableCollection<Model.TreeModel>(originDrawings);
            Drawings = CheckInOutStatus(Drawings);
            GlobalObject.AllDrawings= Drawings.ToList();
            curProjName = "当前项目：" + GlobalObject.curProject.ProjectName;
            LoginOK = true;
            //放置元件列表树
            data = obj.First(x => (string)x["Name"] == "对象类型树")["data"];
            GlobalObject.objectTypeTree = JsonConvert.DeserializeObject<List<SWS.Model.TreeModel>>(data.ToString());
            GlobalObject.objectTypeTree = SetTreeGlyph(GlobalObject.objectTypeTree);
            #region 设计元件 最近使用 
            Model.TreeModel recentNode = new Model.TreeModel()
            { ID = "0", NodeType = "000", Text = "最近使用" };
            var strRecentObjectType = _configService.Read("Project" + GlobalObject.curProject.ProjectId, nameof(ConfigIni.RecentObjectType));
            if (!string.IsNullOrEmpty(strRecentObjectType))
            {
                var listObjectTypeId = strRecentObjectType.Split(',');
                foreach (var id in listObjectTypeId)
                {
                    //获取节点
                    Model.TreeModel node = TreeHelper.GetTreeModel(GlobalObject.objectTypeTree, id);
                    if (node != null)
                    {
                        var node1 = (Model.TreeModel)node.Clone();
                        recentNode.ChildNodes.Add(node1);
                    }
                }
            }
            GlobalObject.objectTypeTree.Insert(0, recentNode);
            #endregion
            objectTypeTree = new ObservableCollection<Model.TreeModel>(GlobalObject.objectTypeTree);
            //设计浏览树 
            data = obj.First(x => (string)x["Name"] == "对象类型树")["data"];
            GlobalObject.designTree = JsonConvert.DeserializeObject<List<Model.TreeModel>>(data.ToString());
            designTree = new ObservableCollection<Model.TreeModel>(GlobalObject.designTree);

            //加载项目下的所有计量单位
            var listUnit = await _dataItemService.GetMeasuringUnitList();
            GlobalObject.Units = listUnit;

            InitHistoryDrawings();
            #region 获取所有图纸名称
            GlobalObject.AllDwgName.Clear();
            foreach (var dwg in Drawings)
            {
                TreeHelper.GetTreeText(dwg);
            }
            #endregion

            #region 选择项目后，如果自己有接收的消息，就弹出消息界面
            data = obj.First(x => (string)x["Name"] == "通知")["data"];
            var infos = JsonConvert.DeserializeObject<List<ec_notification>>(data.ToString());
            //var infos = await _notificationService.GetUserAllNotification(0);
            infos = infos.Where(x => x.RetrieveUserID.ToUpper() != x.SenderUserID.ToUpper()).ToList();
            if (infos.Any())
            {
                var View = GlobalObject.container.Resolve<UserNotification>();
                eventAggregator.GetEvent<SelectProjectEvent>().Publish(infos);
                Application.ShowModalWindow(Application.MainWindow.Handle, View);
            }
            #endregion
        }
        /// <summary>
        /// 设置元件树末级节点的图标
        /// </summary>
        /// <param name="nodes">完整的节点</param> 
        /// <returns></returns>
        private List<Model.TreeModel> SetTreeGlyph(List<SWS.Model.TreeModel> nodes)
        {
            foreach (var node in nodes)
            {
                if (node.ChildNodes.Count > 0)
                {
                    node.ChildNodes = new ObservableCollection<SWS.Model.TreeModel>(SetTreeGlyph(node.ChildNodes.ToList()));
                    //node.FontColor = new SolidColorBrush(Colors.Yellow); //图纸名称字体颜色：黄色
                }
                else
                {
                    node.Glyph = "&#xe13a;";
                    node.FontColor = new SolidColorBrush(Colors.DeepSkyBlue); //图纸名称字体颜色：蓝色
                }
            }
            return nodes;
        }
        #endregion


        public void onWindow_loaded(object para)
        {


        }

        #region tab切换
        public void TabChanged(int tabIndex)
        {
            switch (tabIndex)
            {
                case 0:
                    break;
                case 1:
                    break;
                default:
                    break;
            }
        }
        #endregion

        #region 查找树节点
        public ICommand TextChangedCmd => new Telerik.Windows.Controls.DelegateCommand(TextBox_TextChanged);
        /// <summary>
        /// 显示状态按钮
        /// </summary>
        /// <param name="parameter"></param>
        public virtual async void TextBox_TextChanged(object parameter)
        {
            var textValue = parameter.ToString();
        }


        /// <summary>
        /// 查找树节点
        /// </summary>
        /// <param name="searchText">查找内容</param>
        public async void SearchTree(string tag, string searchText)
        {
            if (Drawings != null)
            {
                if (tag.Equals("工程文件"))
                {
                    // 递归筛选树形结构中的节点
                    //var filteredItems = FilterTree(originDrawings, searchText);
                    //Drawings.Clear();
                    //foreach (var item in filteredItems)
                    //{
                    //    Drawings.Add(item);
                    //}
                    if (string.IsNullOrEmpty(searchText))
                    {
                        Drawings.Clear();
                        Drawings = new ObservableCollection<Model.TreeModel>(GlobalObject.objectTypeTree);
                        return;
                    }
                    //调用接口筛选树形结构的节点
                    var resObjectTypeData = await objectTypeService.GetObjectTypeData("0", searchText);
                    Drawings.Clear();
                    if (resObjectTypeData != null)
                    {
                        Drawings = new ObservableCollection<Model.TreeModel>(resObjectTypeData);
                    }

                }
                if (tag.Equals("设计浏览"))
                {
                    if (string.IsNullOrEmpty(searchText))
                    {
                        designTree.Clear();
                        designTree = new ObservableCollection<Model.TreeModel>(GlobalObject.designTree);
                        return;
                    }
                    var resObjectTypeData = await objectTypeService.GetObjectTypeData("0", searchText);
                    designTree.Clear();
                    if (resObjectTypeData != null)
                    {
                        designTree = new ObservableCollection<Model.TreeModel>(resObjectTypeData);
                    }
                }
            }

        }
        /// <summary>
        /// 过滤查询图纸树节点
        /// </summary>
        /// <param name="nodes">完整的节点</param>
        /// <param name="searchText">带搜索的</param>
        /// <returns></returns>
        private ObservableCollection<Model.TreeModel> FilterTree(ObservableCollection<Model.TreeModel> nodes, string searchText)
        {
            ObservableCollection<Model.TreeModel> result = new ObservableCollection<Model.TreeModel>();

            foreach (var node in nodes)
            {
                // 先检查节点本身是否匹配
                var filteredChildren = FilterTree(node.ChildNodes, searchText);

                // 如果节点匹配，或者它有匹配的子节点，添加当前节点到结果
                if (node.Text.ToUpper().Contains(searchText.ToUpper()) || filteredChildren.Any())
                {
                    var dto = (Model.TreeModel)node.Clone();
                    dto.ChildNodes = filteredChildren;
                    result.Add(dto);
                    //result.Add(new Model.TreeModel
                    //{
                    //    Text = node.Text,
                    //    ChildNodes = filteredChildren
                    //});
                }
            }
            return result;
        }
        #endregion

        #region 检出用户是否有操作节点权限
        /// <summary>
        /// 检出用户是否有操作节点权限
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private bool IsCanEdit(Model.TreeModel node)
        {
            //超级管理员都有权限
            if (GlobalObject.userInfo.userId.ToLower().Equals("system"))
            { return true; }
            //取图纸数据
            ec_drawing_file dwgFile = JsonConvert.DeserializeObject<ec_drawing_file>(node.NodeExtData.ToString());
            if (dwgFile.AllUsersCanEdit.Contains(GlobalObject.userInfo.RealName))
            { return true; }
            else
            { return false; }
        }
        #endregion

        #region 刷新图纸树
        /// <summary>
        /// 刷新图纸树
        /// </summary>
        private async void RefreshDrawings()
        {
            if (Drawings != null)
            {
                Drawings.Clear();
            }
            if (originDrawings != null)
            {
                originDrawings.Clear();
            }
            originDrawings = await _dwgService.GetDrawingCatalogue();
            Drawings = new ObservableCollection<Model.TreeModel>(originDrawings);
            Drawings = CheckInOutStatus(Drawings);
        }
        #endregion

        #region 创建图纸
        /// <summary>
        /// 创建图纸
        /// </summary>
        /// <param name="model"></param>
        private void onCreateDwg(Model.TreeModel model)
        {
            IDialogParameters par = new Prism.Services.Dialogs.DialogParameters();
            par.Add(nameof(ec_drawing_file.DrawingCatalogueID), model);
            _dialogService.ShowDialog(nameof(NewDrawing), par, (result) =>
            {
                if (result.Result == ButtonResult.OK || result.Result == ButtonResult.Yes)
                {
                    //新建了图纸，所以需要UI刷新
                    RefreshDrawings();
                }
            });
        }
        #endregion

        #region 打开图纸
        /// <summary>
        /// 打开图纸
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onOpenDwg(Model.TreeModel model)
        {
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            var msg = string.Empty;
            var dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            if (dwgObj.IsPublish == 1)
            {
                MessageBox.Show("当前状态为：已发布，只能以只读模式打开图纸！");
                //下载图纸文件，只读打开
                DownDwgByOpenReadOnly(model);
                return;
            }
            if (model.CheckInOutStatus == 0)//状态为检入
            {
                if (MessageBoxResult.Yes == MessageBox.Show("当前图纸状态为:未检出,是否检出打开图纸?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
                {
                    //检出图纸
                    await CheckOut(model);
                }
                else
                {
                    //下载图纸文件，只读打开
                    DownDwgByOpenReadOnly(model);
                }
            }
            else if (model.CheckInOutStatus == 1)//状态为自己检出
            {
                //自己检出，打开图纸编辑
                OpenDwgByMyself(model);
            }
            else if (model.CheckInOutStatus == 2)//状态为别人检出
            {
                //下载图纸文件，只读打开
                DownDwgByOpenReadOnly(model);
            }

        }

        /// <summary>
        /// 自己检出，打开图纸编辑
        /// </summary> 
        private async void OpenDwgByMyself(Model.TreeModel model)
        {
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            var dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            string msg = string.Empty;
            if (!string.IsNullOrEmpty(dwgObj.PCInfo) && !GlobalObject.GetPCInfo().Equals(dwgObj.PCInfo))//对比PCInfo
            {
                if (MessageBoxResult.Yes != MessageBox.Show("服务器记录的检出电脑用户信息与当前电脑用户信息不一致,是否继续打开图纸?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
                {
                    return;
                }
            }
            if (!File.Exists(filePath))
            {
                if (MessageBoxResult.Yes == MessageBox.Show("本地图纸文件不存在,是否需要手动找回图纸?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
                {
                    // 文件选择框
                    OpenFileDialog openFileDialog = new OpenFileDialog();
                    openFileDialog.Title = "选择图纸文件";
                    // 设置过滤器，限制用户只能选择特定类型的文件
                    openFileDialog.Filter = "图纸文件|*.dwg;";
                    // 设置是否允许选择多个文件
                    openFileDialog.Multiselect = false;
                    if (openFileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        // 获取用户选择的文件路径
                        string selectedFilePath = openFileDialog.FileName;
                        File.Copy(selectedFilePath, filePath);
                    }
                }
                else
                {
                    //服务器下载图纸
                    var dwgfileDto = await _annexesService.GetAnnexesFile(dwgObj.FolderId);
                    msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
                    if (!string.IsNullOrEmpty(msg))
                    { MessageBox.Show("图纸文件下载失败，信息:" + msg); return; }
                }
            }
            msg = General.OpenDwg(filePath);//打开编辑图纸
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                return;
            }
            InitDrawingSelectedAdd(dwgObj);
        }
        /// <summary>
        /// 下载图纸文件，只读打开
        /// </summary> 
        private async void DownDwgByOpenReadOnly(Model.TreeModel model)
        {
            #region 下载文件，只读打开
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            var msg = string.Empty;
            var dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            if (File.Exists(filePath))
            {
                if (FileHelper.IsFileLocked(filePath))
                {
                    MessageBox.Show($"本地图纸文件:{filePath} 已被打开！");
                    return;
                }
                //已有本地图纸文件移至备份文件夹 
                string now = DateTime.Now.ToString("yyyyMMddHHmmss");//加上当前时间，防止重名
                string backFile = Path.Combine(GlobalObject.GetBackupDwgFileFolder(model.ID), now + model.Text);
                File.Move(filePath, backFile);
                MessageBox.Show($"本地图纸文件已移至:{backFile} ！");
            }
            // 下载图纸文件再打开
            var dwgfileDto = await _annexesService.GetAnnexesFile(dwgObj.FolderId);
            msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
            if (!string.IsNullOrEmpty(msg))
            { MessageBox.Show("图纸文件下载失败，信息:" + msg); return; }
            msg = General.OpenDwg(filePath, true);//以只读模式打开图纸                

            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                return;
            }
            InitDrawingSelectedAdd(dwgObj, true);
            #endregion
        }
        #endregion

        #region 删除图纸
        /// <summary>
        /// 删除图纸
        /// </summary>
        /// <param name="model">图纸</param>
        private void onDeleteDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            MessageBox.Show("功能开发中...");
        }
        #endregion

        #region 编辑属性
        /// <summary>
        /// 编辑属性
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onPropertyDwg(Model.TreeModel model)
        {
            //取旧的图纸数据
            var oldDwgFile = await _dwgService.GetDrawingFile(model.ID);
            IDialogParameters par = new Prism.Services.Dialogs.DialogParameters();
            par.Add(nameof(ec_drawing_file.DrawingCatalogueID), model);
            _dialogService.ShowDialog(nameof(NewDrawing), par, async (result) =>
            {
                if (result.Result == ButtonResult.OK || result.Result == ButtonResult.Yes)
                {
                    var newDwgFile = await _dwgService.GetDrawingFile(model.ID);
                    //旧的图纸数据和新的图纸数据对比图纸名称、图纸目录是否一致
                    if (oldDwgFile.DrawingFileName != newDwgFile.DrawingFileName || oldDwgFile.DrawingCatalogueID != newDwgFile.DrawingCatalogueID)
                    {
                        //数据不一致，所以需要UI刷新
                        RefreshDrawings();
                    }
                }
            });
        }
        #endregion

        #region 浏览所在文件夹
        /// <summary>
        /// 浏览所在文件夹
        /// </summary>
        /// <param name="model">图纸</param>
        private void onOpenDwgFileFolder(Model.TreeModel model)
        {
            try
            {
                System.Diagnostics.Process.Start(GlobalObject.GetDwgFileFolder(model.ID));
            }
            catch (Exception ex)
            {
                MessageBox.Show($"打开文件夹异常，信息:{ex.Message}");
            }
        }
        #endregion

        #region 检入
        /// <summary>
        /// 检入
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onCheckInDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            string msg = string.Empty;
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            #region 校验

            if (!File.Exists(filePath))
            {
                MessageBox.Show("本地图纸文件不存在，无法检入！");
                return;
            }
            //if (FileHelper.IsFileLocked(filePath))
            //{
            //    MessageBox.Show("图纸文件已被打开,无法进行上传检入,请关闭文件！");
            //    return;
            //}

            var dwgObj = await _dwgService.GetDrawingFile(model.ID);
            if (dwgObj == null)
            {
                MessageBox.Show("服务器不存在当前图纸，检入失败！");
                return;
            }
            else if (dwgObj.IsCheckOut == 0)
            {
                MessageBox.Show("当前图纸状态为：检入，无法再进行检入！");
                return;
            }
            #endregion
            //获取所有打开图纸名
            var listName = General.GetAllOpenDrawingNames();
            if (listName.Contains(filePath))
            {
                //把要检入的图纸切换到当前图纸
                General.SwitchToDocument(filePath);
                //重新已只读模式打开图纸,有未保存的会自动保存
                General.SetDrawingReadOnly(filePath, true);
                var item = GlobalObject.ListDwgOpened.FirstOrDefault(a => a.Path == filePath);
                if (item != null)
                { GlobalObject.ListDwgOpened.Remove(item); }
                InitDrawingSelectedAdd(dwgObj, true);
            }
            else
            {
                //以只读模式打开图纸
                msg = General.OpenDwg(filePath, true);
                InitDrawingSelectedAdd(dwgObj, true);
            }
            //获取当前图纸所有句柄
            var listHandles = General.GetHandles();
            if (!listHandles.Any())
            {
                //ec_drawing_syn syn = new ec_drawing_syn();
                //syn.FolderId = dwgObj.FolderId;
                //syn.DrawingFileID = dwgObj.DrawingFileID;
                //CheckInModel checkin=new CheckInModel();
                //checkin.handles = listHandles;
                //checkin.dwgObj = dwgObj;
                //checkin.syn = syn;
                //CheckInDwg(checkin);
                //dwgObj.CheckOutUserID = "";
                //dwgObj.CheckOutUserName = "";
                //dwgObj.IsCheckOut = 0;
                //UpdateNode(model, dwgObj);
                //General.SetDrawingReadOnly(filePath, false);
                //InitDrawingSelectedAdd(dwgObj);
                //return;
            }
            string lines = string.Empty;
            if (MessageBoxResult.Yes == MessageBox.Show("是否关联云线?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
            {
                isCheckIn = true;
                General.SelectHandles.Clear();
                var listLine = General.StartLineSelection();
                if (listLine.Any()) { lines = string.Join("|", listLine); }

            }
            ec_drawing_file dwgFile = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters par = new Prism.Services.Dialogs.DialogParameters();
            par.Add(GlobalObject.dialogPar.info.ToString(), dwgFile);
            par.Add(GlobalObject.dialogPar.para1.ToString(), listHandles);
            par.Add(GlobalObject.dialogPar.para2.ToString(), lines);
            _dialogService.ShowDialog(nameof(DialogPreCheckIn), par, (result) =>
            {
                if (result.Result == ButtonResult.OK || result.Result == ButtonResult.Yes)
                {
                    dwgObj.CheckOutUserID = "";
                    dwgObj.CheckOutUserName = "";
                    dwgObj.IsCheckOut = 0;
                    UpdateNode(model, dwgObj);
                    //重新改变当前图纸为可编辑模式
                }
                General.SetDrawingReadOnly(filePath, false);
                InitDrawingSelectedAdd(dwgObj);
            });
            isCheckIn = false;
            return;

            ////预检入校验
            //msg = await _dwgService.PreCheckInDrawingFile(dwgObj);
            //if (!string.IsNullOrEmpty(msg))
            //{
            //    MessageBox.Show($"预检入失败,信息:{msg}");
            //    return;
            //}
            ////上传文件，获取文件新FolderId
            //var newFolderId = await _annexesService.UploadFile(filePath, dwgObj.DrawingFileName);
            //dwgObj.FolderId = newFolderId;
            //dwgObj.FileMD5 = FileHelper.GetFileMD5(filePath);

            ////检入第一步
            //msg = await _dwgService.CheckInDrawingFileStep1(dwgObj);
            //if (!string.IsNullOrEmpty(msg))
            //{
            //    MessageBox.Show($"检入失败,信息:{msg}");
            //    return;
            //}

            ////检入第二步
            //msg = await _dwgService.CheckInDrawingFileStep2(dwgObj);
            //if (!string.IsNullOrEmpty(msg))
            //{
            //    MessageBox.Show($"检入失败,信息:{msg}");
            //    return;
            //}
            //MessageBox.Show("检入成功！");
            //dwgObj = await _dwgService.GetDrawingFile(model.ID);
            //UpdateNode(model, dwgObj);
        }
        private async void CheckInDwg(CheckInModel model)
        {
            ec_drawing_file dwgObj = model.dwgObj;
            List<string> handles = model.handles;
            ec_drawing_syn syn = model.syn;
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.dwgObj.DrawingFileID), dwgObj.DrawingFileName);
            //预检入校验
            var msg = await _dwgService.PreCheckInDrawingFile(dwgObj, handles);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"预检入失败,信息:{msg}");
                return;
            }
            //上传文件，获取文件新FolderId
            var newFolderId = await _annexesService.UploadFile(filePath, dwgObj.DrawingFileName);
            dwgObj.FolderId = newFolderId;
            dwgObj.FileMD5 = FileHelper.GetFileMD5(filePath);

            //检入第一步
            msg = await _dwgService.CheckInDrawingFileStep1(dwgObj, handles);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"检入失败,信息:{msg}");
                return;
            }

            //检入第二步
            msg = await _dwgService.CheckInDrawingFileStep2(dwgObj, syn);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"检入失败,信息:{msg}");
                return;
            }
            MessageBox.Show("检入成功！");
            eventAggregator.GetEvent<checkInResultEvent>().Publish(true);
            //dwgObj = await _dwgService.GetDrawingFile(dwgObj.DrawingFileID);
            //UpdateNode(model, dwgObj);d
        }
        #endregion

        #region 检出
        /// <summary>
        /// 检出
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onCheckOutDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            var flag = await CheckOut(model);//检出操作
            //if (!flag)
            //{ return; }
            //if (MessageBoxResult.Yes == MessageBox.Show("检出成功,是否打开图纸文件?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
            //{
            //    //打开图纸文件
            //    string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(), model.Text);
            //    var msg = CADFunc.General.OpenDwg(filePath);
            //    if (!string.IsNullOrEmpty(msg))
            //    {
            //        MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息：{msg}");
            //        return;
            //    }
            //};
        }
        /// <summary>
        /// 检出
        /// </summary>
        /// <param name="model">图纸节点</param>
        /// <returns></returns>
        private async Task<bool> CheckOut(Model.TreeModel model)
        {
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            if (File.Exists(filePath))
            {
                if (FileHelper.IsFileLocked(filePath))
                {
                    MessageBox.Show($"本地图纸文件:{model.Text} 已存在并被打开,请关闭文件再检出");
                    return false;
                }
                string backFolder = GlobalObject.GetBackupDwgFileFolder(model.ID);
                if (MessageBoxResult.OK == MessageBox.Show($"本地图纸文件:{model.Text} 已存在,继续检出会把本地图纸移至:[{backFolder}]", "是否继续检出", MessageBoxButton.OKCancel, MessageBoxImage.Question))
                {
                    //本地图纸文件移至备份文件夹 
                    string now = DateTime.Now.ToString("yyyyMMddHHmmss");//加上当前时间，防止重名
                    string backFile = Path.Combine(GlobalObject.GetBackupDwgFileFolder(model.ID), now + model.Text);
                    File.Move(filePath, backFile);
                }
                else
                {
                    return false;
                }
            }
            ec_drawing_file dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            //下载文件 
            var dwgfileDto = await _annexesService.GetAnnexesFile(dwgObj.FolderId);
            var msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
            if (!string.IsNullOrEmpty(msg))
            { MessageBox.Show("图纸文件下载失败，信息:" + msg); return false; }

            //检出接口提交修改信息 
            msg = await _dwgService.CheckOutDrawingFile(dwgObj.DrawingFileID);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"检出失败,信息:{msg}");
                return false;
            }
            //打开图纸文件
            filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            msg = General.OpenDwg(filePath);

            //更新图纸节点图标和字体颜色
            dwgObj.CheckOutUserID = GlobalObject.userInfo.userId;
            dwgObj.CheckOutUserName = GlobalObject.userInfo.RealName;
            dwgObj.CheckOutTime = DateTime.Now;
            dwgObj.IsCheckOut = 1;
            UpdateNode(model, dwgObj);
            //设置图纸选中元素回调
            InitDrawingSelectedAdd(dwgObj);
            return true;
        }
        #endregion

        #region 释放
        /// <summary>
        /// 释放
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onFreeDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            if (MessageBoxResult.Yes != MessageBox.Show($"确定忽略本地文件修改，释放文件的占用状态?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Question))
            {
                return;
            }
            var msg = await _dwgService.FreeDrawingFile(model.ID);
            if (!string.IsNullOrEmpty(msg))
            { MessageBox.Show("释放失败，信息:" + msg); return; }
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            if (!FileHelper.IsFileLocked(filePath))
            { File.Delete(filePath); }//删除本地图纸文件
            MessageBox.Show("释放成功！");
            var dwgObj = await _dwgService.GetDrawingFile(model.ID);
            UpdateNode(model, dwgObj);
        }
        #endregion

        #region 上移\下移
        /// <summary>
        /// 上移
        /// </summary>
        /// <param name="node">图纸</param>
        private async void onUpDwg(Model.TreeModel node)
        {
            //MessageBox.Show("功能开发中...");
            //return;
            var preNode = GetPreviousNode(node);
            if (preNode == null)
            {
                MessageBox.Show("当前图纸为第一个，不能上移");
                return;
            }
            var preDwgFile = await _dwgService.GetDrawingFile(preNode.ID);
            preDwgFile.OrderID++;
            var msg = await _dwgService.UpdateDrawingFile(preDwgFile);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show("修改前一个图纸数据失败，信息:" + msg); return;
            }
            var dwgFile = await _dwgService.GetDrawingFile(node.ID);
            dwgFile.OrderID--;
            msg = await _dwgService.UpdateDrawingFile(dwgFile);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show("修改一个图纸数据失败，信息:" + msg); return;
            }
            MoveItem(drawings, node, -1);//图纸树UI刷新，当前节点上移一个位置
            MessageBox.Show("上移成功");
        }

        /// <summary>
        /// 下移
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onDownDwg(Model.TreeModel node)
        {
            //MessageBox.Show("功能开发中...");
            //return;

            var nextNode = GetNextNode(node);
            if (nextNode == null)
            {
                MessageBox.Show("当前图纸为最后一个，不能下移");
                return;
            }
            var preDwgFile = await _dwgService.GetDrawingFile(nextNode.ID);
            preDwgFile.OrderID--;
            var msg = await _dwgService.UpdateDrawingFile(preDwgFile);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show("修改前一个图纸数据失败，信息:" + msg); return;
            }
            var dwgFile = await _dwgService.GetDrawingFile(node.ID);
            dwgFile.OrderID++;
            msg = await _dwgService.UpdateDrawingFile(dwgFile);
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show("修改一个图纸数据失败，信息:" + msg); return;
            }
            MoveItem(drawings, node, 1);//图纸树UI刷新，当前节点下移一个位置
            MessageBox.Show("下移成功");
        }

        /// <summary>
        /// 获取当前节点的前一个节点
        /// </summary> 
        /// <returns></returns>
        private Model.TreeModel GetPreviousNode(Model.TreeModel node)
        {
            if (string.IsNullOrEmpty(node.parentId)) return null; //根节点无上级节点
            var dwgFile = drawings.FirstOrDefault(a => a.ID == node.parentId);
            if (dwgFile == null) { return null; }
            var listNodes = dwgFile.ChildNodes;
            int index = listNodes.IndexOf(node);
            return index > 0 ? listNodes[index - 1] : null;
        }
        /// <summary>
        /// 获取当前节点的后一个节点
        /// </summary> 
        /// <returns></returns>
        public Model.TreeModel GetNextNode(Model.TreeModel node)
        {
            if (string.IsNullOrEmpty(node.parentId)) return null; //根节点无上级节点
            var dwgFile = drawings.FirstOrDefault(a => a.ID == node.parentId);
            if (dwgFile == null) { return null; }
            var listNodes = dwgFile.ChildNodes;
            int index = listNodes.IndexOf(node);
            var listOrderId = listNodes.Select(a => a.OrderNo).ToList();
            var maxIndex = listOrderId.Max();
            return index < maxIndex - 1 ? listNodes[index + 1] : null;
        }
        /// <summary>
        /// 移动元素位置
        /// </summary>
        /// <param name="collection">目标集合</param>
        /// <param name="item">要移动的元素</param>
        /// <param name="step">移动步数（正数后移，负数前移）</param>
        public void MoveItem(ObservableCollection<Model.TreeModel> list, Model.TreeModel item, int step)
        {
            Model.TreeModel parentNode = list.FirstOrDefault(a => a.ID == item.parentId);
            if (parentNode == null)
                return;
            var listNodes = parentNode.ChildNodes;
            if (listNodes == null || !listNodes.Contains(item))
                return;

            int oldIndex = listNodes.IndexOf(item);
            int newIndex = oldIndex + step;
            // 边界检查
            if (newIndex < 0) newIndex = 0;
            if (newIndex >= listNodes.Count) newIndex = listNodes.Count - 1;
            listNodes.Move(oldIndex, newIndex);
            //return list;
        }
        #endregion

        #region 生成文件材料表
        /// <summary>
        /// 生成文件材料表
        /// </summary>
        /// <param name="model">图纸</param>
        private void onGenerateFileMaterialDwg(Model.TreeModel model)
        {
            MessageBox.Show("功能开发中...");
        }
        #endregion

        #region 修订
        /// <summary>
        /// 修订
        /// </summary>
        /// <param name="model">图纸</param>
        private void onReviseDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            ec_drawing_file dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.title.ToString(), $"[{dwgObj.DrawingFileName}] 文件版本号输入");
            x.Add(GlobalObject.dialogPar.info.ToString(), "文件版本号：");
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogInput), x, async (RES) =>
            {
                if (RES.Result == ButtonResult.Yes)
                {
                    var version = RES.Parameters.GetValue<string>(GlobalObject.dialogPar.info.ToString());
                    var msg = await _dwgService.ModifyDrawingFile(model.ID, version);
                    if (string.IsNullOrEmpty(msg))
                    {
                        MessageBox.Show("修订成功！");
                        //获取最新图纸信息
                        dwgObj = await _dwgService.GetDrawingFile(model.ID);
                        //更新图纸节点图标和字体颜色
                        UpdateNode(model, dwgObj);
                    }
                    else { MessageBox.Show("修订失败：" + msg); }
                }
                else if (RES.Result == ButtonResult.No)
                { }
            });
        }
        #endregion

        #region 发布
        /// <summary>
        /// 发布
        /// </summary>
        /// <param name="model">图纸</param>
        private void onPublishDwg(Model.TreeModel model)
        {
            if (!IsCanEdit(model))
            {
                MessageBox.Show("当前用户没有权限操作图纸！");
                return;
            }
            ec_drawing_file dwgObj = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.title.ToString(), $"[{dwgObj.DrawingFileName}] 文件发布");
            x.Add(GlobalObject.dialogPar.info.ToString(), "注释：");
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogInput), x, async (RES) =>
            {
                if (RES.Result == ButtonResult.Yes)
                {
                    var remark = RES.Parameters.GetValue<string>(GlobalObject.dialogPar.info.ToString());
                    var msg = await _dwgService.PublishDrawingFile(model.ID, remark);
                    if (string.IsNullOrEmpty(msg))
                    {
                        MessageBox.Show("发布成功！");
                        //获取最新图纸信息
                        dwgObj = await _dwgService.GetDrawingFile(model.ID);
                        //更新图纸节点图标和字体颜色
                        UpdateNode(model, dwgObj);
                        //更新图纸历史树
                        InitHistoryDrawings();
                    }
                    else { MessageBox.Show("发布失败：" + msg); }
                }
                else if (RES.Result == ButtonResult.No)
                { }
            });
        }
        #endregion

        #region 检入记录
        /// <summary>
        /// 检入记录
        /// </summary>
        /// <param name="model">图纸</param>
        private void onCheckInRecordDwg(Model.TreeModel model)
        {
            var dwg = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.info.ToString(), dwg);
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogCheckInRecord), x, (RES) =>
            {
            });
        }
        #endregion

        #region 检入审核
        /// <summary>
        /// 检入审核
        /// </summary>
        /// <param name="model">图纸</param>
        private void onCheckInAuditDwg(Model.TreeModel model)
        {
            var view = GlobalObject.container.Resolve<CheckInApprove>();
            if (GlobalObject.userInfo != null)
            {
                Application.ShowModalWindow(Application.MainWindow.Handle, view);
            }
        }
        #endregion

        #region 发布记录
        /// <summary>
        /// 发布记录
        /// </summary>
        /// <param name="model">图纸</param>
        private void onPublishRecordDwg(Model.TreeModel model)
        {
            var dwg = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.info.ToString(), dwg);
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogPublishRecord), x, (RES) =>
            {
            });
        }
        #endregion

        #region 操作记录
        /// <summary>
        /// 操作记录
        /// </summary>
        /// <param name="model">图纸</param>
        private void onOperateRecordDwg(Model.TreeModel model)
        {
            var dwg = JsonConvert.DeserializeObject<ec_drawing_file>(model.NodeExtData.ToString());
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.info.ToString(), dwg);
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogOperateRecord), x, (RES) =>
            {
            });
        }
        #endregion

        #region 获取并显示图元列表
        private ObservableCollection<Model.KeyValueModel> ListTagNumber = new ObservableCollection<Model.KeyValueModel>();
        /// <summary>
        /// 获取并显示图元列表
        /// </summary>
        /// <param name="id"></param>
        private async void GetLibrary(string id)
        {
            try
            {
                if (id == "000")
                { return; }
                #region 获取图元列表，并显示出来
                var list = await objectTypeService.GetLibraryDataById(id);
                var flag = false;
                var msg = string.Empty;
                listLibrary?.Clear();
                foreach (var item in list)
                {
                    //下载文件 
                    var dwgfileDto = await _annexesService.GetAnnexesFile(item.FolderId);
                    var filePath = Path.Combine(GlobalObject.GetDwgFileFolder(id), item.LibraryFileName + ".dwg");
                    if (File.Exists(filePath))
                    { File.Delete(filePath); }
                    msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
                    if (!string.IsNullOrEmpty(msg))
                    {
                        flag = true;
                        continue;
                    }
                    var img = General.GetDwgThumbnail(filePath);
                    if (img != null)
                    {
                        var imgPath = Path.Combine(GlobalObject.GetDwgFileFolder(id), item.LibraryFileName + ".png");
                        if (File.Exists(imgPath))
                        { File.Delete(imgPath); }
                        img.Save(imgPath);
                        item.ImagePath = imgPath;
                    }
                }
                if (flag)
                {
                    MessageBox.Show($"图元文件下载失败，信息:" + msg);
                }
                listLibrary = new ObservableCollection<ec_library_file>(list);
                #endregion

                #region 获取位号列表
                ListTagNumber.Clear();
                var listTag = await objectTypeService.GetTagNumberById(id);
                if (listTag != null)
                {
                    foreach (var item in listTag)
                    {
                        if (string.IsNullOrEmpty(item.TagNumber))
                        { continue; }
                        if (ListTagNumber.FirstOrDefault(a => a.Key == item.TagNumber) != null)
                        { continue; }
                        ListTagNumber.Add(new Model.KeyValueModel() { Key = item.TagNumber, Value = item.EngineDataID });
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                MessageBox.Show($"图元列表异常:" + ex.Message);
            }
        }
        #endregion

        #region 选中的设计浏览树节点
        /// <summary>
        /// 选中的设计浏览树节点
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onDesignSelectedChange(TreeModel reeModel)
        {
            selectDesign = await InitDesignChildren(reeModel);
            //OnPropertyChanged(nameof(selectDesign));
        }

        /// <summary>
        /// 获取对象类型下的所有现有位号清单(仅有位号)
        /// </summary>
        /// <param name="Model.TreeModel"></param>
        /// <returns></returns>
        private async Task<Model.TreeModel> InitDesignChildren(TreeModel TreeModel)
        {
            if (TreeModel == null) { return null; }
            if (TreeModel.ChildNodes.Count <= 0)
            {
                if (TreeModel.NodeType == "91")
                {
                    var pixel = JsonConvert.DeserializeObject<ec_enginedata_pixel>(TreeModel.NodeExtData.ToString());
                    var dwgObj = await _dwgService.GetDrawingFile(pixel.DrawingFileID);
                    //获取属性
                    eventAggregator.GetEvent<drawingChangeEvent>().Publish(dwgObj);
                    return TreeModel;
                }
                else if (TreeModel.NodeType == "9")
                {
                    //获取位号的pixel对象
                    var list = await _enginedataService.GetTagPixelsById(TreeModel.ID);
                    if (list.Any())
                    {
                        ObservableCollection<Model.TreeModel> listTree = new ObservableCollection<Model.TreeModel>();
                        foreach (var item in list)
                        {
                            var node = new Model.TreeModel();
                            node.ID = item.DrawingFileID;
                            node.Text = item.DrawingFileName;
                            node.ToolTipText = item.DrawingFileName;
                            node.NodeType = "91";
                            //node.Glyph = "&#xe147;";
                            node.FontColor = new SolidColorBrush(Colors.DeepSkyBlue); //图纸名称字体颜色：蓝色
                            node.ChildNodes = new ObservableCollection<Model.TreeModel>();
                            var dwgFile = await _dwgService.GetDrawingFile(item.DrawingFileID);
                            UpdateNode(node, dwgFile);
                            node.NodeExtData = JsonConvert.SerializeObject(item);
                            listTree.Add(node);
                        }
                        TreeModel.ChildNodes = new ObservableCollection<Model.TreeModel>(listTree);
                        TreeModel.isexpand = true;
                    }
                    //获取属性
                    eventAggregator.GetEvent<tagChangeEvent>().Publish(TreeModel);
                }
                else
                {
                    var list = await objectTypeService.GetTagNumberById_Brief(TreeModel.ID);
                    if (list.Any())
                    {
                        foreach (var item in list)
                        {
                            item.NodeType = "9";
                            item.Glyph = "&#xe147;";
                            item.FontColor = new SolidColorBrush(Colors.DeepSkyBlue); //图纸名称字体颜色：蓝色
                            item.ChildNodes = new ObservableCollection<Model.TreeModel>();
                        }
                        TreeModel.ChildNodes = new ObservableCollection<Model.TreeModel>(list);
                        TreeModel.isexpand = true;
                    }
                    //获取属性
                    eventAggregator.GetEvent<treeNodeChangeEvent>().Publish(TreeModel);
                }

            }
            else
            { //获取属性
                eventAggregator.GetEvent<tagChangeEvent>().Publish(TreeModel);
            }

            return TreeModel;
        }
        #endregion

        #region 双击设计浏览树的图纸节点
        /// <summary>
        /// 双击设计浏览树的图纸节点
        /// </summary>
        /// <param name="model"></param>
        private async void onDesignDoubleClick(Model.TreeModel model)
        {
            if (model == null) return;
            if (model.NodeType != "91") return;
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            var pixel = JsonConvert.DeserializeObject<ec_enginedata_pixel>(model.NodeExtData.ToString());
            var dwgObj = await _dwgService.GetDrawingFile(pixel.DrawingFileID);
            //获取属性
            eventAggregator.GetEvent<drawingChangeEvent>().Publish(dwgObj);
            string msg = string.Empty;
            if (model.CheckInOutStatus == 1)
            {
                #region 自己检出则下载图纸并打开编辑

                if (!GlobalObject.GetPCInfo().Equals(dwgObj.PCInfo))
                {
                    MessageBox.Show($"当前图纸被:【{dwgObj.PCInfo}】检出，请注意同时编辑可能丢失数据！");
                }
                if (File.Exists(filePath))
                {
                    #region 当图纸文件已被打开时，直接打开图纸并选中图元
                    if (FileHelper.IsFileLocked(filePath))
                    {
                        msg = General.OpenDwg(filePath);//打开编辑图纸
                        if (!string.IsNullOrEmpty(msg))
                        {
                            MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                            return;
                        }
                        //根据句柄设置选中图元
                        msg = General.SelectEntityByHandle(pixel.PixelCode);
                        if (!string.IsNullOrEmpty(msg))
                        {
                            MessageBox.Show(msg);
                        }
                        return;
                    }
                    #endregion
                    //图纸未被打开则删除再下载服务器最新图纸
                    File.Delete(filePath);
                }
                //服务器下载图纸
                var dwgfileDto = await _annexesService.GetAnnexesFile(dwgObj.FolderId);
                msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
                if (!string.IsNullOrEmpty(msg))
                { MessageBox.Show("图纸文件下载失败，信息:" + msg); return; }
                msg = General.OpenDwg(filePath);//打开编辑图纸
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                    return;
                }
                //根据句柄设置选中图元
                msg = General.SelectEntityByHandle(pixel.PixelCode);
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show(msg);
                    return;
                }

                #endregion
            }
            else
            {
                #region 未检出或别人检出，则下载图纸并只读打开 
                if (File.Exists(filePath))
                {
                    #region 当图纸文件已被打开时，直接打开图纸并选中图元
                    if (FileHelper.IsFileLocked(filePath))
                    {
                        msg = General.OpenDwg(filePath, true);//只读打开图纸
                        if (!string.IsNullOrEmpty(msg))
                        {
                            MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                            return;
                        }
                        //根据句柄设置选中图元
                        msg = General.SelectEntityByHandle(pixel.PixelCode);
                        if (!string.IsNullOrEmpty(msg))
                        {
                            MessageBox.Show(msg);
                        }
                        return;
                    }
                    #endregion
                    //图纸未被打开则删除再下载服务器最新图纸
                    File.Delete(filePath);
                }
                //服务器下载图纸
                var dwgfileDto = await _annexesService.GetAnnexesFile(dwgObj.FolderId);
                msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
                if (!string.IsNullOrEmpty(msg))
                { MessageBox.Show("图纸文件下载失败，信息:" + msg); return; }

                msg = General.OpenDwg(filePath, true);//只读打开图纸
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                    return;
                }
                //根据句柄设置选中图元
                msg = General.SelectEntityByHandle(pixel.PixelCode);
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show(msg);
                }
                #endregion
            }
        }
        #endregion

        #region 图纸选中元素，获取属性
        /// <summary>
        /// 图纸选中元素，获取属性
        /// </summary>
        /// <param name="isReadOnly">是否只读</param>
        private void InitDrawingSelectedAdd(ec_drawing_file dwgObj, bool isReadOnly = false)
        {
            //GlobalObject.drawingFileId = dwgObj.DrawingFileID;
            var doc = Application.DocumentManager.MdiActiveDocument;
            doc.CloseWillStart += onCloseWillStart;
            var ed = doc.Editor;
            ed.SelectionAdded += OnSelectionAdded;
            GlobalObject.ListDwgOpened.Add(new DrawingOpened()
            {
                Id = dwgObj.DrawingFileID,
                Path = Path.Combine(GlobalObject.GetDwgFileFolder(dwgObj.DrawingFileID), dwgObj.DrawingFileName),
                IsReadOnly = isReadOnly
            });
        }
        /// <summary>
        /// 图纸选中元素，获取属性
        /// </summary>
        private void InitDrawingSelectedAdd(Model.TreeModel dwgObj, bool isReadOnly = false)
        {
            //GlobalObject.drawingFileId = dwgObj.DrawingFileID;
            var doc = Application.DocumentManager.MdiActiveDocument;
            doc.CloseWillStart += onCloseWillStart;
            var ed = doc.Editor;
            ed.SelectionAdded += OnSelectionAdded;
            //GlobalObject.ListDwgOpened.Add(Path.Combine(GlobalObject.GetDwgFileFolder(), dwgObj.Text), dwgObj.ID);
            GlobalObject.ListDwgOpened.Add(new DrawingOpened()
            {
                Id = dwgObj.ID,
                Path = Path.Combine(GlobalObject.GetDwgFileFolder(dwgObj.ID), dwgObj.Text),
                IsReadOnly = isReadOnly
            });
        }
        /// <summary>
        /// 添加选中元素事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnSelectionAdded(object sender, SelectionAddedEventArgs e)
        {
            #region 过滤500毫秒内多次事件响应
            //var span = DateTime.Now - GlobalObject.preClickTime;
            //if (span.TotalMilliseconds < 500)
            //{
            //    Console.WriteLine($"当前时间：{DateTime.Now.ToString("HH:mm:ss:ffff")},上次点击时间:{GlobalObject.preClickTime.ToString("HH:mm:ss:ffff")}在500毫秒内，不处理");
            //    return;
            //}
            //else
            //{
            //    GlobalObject.preClickTime = DateTime.Now;
            //    Console.WriteLine($"当前时间：{DateTime.Now.ToString("HH:mm:ss:ffff")},上次点击时间:{GlobalObject.preClickTime.ToString("HH:mm:ss:ffff")}");
            //}
            #endregion


            try
            {

                var doc = Application.DocumentManager.MdiActiveDocument;
                var ed = doc.Editor;
                if (e.AddedObjects.Count > 0)
                {
                    List<string> listHand = new List<string>();
                    using (Transaction tr = doc.TransactionManager.StartTransaction())
                    {
                        //var obj = e.AddedObjects[e.AddedObjects.Count - 1];
                        for (int i = 0; i < e.AddedObjects.Count; i++)
                        {
                            var obj = e.AddedObjects[i];
                            Entity ent = tr.GetObject(obj.ObjectId, OpenMode.ForWrite) as Entity;
                            var xdata = ent.XData;
                            if (ent != null)
                            {
                                if (isCheckIn)
                                {
                                    ent.ColorIndex = 1;//1为红色
                                    if (!General.SelectHandles.Contains(ent.Handle.ToString()))
                                    {
                                        General.SelectHandles.Add(ent.Handle.ToString());
                                    }
                                }
                                else if (isObjectTypeGuanlian)
                                {
                                    if (!General.SelectHandles.Contains(ent.Handle.ToString()))
                                    {
                                        General.SelectHandles.Add(ent.Handle.ToString());
                                    }
                                }
                                else if (isIOassociationChannel)
                                {
                                    List<string> listHandId = new List<string>();
                                    if (!General.SelectHandles.Contains(ent.Handle.ToString()))
                                    {
                                        General.SelectHandles.Add(ent.Handle.ToString());
                                        listHandId.Add(ent.Handle.ToString());
                                    }
                                    eventAggregator.GetEvent<GetHandsIdEvent>().Publish(listHandId);

                                }
                                else
                                {
                                    listHand.Add(ent.Handle.ToString());
                                }
                            }
                        }
                        if (!isCheckIn)
                        { eventAggregator.GetEvent<getPropertyEvent>().Publish(listHand); }
                        tr.Commit();
                    }
                }

                //var doc = Application.DocumentManager.MdiActiveDocument;
                //var ed = doc.Editor;
                //if (e.AddedObjects.Count > 0)
                //{
                //    using (Transaction tr = doc.TransactionManager.StartTransaction())
                //    {
                //        var obj = e.AddedObjects[e.AddedObjects.Count - 1];


                //        Entity ent = tr.GetObject(obj.ObjectId, OpenMode.ForRead) as Entity;
                //        if (ent != null && ent.XData != null)
                //        {
                //            var handlid = ent.Handle.ToString();
                //            // 在此处理被点击的图元
                //            //ed.WriteMessage($"\n选中图元：{ent.GetType().Name}, 句柄：{ent.Handle}");
                //            eventAggregator.GetEvent<selectPixelsEvent>().Publish(handlid);
                //            ed.WriteMessage($"\n选中图元事件触发：{handlid} \n");
                //        }
                //        else if (ent != null && ent.XData == null)
                //        {
                //            var handlid = ent.Handle.ToString();
                //            ed.WriteMessage($"\n选中图元：{handlid} XData为空\n");
                //        }
                //        tr.Commit();
                //    }
                //}
                //获取属性事件

            }
            catch (Exception ex)
            {

            }
        }
        /// <summary>
        /// 关闭图纸事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void onCloseWillStart(object sender, EventArgs e)
        {
            var name = General.GetDwgName();
            var dwg = GlobalObject.ListDwgOpened.FirstOrDefault(a => a.Path == name);
            if (dwg != null)
            { GlobalObject.ListDwgOpened.Remove(dwg); }
        }
        #endregion

        #region 初始化历史版次图纸树
        /// <summary>
        /// 初始化历史版次图纸树
        /// </summary>
        private async void InitHistoryDrawings()
        {
            var historyDrawingsTree = await _dwgService.GetDrawingCatalogue();
            historyDrawingsTree = CheckInOutStatus(historyDrawingsTree);
            var listHistory = await _dwgService.GetPublishedDwg();
            if (listHistory.Any())
            {
                //历史树1
                //historyDrawings = FilterHistoryTree(historyDrawingsTree, listHistory);
                //FilterHistoryZero(historyDrawings);

                #region 历史树2 
                historyDrawings = new ObservableCollection<Model.TreeModel>();
                for (int i = 0; i < GlobalObje.DwgStage().Count; i++)
                {
                    var stage = GlobalObje.DwgStage()[i];
                    historyDrawings.Add(new Model.TreeModel() { ID = i.ToString(), Text = stage.DataItemName, NodeType = "0", ChildNodes = new ObservableCollection<Model.TreeModel>() });
                }
                foreach (var item in listHistory)
                {
                    var stageNode = historyDrawings.FirstOrDefault(a => a.Text == item.FileVersion);
                    if (stageNode != null)
                    {
                        Model.TreeModel node = null;
                        foreach (var dto in historyDrawingsTree)
                        {
                            //获取节点下的图纸
                            node = TreeHelper.GetTreeModel(dto, item.DrawingFileID);
                            if (node != null)
                            {
                                break;
                            }
                        }
                        if (node == null) { continue; }
                        var model = new Model.TreeModel()
                        {
                            ID = item.DrawingFileID,
                            Text = node.Text,
                            NodeType = "99",//历史图纸类型99
                            NodeExtData = JsonConvert.SerializeObject(item)
                        };
                        var dwg = JsonConvert.DeserializeObject<ec_drawing_file>(node.NodeExtData.ToString());
                        UpdateNode(model, dwg);
                        stageNode.ChildNodes.Add(model);
                    }
                }
                #endregion
            }
        }


        /// <summary>
        /// 遍历图纸把有历史版次的图纸加入进去
        /// </summary>
        /// <param name="nodes">完整的节点</param> 
        /// <returns></returns>
        private ObservableCollection<Model.TreeModel> FilterHistoryTree(ObservableCollection<Model.TreeModel> nodes, List<ec_drawing_publish> listHistory)
        {
            foreach (var node in nodes)
            {
                if (node.Text.ToLower().EndsWith(".dwg"))
                {
                    var list = listHistory.Where(a => a.DrawingFileID == node.ID).ToList();
                    if (list.Any())
                    {
                        if (node.ChildNodes == null)
                        { node.ChildNodes = new ObservableCollection<Model.TreeModel>(); }
                        foreach (var item in list)
                        {
                            var name = node.Text.Replace(".dwg", "");
                            var model = new Model.TreeModel()
                            {
                                ID = item.DrawingFileID,
                                Text = $"{name}({item.FileVersion}).dwg",
                                NodeType = "99",
                                NodeExtData = JsonConvert.SerializeObject(item)
                            };
                            node.ChildNodes.Add(model);
                        }
                        node.isexpand = true;
                    }
                    else
                    {
                        node.NodeType = "-1";//没有历史版次，当前节点要删除
                    }
                }
                else
                {
                    FilterHistoryTree(node.ChildNodes, listHistory);
                }
            }
            return nodes;
        }
        /// <summary>
        /// 遍历图纸把没有历史版次的图纸删除
        /// </summary>
        /// <param name="nodes">完整的节点</param> 
        /// <returns></returns>
        private ObservableCollection<Model.TreeModel> FilterHistoryTreeDwgZero(ObservableCollection<Model.TreeModel> nodes)
        {
            if (nodes == null)
            { return null; }
            foreach (var node in nodes)
            {
                var list = node.ChildNodes;
                if (list != null && list.Any())
                {
                    ObservableCollection<Model.TreeModel> listRemove = new ObservableCollection<Model.TreeModel>();
                    foreach (var item in list)
                    {
                        if (item.NodeType == "-1")
                        { listRemove.Add(item); }
                    }
                    foreach (var item in listRemove)
                    {
                        node.ChildNodes.Remove(item);
                    }
                    if (node.ChildNodes.Any())
                    { node.isexpand = true; }
                }
                FilterHistoryTreeDwgZero(node.ChildNodes);
            }
            return nodes;
        }
        /// <summary>
        /// 遍历图纸把没有下级的目录删除
        /// </summary>
        /// <param name="nodes">完整的节点</param> 
        /// <returns></returns>
        private ObservableCollection<Model.TreeModel> FilterHistoryTreeFolderZero(ObservableCollection<Model.TreeModel> nodes)
        {
            if (nodes == null)
            { return null; }
            foreach (var node in nodes)
            {
                FilterHistoryTreeFolderZero(node.ChildNodes);
                if ((node.ChildNodes == null || !node.ChildNodes.Any()) && node.NodeType != "99")
                { node.NodeType = "-1"; }
                ObservableCollection<Model.TreeModel> listRemove = new ObservableCollection<Model.TreeModel>();
                var list = node.ChildNodes;
                if (list != null && list.Any())
                {
                    foreach (var item in list)
                    {
                        if (item.NodeType == "-1")
                        { listRemove.Add(item); }
                    }
                    foreach (var item in listRemove)
                    {
                        node.ChildNodes.Remove(item);
                    }
                    if ((node.ChildNodes == null || !node.ChildNodes.Any()) && node.NodeType != "99")
                    { node.NodeType = "-1"; }
                    if (node.ChildNodes.Any())
                    { node.isexpand = true; }
                }
            }
            return nodes;
        }
        /// <summary>
        /// 过滤没有下级历史图纸的节点
        /// </summary>
        /// <param name="nodes"></param>
        private void FilterHistoryZero(ObservableCollection<Model.TreeModel> nodes)
        {
            FilterHistoryTreeDwgZero(nodes);
            FilterHistoryTreeFolderZero(nodes);
            ObservableCollection<Model.TreeModel> listRemove = new ObservableCollection<Model.TreeModel>();

            foreach (var item in nodes)
            {
                if (item.NodeType == "-1")
                { listRemove.Add(item); }
            }
            foreach (var item in listRemove)
            {
                nodes.Remove(item);
            }
        }
        #endregion

        #region 只读打开历史版次图纸
        /// <summary>
        /// 只读打开历史版次图纸
        /// </summary>
        /// <param name="model">图纸</param>
        private async void onReadOnlyOpenDwg(Model.TreeModel model)
        {
            #region 下载文件，只读打开
            string filePath = Path.Combine(GlobalObject.GetDwgFileFolder(model.ID), model.Text);
            var msg = string.Empty;
            var dwgPublishObj = JsonConvert.DeserializeObject<ec_drawing_publish>(model.NodeExtData.ToString());
            if (File.Exists(filePath))
            {
                msg = General.OpenDwg(filePath, true);//以只读模式打开图纸   
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                }
                //设置图纸选中元素回调
                InitDrawingSelectedAdd(model, true);
                return;
            }
            // 下载图纸文件再打开
            var dwgfileDto = await _annexesService.GetAnnexesFile(dwgPublishObj.FolderId);
            msg = await _annexesService.DownloadFile(filePath, dwgfileDto.F_Id);
            if (!string.IsNullOrEmpty(msg))
            { MessageBox.Show("图纸文件下载失败，信息:" + msg); return; }
            msg =  General.OpenDwg(filePath, true);//以只读模式打开图纸  
            if (!string.IsNullOrEmpty(msg))
            {
                MessageBox.Show($"本地图纸文件:{model.Text} 打开失败，信息:{msg}");
                return;
            }
            //设置图纸选中元素回调
            InitDrawingSelectedAdd(model, true);
            #endregion
        }
        #endregion

        #region 刷新历史版次图纸树
        /// <summary>
        /// 刷新历史版次图纸树
        /// </summary>
        /// <param name="model">图纸</param>
        private void onRefreshHistoryDwg(Model.TreeModel model)
        {
            InitHistoryDrawings();
        }
        #endregion

        #region 双击图元，把图元加入到图纸上
        /// <summary>
        /// 双击图元，把图元加入到图纸上 ec_library_file
        /// </summary>
        /// <param name="tag">图元</param>
        private void onTagDoubleClick(object tag)
        {
            if (tag == null)
            {
                return;
            }
            var dwgLibrary = tag as ec_library_file;
            if (dwgLibrary == null)
            {
                return;
            }
            else
            {
                //在SWS系统内打开且不是只读的图纸才可添加图元
                var name = General.GetDwgName();
                var dwgFile = GlobalObject.ListDwgOpened.FirstOrDefault(a => a.Path == name && a.IsReadOnly == false);
                if (dwgFile == null)
                { return; }

                IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
                x.Add(GlobalObject.dialogPar.info.ToString(), ListTagNumber);
                x.Add(GlobalObject.dialogPar.id.ToString(), selectType.ID);
                var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
                _dialogService.ShowDialog(nameof(DialogTagSelect), x, async (RES) =>
                {
                    if (RES.Result == ButtonResult.Yes)
                    {
                        string tagNum = string.Empty;
                        var tagNumber = RES.Parameters.GetValue<string>(GlobalObject.dialogPar.info.ToString());
                        var dgwFilePath = Path.Combine(GlobalObject.GetDwgFileFolder(dwgFile.Id), dwgLibrary.LibraryFileName + ".dwg");
                        var objId = General.InsertExternalDWG(dgwFilePath, tagNumber, ref tagNum);
                        #region 图纸上保存图元属性 
                        if (!objId.IsNull)
                        {
                            List<ec_enginedata_property> listPro = new List<ec_enginedata_property>();
                            var handlid = objId.Handle.ToString();//添加图元返回的句柄
                            ec_enginedata item = new ec_enginedata();
                            item.TagNumber = tagNum;
                            item.ObjectTypeID = selectType.ID;
                            item.Layout_Block_File = dwgLibrary;
                            var res = await objectTypeService.GetObjectTypePById(selectType.ID);//添加属性
                            if (res.Any())
                            {
                                foreach (var dto in res)
                                {
                                    listPro.Add(new ec_enginedata_property()
                                    {
                                        EngineDataPropertyID = dto.PropertyID,
                                        PropertyName = dto.PropertyName,
                                        PropertyNameEN = dto.PropertyNameEN,
                                        PropertyValue = dto.DefaultValue,
                                        MeasuringUnit = dto.MeasuringUnitTypeName,
                                        PropertyGID = dto.PropertyGID,
                                        PropertyGroupName = dto.PropertyGroupName
                                    });
                                }
                            }
                            item.EngineDataProperty = listPro;
                            List<ec_enginedata_pixel> listPixel = new List<ec_enginedata_pixel>();
                            var pixelDto = new ec_enginedata_pixel()
                            {
                                TagNumber = tagNum,
                                DrawingFileID = dwgFile.Id,
                                LibraryFileID = dwgLibrary.LibraryFileID,
                                PixelCode = handlid,
                                ObjectTypeID = selectType.ID,
                                ObjectTypeName = selectType.Text,
                                EngineDataProperty = listPro
                            };
                            listPixel.Add(pixelDto);
                            item.EngineDataPixel = listPixel;
                            string msg = string.Empty;
                            msg = await objectTypeService.UpdatePixelAndProp(item);
                            if (msg != string.Empty)
                            {
                                MessageBox.Show("保存图元属性至图纸异常：" + msg);
                            }
                        }
                        #endregion
                        AddRecentObjectType();
                    }
                    else if (RES.Result == ButtonResult.No)
                    { }
                });
                return;
            }
        }
        /// <summary>
        /// 把设计元件当前节点， 添加到最近使用
        /// </summary>
        private void AddRecentObjectType()
        {
            if (selectType == null)
            { return; }
            string ids = string.Empty;
            var strRecentObjectType = _configService.Read("Project" + GlobalObject.curProject.ProjectId, nameof(ConfigIni.RecentObjectType));
            if (string.IsNullOrEmpty(strRecentObjectType))
            {
                //获取节点 
                Model.TreeModel node = TreeHelper.GetTreeModel(GlobalObject.objectTypeTree, selectType.ID);
                var addNode = (Model.TreeModel)node.Clone();
                var firstNode = objectTypeTree[0];
                //UI添加到最近使用
                firstNode.ChildNodes.Insert(0, addNode);
                ids = selectType.ID;
            }
            else if (strRecentObjectType.Contains(selectType.ID))
            { return; }
            else
            {
                var firstNode = objectTypeTree[0];
                var listObjectTypeId = strRecentObjectType.Split(',').ToList();
                if (listObjectTypeId.Count >= 5)
                {
                    //删除最后一个
                    listObjectTypeId.Remove(listObjectTypeId.Last());
                    firstNode.ChildNodes.Remove(firstNode.ChildNodes.Last());
                }
                listObjectTypeId.Insert(0, selectType.ID);
                //获取节点
                Model.TreeModel node = TreeHelper.GetTreeModel(GlobalObject.objectTypeTree, selectType.ID);
                var addNode = (Model.TreeModel)node.Clone();
                firstNode.ChildNodes.Insert(0, addNode);//UI添加到最近使用
                ids = string.Join(",", listObjectTypeId);
            }
            //保存最近使用id到本地文件里
            _configService.Save("Project" + GlobalObject.curProject.ProjectId, nameof(ConfigIni.RecentObjectType), ids);
        }
        #endregion

        #region 编辑目录属性
        /// <summary>
        /// 编辑目录属性
        /// </summary>
        /// <param name="model">图纸</param>
        private void onEditDrawingCatalogue(Model.TreeModel model)
        {
            var oldName = model.Text;
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.id.ToString(), model.ID);
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogDrawingCatalogue), x, (RES) =>
            {
                if (RES.Result == ButtonResult.Yes)
                {
                    var newName = RES.Parameters.GetValue<string>(GlobalObject.dialogPar.info.ToString());
                    if (!newName.Equals(oldName))
                    {
                        model.Text = newName;
                    }
                }
                else if (RES.Result == ButtonResult.No)
                { }
            });
        }
        #endregion

        #region 元件关联图元
        /// <summary>
        /// 元件关联图元
        /// </summary>
        /// <param name="model">图纸</param>
        private void onGuanlian(object obj)
        {
            if (selectedTag == null)
            {
                MessageBox.Show("请先选择元件！");
                return;
            }
            //在SWS系统内打开且不是只读的图纸才可添加图元
            var dwgName = General.GetDwgName();
            var dwgFile = GlobalObject.ListDwgOpened.FirstOrDefault(a => a.Path == dwgName && a.IsReadOnly == false);
            if (dwgFile == null)
            {
                MessageBox.Show("请在系统打开的图纸上操作！");
                return;
            }
            IDialogParameters x = new Prism.Services.Dialogs.DialogParameters();
            x.Add(GlobalObject.dialogPar.info.ToString(), ListTagNumber);
            x.Add(GlobalObject.dialogPar.id.ToString(), selectType.ID);
            var _dialogService = GlobalObject._prismContainer.Resolve<IDialogService>();
            _dialogService.ShowDialog(nameof(DialogTagSelect), x, async (RES) =>
            {
                if (RES.Result == ButtonResult.Yes)
                {
                    General.SendMessage($"请选择需关联【{selectType.Text}】元件的图元");
                    var tagNumber = RES.Parameters.GetValue<string>(GlobalObject.dialogPar.info.ToString());
                    isObjectTypeGuanlian = true;
                    General.SelectHandles.Clear();
                    var listHandles = General.StartObjectTypeSelection();
                    if (!listHandles.Any())
                    {
                        isObjectTypeGuanlian = false;
                        return;
                    }
                    #region 图纸上保存图元属性 
                    List<ec_enginedata> listEnginedata = new List<ec_enginedata>();
                    foreach (var handlid in listHandles)
                    {
                        List<ec_enginedata_property> listPro = new List<ec_enginedata_property>();
                        ec_enginedata item = new ec_enginedata();
                        item.TagNumber = tagNumber;
                        item.ObjectTypeID = selectType.ID;
                        var res = await objectTypeService.GetObjectTypePById(selectType.ID);//添加属性
                        if (res.Any())
                        {
                            foreach (var dto in res)
                            {
                                listPro.Add(new ec_enginedata_property()
                                {
                                    EngineDataPropertyID = dto.PropertyID,
                                    PropertyName = dto.PropertyName,
                                    PropertyNameEN = dto.PropertyNameEN,
                                    PropertyValue = dto.DefaultValue,
                                    MeasuringUnit = dto.MeasuringUnitTypeName,
                                    PropertyGID = dto.PropertyGID,
                                    PropertyGroupName = dto.PropertyGroupName
                                });
                            }
                        }
                        item.EngineDataProperty = listPro;
                        List<ec_enginedata_pixel> listPixel = new List<ec_enginedata_pixel>();
                        var pixelDto = new ec_enginedata_pixel()
                        {
                            TagNumber = tagNumber,
                            DrawingFileID = dwgFile.Id,
                            PixelCode = handlid,
                            ObjectTypeID = selectType.ID,
                            ObjectTypeName = selectType.Text,
                            EngineDataProperty = listPro
                        };
                        listPixel.Add(pixelDto);
                        item.EngineDataPixel = listPixel;
                        listEnginedata.Add(item);
                    }
                    var msg = await objectTypeService.UpdatePixelAndPropBatch(listEnginedata);
                    if (msg != string.Empty)
                    {
                        MessageBox.Show("保存图元属性至图纸异常：" + msg);
                    }
                    else
                    {
                        General.SetXdata(listHandles, tagNumber);//对空XData进行设置XData
                        General.SendMessage($"图元：{string.Join(",", listHandles)},成功转【{selectType.Text}】对象");
                    }
                    isObjectTypeGuanlian = false;
                    #endregion 
                }
                else if (RES.Result == ButtonResult.No)
                { }
            });

        }
        #endregion

        #region 位号关联通道
        private void ChangeIORelation(bool flag)
        {
            isIOassociationChannel = flag;
        }
        #endregion

    }
}