RevitArchive/RevitKits/ParameterManager/MetroCategoryParamsViewModel.cs

using System.Collections.Generic;
using System.Linq;
using Autodesk.Revit.UI;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using Sai.Database.Shared;
using SZBIM.StandardTools;
using SZBIM.StandardTools.ParameterManager;

namespace Sai.Common.Shared.ParameterManager
{
    public partial class MetroCategoryParamsViewModel : ObservableObject
    {
        public MetroCategoryParamsViewModel(MetroParamsManagerWin parentWindow)
        {
            ParentWindow = parentWindow;
            dapperUtil = parentWindow.DapperUtil;
            var dedicatedParams = GetMetroDedicatedProperties();
            commonParams = GetMetroCommonProperties();
            SharedParams = GetMetroSharedParams();
            GenerateMetroDedicatedPropTree(dedicatedParams);
            CanAdd = paramsToAdd.Count > 0;
        }

        private readonly List<ParamModel> commonParams;
        private readonly DapperUtil dapperUtil;
        private readonly List<ParamModel> paramsToAdd = new();

        [ObservableProperty] private bool canAdd;

        [ObservableProperty] private bool? isAddCommonParam = true;

        [ObservableProperty] private bool isFamilyParam;

        [ObservableProperty] private bool isSharedFamilyParam;

        [ObservableProperty] private bool isSharedProjectProjectParam = true;

        public List<SharedParamModel> SharedParams { get; set; }

        public List<TreeModel> Models { get; } = new();
        public MetroParamsManagerWin ParentWindow { get; set; }

        [RelayCommand(CanExecute = nameof(IsProjectDocument))]
        private void AddParameters(object obj)
        {
            ExternalEventRequest x = ExternalEventRequest.Denied;
            //KeyHelpers.SetfocusRVT();
            //KeyHelpers.keybd_event(0x1B, 0, 0, 0);
            //KeyHelpers.keybd_event(0x1B, 0, 2, 0);
            if (paramsToAdd.Any())
            {
                ParentWindow.AddProjectInfoParameterEventHandler.IsSharedProjectParam = IsSharedProjectProjectParam;
                ParentWindow.AddProjectInfoParameterEventHandler.IsFamilyParam = IsFamilyParam;
                ParentWindow.AddProjectInfoParameterEventHandler.IsSharedFamilyParam = IsSharedFamilyParam;
                ParentWindow.AddProjectInfoParameterEventHandler.ParameterList = paramsToAdd;
                ParentWindow.AddProjectInfoParameterEventHandler.SharedParameters = SharedParams;
                x = ParentWindow.AddParameterEvent.Raise();
            }

            CanAdd = x != ExternalEventRequest.Accepted;
        }

        [RelayCommand]
        private void CheckedAll(object obj)
        {
            if (obj is List<ParamModel>)
            {
                var paramters = obj as List<ParamModel>;
                foreach (var param in paramters)
                {
                    param.IsChecked = true;
                }
            }
        }

