RevitArchive/RevitKits/ParameterManager/ArchiParamManagerViewModel.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 ArchiParamManagerViewModel : ObservableObject
    {
        public ArchiParamManagerViewModel(DapperUtil dapperUtil)
        {
            this.dapperUtil = dapperUtil;
            addProjectParamsHandler = new AddProjectParamsHandler();
            addProjectParamsEvent = ExternalEvent.Create(addProjectParamsHandler);

            projectFamilyParamsHandler = new AddProjectFileFamilyParamsHandler();
            projectFamilyParamsEvent = ExternalEvent.Create(projectFamilyParamsHandler);
            var archiProperties = GetArchiProperties();
            ArchiSharedParams = GetArchiSharedParams();
            GenerateArchiTree(archiProperties);
        }

        /// <summary>
        ///     项目中的族添加族参数（共享，非共享）
        /// </summary>
        private readonly ExternalEvent addProjectParamsEvent;

        /// <summary>
        ///     添加参数为项目参数绑定类别
        /// </summary>
        private readonly AddProjectParamsHandler addProjectParamsHandler;

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

        /// <summary>
        ///     项目参数（绑定类别的外部事件）
        /// </summary>
        private readonly ExternalEvent projectFamilyParamsEvent;

        /// <summary>
        ///     项目文件的族参数
        /// </summary>
        private readonly AddProjectFileFamilyParamsHandler projectFamilyParamsHandler;

        [ObservableProperty] [NotifyCanExecuteChangedFor(nameof(AddParametersCommand))]
        private bool canAdd;

        [ObservableProperty] private bool isFamilyParam;

        [ObservableProperty] private bool isSharedFamilyParam;

        [ObservableProperty] private bool isSharedProjectParam = true;

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

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

        [RelayCommand(CanExecute = nameof(CanAdd))]
        private void AddParameters(object obj)
        {
            //ExternalEventRequest x = ExternalEventRequest.Denied;
            //x = addProjectParamsEvent.Raise();
            //CanAdd = x != ExternalEventRequest.Accepted;
            //KeyHelpers.SetfocusRVT();
            //KeyHelpers.keybd_event(0x1B, 0, 0, 0);
            //KeyHelpers.keybd_event(0x1B, 0, 2, 0);
            if (!paramsToAdd.Any())
            {
                return;
            }

            if (IsSharedProjectParam)
            {
                addProjectParamsHandler.ParameterList = paramsToAdd;
                addProjectParamsHandler.SharedParameters = ArchiSharedParams;
                addProjectParamsEvent.Raise();
                return;
            }

            projectFamilyParamsHandler.ParameterList = paramsToAdd;
            projectFamilyParamsHandler.SharedParameters = ArchiSharedParams;
            if (IsFamilyParam)
            {
                projectFamilyParamsHandler.IsFamilyParam = true;
                projectFamilyParamsEvent.Raise();
                return;
            }

            if (IsSharedFamilyParam)
            {
                projectFamilyParamsHandler.IsFamilyParam = false;
                projectFamilyParamsEvent.Raise();
            }
        }


        private void GenerateArchiTree(IList<ParamModel> paramsData)
        {
            var majors = paramsData.GroupBy(param => param.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
                };
                Models.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);
                }
            }
        }

        /// <summary>
        ///     建筑属性
        /// </summary>
        private List<ParamModel> GetArchiProperties()
        {
            return dapperUtil.LoadModel<ParamModel>("ARCHI_PROPERTIES");
        }

        /// <summary>
        ///     建筑共享参数
        /// </summary>
        private List<SharedParamModel> GetArchiSharedParams()
        {
            return dapperUtil.LoadModel<SharedParamModel>("ARCHI_SHARED_PARAMS");
        }

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

            CanAdd = paramsToAdd.Any(p => p.IsChecked == true);
        }
    }
}