        private void GenerateMetroDedicatedPropTree(IList<ParamModel> paramsData)
        {
            var projects = paramsData.GroupBy(param => param.Project);
            foreach (var project in projects)
            {
                //项目
                List<TreeModel> projectChildren = new List<TreeModel>();
                TreeModel projectTreeModel = new TreeModel
                {
                    Name = project.Key,
                    Icon = null,
                    IsChecked = false,
                    IsExpanded = true,
                    Parent = null,
                    Children = projectChildren,
                    Tag = null
                };
                Models.Add(projectTreeModel);
                //专业
                var majors = project.GroupBy(p => p.Major);
                foreach (var major in majors)
                {
                    List<TreeModel> majorChildren = new List<TreeModel>();
                    TreeModel majorTreeModel = new TreeModel
                    {
                        Name = major.Key,
                        Icon = null,
                        IsChecked = false,
                        IsExpanded = false,
                        Children = majorChildren,
                        Tag = null
                    };
                    projectChildren.Add(majorTreeModel);
                    //构件
                    var components = major.GroupBy(p => p.Component);
                    foreach (IGrouping<string, ParamModel> component in components)
                    {
                        TreeModel componentTreeModel = new TreeModel
                        {
                            Id = null,
                            Name = component.Key,
                            Icon = null,
                            IsExpanded = false,
                            Parent = null,
                            Children = null,
                            Tag = component.ToList()
                        };
                        majorChildren.Add(componentTreeModel);

                        //属性分类
                        //var propertyCategories = component.GroupBy(p => p.PropertyCategory);
                        //foreach (var category in propertyCategories)
                        //{
                        //    ErrorModels<TreeModel> categoryChildren = new ErrorModels<TreeModel>();
                        //    TreeModel categoryTreeModel = new TreeModel
                        //    {
                        //        ViewId = null,
                        //        Name = category.Key,
                        //        Icon = null,
                        //        IsChecked = false,
                        //        IsExpanded = false,
                        //        Parent = null,
                        //        Children = categoryChildren,
                        //        Tag = category
                        //    };

                        //    componentChildren.Add(categoryTreeModel);
                        //    //属性分组
                        //    var groups = category.GroupBy(p => p.PropertyGroup);
                        //    foreach (var group in groups)
                        //    {
                        //        ErrorModels<TreeModel> groupChildren = new ErrorModels<TreeModel>();
                        //        TreeModel groupTreeModel = new TreeModel
                        //        {
                        //            ViewId = null,
                        //            Name = group.Key,
                        //            Icon = null,
                        //            IsChecked = false,
                        //            IsExpanded = false,
                        //            Parent = null,
                        //            Children = groupChildren,
                        //            Tag = group
                        //        };
                        //        categoryChildren.Add(groupTreeModel);
                        //        //属性
                        //        var properties = group.GroupBy(p => p.FullProperty);
                        //        foreach (var property in properties)
                        //        {
                        //            TreeModel propertyTreeModel = new TreeModel
                        //            {
                        //                ViewId = null,
                        //                Name = property.Key,
                        //                Icon = null,
                        //                IsChecked = false,
                        //                IsExpanded = false,
                        //                Parent = null,
                        //                Tag = property
                        //            };
                        //            groupChildren.Add(propertyTreeModel);
                        //        }
                        //    }
                        //}
                    }
                }
            }
        }


        /// <summary>
        ///     轨交通用属性
        /// </summary>
        private List<ParamModel> GetMetroCommonProperties()
        {
            return dapperUtil.LoadModel<ParamModel>("METRO_COMMON_PROPERTIES");
        }

        /// <summary>
        ///     轨交专项属性
        /// </summary>
        private List<ParamModel> GetMetroDedicatedProperties()
        {
            return dapperUtil.LoadModel<ParamModel>("METRO_DEDICATED_PROPERTIES");
        }

        /// <summary>
        ///     轨交共享参数
        /// </summary>
        private List<SharedParamModel> GetMetroSharedParams()
        {
            return dapperUtil.LoadModel<SharedParamModel>("METRO_SHARED_PARAMS");
        }

        private bool IsProjectDocument()
        {
            var uidoc = ParentWindow.UiApplication.ActiveUIDocument;
            var doc = uidoc.Document;
            return !doc.IsFamilyDocument;
        }

        [RelayCommand]
        private void TreeItemChanged(object obj)
        {
            if (obj is List<ParamModel>)
            {
                var paramters = obj as List<ParamModel>;
                paramsToAdd.Clear();
                if (paramters.Count > 0)
                {
                    if (IsAddCommonParam == true)
                    {
                        paramsToAdd.AddRange(commonParams);
                    }

                    paramsToAdd.AddRange(paramters.Where(param => param.IsChecked == true));
                }
            }

            CanAdd = paramsToAdd.Count > 0;
        }

        [RelayCommand]
        private void UnCheckedAll(object obj)
        {
            if (obj is List<ParamModel>)
            {
                var paramters = obj as List<ParamModel>;
                foreach (var param in paramters)
                {
                    param.IsChecked = false;
                }
            }
        }
    }
}