AIPlatform_6787/aipdev/FolderManagement.xaml.cs

using aipdev.Annotations;
using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.Utilities;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;

namespace aipdev
{
    public class FolderItem : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Gets the item id.
        /// </summary>
        public long Id { get; set; }

        /// <summary>
        /// Gets the item name.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Gets the item description.
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// Gets if the item is updated.
        /// </summary>
        public bool IsUpdated { get; set; }

        /// <summary>
        /// Gets if the item has menu.
        /// </summary>
        public bool HasMenu { get; set; }

        /// <summary>
        /// Gets or sets the organization id.
        /// </summary>
        public long OrganizationId { get; set; }

        /// <summary>
        /// Gets the image category id.
        /// </summary>
        public long ImageCategoryId { get; set; }

        /// <summary>
        /// Gets the children items.
        /// </summary>
        public ObservableCollection<FolderItem> Children { get; set; }


        public FolderItem()
        {
            Children = new ObservableCollection<FolderItem>();
        }

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public class ImageFolderExtend : FolderItem
    {
        /// <summary>
        /// Gets or sets the image category level
        /// </summary>
        public CategoryLevel Level { get; set; }

        /// <summary>
        /// Gets or sets the image available count.
        /// </summary>
        public int ImageCount { get; set; }

        /// <summary>
        /// Gets or sets the image category is enabled
        /// </summary>
        public bool IsEnabled { get; set; }
    }

    public class DeveloperFolderExtend : DeveloperFolder
    {
        /// <summary>
        /// Gets or sets the value the developer image foler is shared to developers or not.
        /// </summary>
        public bool IsShared { get; set; }
    }

    public enum FolderType
    {
        All,
        Server,
        Developer,
    }

    /// <summary>
    /// Interaction logic for FolderManagement.xaml
    /// </summary>
    public partial class FolderManagement : UserControl, IContentPage
    {
        private readonly ObservableCollection<ImageFolderExtend> _serverFolders = new ObservableCollection<ImageFolderExtend>();

        private readonly ObservableCollection<DeveloperFolderExtend> _developerFolders = new ObservableCollection<DeveloperFolderExtend>();

        public string PageName { get; set; }

        public bool IsHomePage { get; set; }

        public bool IsModalPage { get; set; }

        public List<ImageCategory> _imageCategories { get; set; }

        public List<ImageCategory> _imageBatches { get; set; }

        public FolderManagement()
        {
            InitializeComponent();
            PageName = "FolderManagement";
            IsHomePage = false;
            IsModalPage = false;
            ServerFolders.ItemsSource = _serverFolders;
            DevFolders.ItemsSource = _developerFolders;
        }

        public async void OnShow(object arg)
        {
            await LoadFoldersAsync(FolderType.All).ConfigureAwait(false);
        }

        public void OnHide()
        {
            ClearFolders();
        }

        public void Close()
        {
            ClearFolders();
        }

        private void ClearFolders()
        {
            _serverFolders.Clear();
            _developerFolders.Clear();
        }

        private async Task LoadFoldersAsync(FolderType type)
        {
            try
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.ShowLoading();
                });
                switch (type)
                {
                    case FolderType.All:
                        await LoadServerFoldersAsync().ConfigureAwait(false);
                        await LoadDeveloperFoldersAsync().ConfigureAwait(false);
                        break;
                    case FolderType.Server:
                        await LoadServerFoldersAsync().ConfigureAwait(false);
                        break;
                    case FolderType.Developer:
                        await LoadDeveloperFoldersAsync().ConfigureAwait(false);
                        break;
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    MessageBox.Show(Application.Current.MainWindow, $"加载文件夹列表失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                });
            }
            finally
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.HideLoading();
                });
            }
        }

        private async Task LoadServerFoldersAsync()
        {
            _imageCategories = new List<ImageCategory>();

            #region Organizations
            Dispatcher.Invoke(() =>
            {
                _serverFolders.Clear();
            });
            var organizations = await DeveloperManager.Shared.GetOrganizationsAsync().ConfigureAwait(false);
            if (organizations != null)
            {
                foreach (var org in organizations)
                {
                    var orgExtend = new ImageFolderExtend
                    {
                        Id = org.Id,
                        Name = org.Name,
                        Description = org.Name,
                        Level = CategoryLevel.Organization,
                        HasMenu = false,
                    };
                    #region ImageCategories
                    var categories = await DeveloperManager.Shared.GetImageCategoriesAsync(org.Id).ConfigureAwait(false);
                    if (categories != null)
                    {
                        foreach (var categ in categories)
                        {
                            if (categ.Developers.Any(x => x.Id == DeveloperManager.Shared.Session.AccountId))
                            {
                                var quantity = categ.ImageQuantityItem;
                                var desc = $"{categ.Name} - 已标注：{quantity.Labeled}，已跳过：{quantity.Skipped}，未标注：{quantity.UnLabeled}，未分配：{quantity.UnAssigned}";
                                var categExtend = new ImageFolderExtend
                                {
                                    Id = categ.Id,
                                    Name = categ.Name,
                                    Description = desc,
                                    Level = categ.Level,
                                    ImageCount = quantity.Seen,
                                    HasMenu = true,
                                    OrganizationId = org.Id,
                                    ImageCategoryId = categ.Id,
                                    IsEnabled = quantity.Seen > 0,
                                };
                                await AddItemChildAsync(categExtend, categ, categ.Id).ConfigureAwait(false);
                                orgExtend.Children.Add(categExtend);
                                _imageCategories.Add(categ);
                            }
                        }
                    }
                    #endregion
                    Dispatcher.Invoke(() =>
                    {
                        _serverFolders.Add(orgExtend);
                    });
                }
            }
            #endregion
        }

        private async Task AddItemChildAsync(ImageFolderExtend folderExtend, ImageCategory category, long imageCategoryId)
        {
            var categories = await DeveloperManager.Shared.GetImageCategoriesAsync(category.Id).ConfigureAwait(false);
            if (categories != null)
            {
                foreach (var item in categories)
                {
                    var quantity = item.ImageQuantityItem;
                    var desc = $"{item.Name} - 已标注：{quantity.Labeled}，已跳过：{quantity.Skipped}，未标注：{quantity.UnLabeled}";
                    if (item.Level == CategoryLevel.Batch)
                    {
                        desc += $"，未分配：{quantity.UnAssigned}";
                    }
                    var caseExtend = new ImageFolderExtend
                    {
                        Id = item.Id,
                        Name = item.Name,
                        Description = desc,
                        Level = item.Level,
                        ImageCount = quantity.Seen,
                        HasMenu = true,
                        OrganizationId = item.OrganizationId,
                        ImageCategoryId = imageCategoryId,
                        IsEnabled = quantity.Seen > 0,
                    };
                    await AddItemChildAsync(caseExtend, item, imageCategoryId).ConfigureAwait(false);
                    folderExtend.Children.Add(caseExtend);
                }
            }
        }

        private async Task LoadDeveloperFoldersAsync()
        {
            Dispatcher.Invoke(() =>
            {
                _developerFolders.Clear();
            });
            var developerFolders = await DeveloperManager.Shared.GetDeveloperFoldersAsync(0, 1000, true).ConfigureAwait(false);
            foreach (var developerFolder in developerFolders)
            {
                var item = new DeveloperFolderExtend
                {
                    Id = developerFolder.Id,
                    Name = developerFolder.Name,
                    Description = developerFolder.Description,
                    DeveloperId = developerFolder.DeveloperId,
                    ImageCategoryId = developerFolder.ImageCategoryId,
                    ImageCount = developerFolder.ImageCount,
                    ApprovalState = developerFolder.ApprovalState,
                    Sharers = developerFolder.Sharers,
                    Approver = developerFolder.Approver,
                    IsShared = developerFolder.ApprovalState == ApprovalState.Approved,
                    CreateTime = developerFolder.CreateTime,
                    UpdateTime = developerFolder.UpdateTime,
                };
                Dispatcher.Invoke(() =>
                {
                    _developerFolders.Add(item);
                });
            }
        }

        private void OnFolderClick(object sender, RoutedEventArgs e)
        {
            if (e.OriginalSource is CheckBox)
            {
                return;
            }
            var button = (Button)sender;
            var folder = (ImageFolder)button.DataContext;
            ContentManager.Show("FolderImageBrowser", folder);
        }

        private async void OnRefreshServerFoldersClick(object sender, RoutedEventArgs e)
        {
            await LoadFoldersAsync(FolderType.Server).ConfigureAwait(false);
        }

        private void OnOpenFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (ImageFolderExtend)menuItem.DataContext;
            ContentManager.Show("FolderImageBrowser", folder);
        }

        private async void OnCopyFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (ImageFolderExtend)menuItem.DataContext;
            try
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.ShowLoading();
                });
                var developerFolder = await DeveloperManager.Shared.CreateDeveloperFolderAsync(folder.Name + $"_{DateTime.Now:yyyyMMddHHmmss}", string.Empty, folder.OrganizationId, folder.ImageCategoryId);
                var operationId = IdCreator.CreateId();

                _ = Task.Run(async () =>
                {
                    await DeveloperManager.Shared.CopyFolderAsync(folder.Id, developerFolder.Id, operationId);
                });
                var progress = 0;
                while (progress < 100)
                {
                    try
                    {
                        progress = await DeveloperManager.Shared.GetOperationProgressAsync(operationId);
                    }
                    catch (Exception)
                    {
                        //
                    }
                    await Task.Delay(200);
                }

                developerFolder = await DeveloperManager.Shared.GetDeveloperFolderAsync(developerFolder.Id);
                await UpdateDeveloperFoldersAsync(developerFolder);
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    MessageBox.Show(Application.Current.MainWindow, $"复制文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                });
                await LoadDeveloperFoldersAsync();
            }
            finally
            {
                Dispatcher.Invoke(() =>
                {
                    ContentManager.HideLoading();
                });
            }
        }

        private Task UpdateDeveloperFoldersAsync(DeveloperFolder folder)
        {
            var devFolder = _developerFolders.FirstOrDefault(x => x.Id == folder.Id);
            if (devFolder == null)
            {
                devFolder = new DeveloperFolderExtend
                {
                    Id = folder.Id,
                    Name = folder.Name,
                    Description = folder.Description,
                    DeveloperId = folder.DeveloperId,
                    ImageCategoryId = folder.ImageCategoryId,
                    ImageCount = folder.ImageCount,
                    ApprovalState = folder.ApprovalState,
                    Sharers = folder.Sharers,
                    Approver = folder.Approver,
                    IsShared = folder.ApprovalState == ApprovalState.Approved,
                    CreateTime = folder.CreateTime,
                    UpdateTime = folder.UpdateTime,
                };
                Dispatcher.Invoke(() =>
                {
                    _developerFolders.Insert(0, devFolder);
                });
            }
            else
            {
                var index = _developerFolders.IndexOf(devFolder);
                Dispatcher.Invoke(() =>
                {
                    _developerFolders.Remove(devFolder);
                });
                devFolder.ImageCount = folder.ImageCount;
                Dispatcher.Invoke(() =>
                {
                    _developerFolders.Insert(index, devFolder);
                });
            }

            return Task.CompletedTask;
        }

        private async void OnCopyFolderFilesClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (ImageFolderExtend)menuItem.DataContext;
            var copyImageWindow = new CopyImageWindow(folder.ImageCategoryId) { Owner = Application.Current.MainWindow };
            copyImageWindow.ShowDialog();
            if (copyImageWindow.SelectedFolder != null)
            {
                var devFolder = copyImageWindow.SelectedFolder;
                try
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    var operationId = IdCreator.CreateId();

                    _ = Task.Run(async () =>
                    {
                        await DeveloperManager.Shared.CopyFolderFilesAsync(folder.Id, devFolder.Id, operationId);
                    });
                    var progress = 0;
                    while (progress < 100)
                    {
                        try
                        {
                            progress = await DeveloperManager.Shared.GetOperationProgressAsync(operationId);
                        }
                        catch (Exception)
                        {
                            //
                        }
                        await Task.Delay(200);
                    }
                    var developerFolder = await DeveloperManager.Shared.GetDeveloperFolderAsync(devFolder.Id);
                    await UpdateDeveloperFoldersAsync(developerFolder);
                }
                catch (Exception ex)
                {
                    Dispatcher.Invoke(() =>
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"复制文件夹图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    });
                    await LoadDeveloperFoldersAsync();
                }
                finally
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.HideLoading();
                    });
                }
            }
        }

        private async void OnSyncFolderFilesClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (ImageFolderExtend)menuItem.DataContext;
            var copyImageWindow = new CopyImageWindow(folder.ImageCategoryId) { Owner = Application.Current.MainWindow };
            copyImageWindow.ShowDialog();
            if (copyImageWindow.SelectedFolder != null)
            {
                var devFolder = copyImageWindow.SelectedFolder;
                try
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    var operationId = IdCreator.CreateId();

                    _ = Task.Run(async () =>
                    {
                        await DeveloperManager.Shared.SyncFolderAsync(folder.Id, devFolder.Id, operationId);
                    });
                    var progress = 0;
                    while (progress < 100)
                    {
                        try
                        {
                            progress = await DeveloperManager.Shared.GetOperationProgressAsync(operationId);
                        }
                        catch (Exception)
                        {
                            //
                        }
                        await Task.Delay(200);
                    }
                    var developerFolder = await DeveloperManager.Shared.GetDeveloperFolderAsync(devFolder.Id);
                    await UpdateDeveloperFoldersAsync(developerFolder);
                }
                catch (Exception ex)
                {
                    Dispatcher.Invoke(() =>
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"同步文件夹图片失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    });
                    await LoadDeveloperFoldersAsync();
                }
                finally
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.HideLoading();
                    });
                }
            }
        }

        private void OnOpenDeveloperFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (ImageFolder)menuItem.DataContext;
            ContentManager.Show("FolderImageBrowser", folder);
        }

        private async void OnRefreshDeveloperFoldersClick(object sender, RoutedEventArgs e)
        {
            await LoadFoldersAsync(FolderType.Developer).ConfigureAwait(false);
        }

        private async void OnCreateDeveloperFolderClick(object sender, RoutedEventArgs e)
        {
            var createFolderWindow = new CreateFolderWindow(_imageCategories) { Owner = Application.Current.MainWindow };
            createFolderWindow.ShowDialog();
            if (!string.IsNullOrEmpty(createFolderWindow.NewFolderName))
            {
                var folderName = createFolderWindow.NewFolderName;
                var folderDesc = createFolderWindow.NewFolderDescription;
                var folderImageCategoryId = createFolderWindow.NewFolderImageCategoryId;
                var folderOrganizationId = createFolderWindow.NewFolderOrganizationId;
                ContentManager.ShowLoading();
                try
                {
                    var createdFolder = await DeveloperManager.Shared.CreateDeveloperFolderAsync(folderName, folderDesc, folderOrganizationId, folderImageCategoryId);
                    await UpdateDeveloperFoldersAsync(createdFolder);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"创建文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    await LoadDeveloperFoldersAsync();
                }
                finally
                {
                    ContentManager.HideLoading();
                }
            }
        }

        private async void OnCreateTestFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (DeveloperFolder)menuItem.DataContext;
            var createTestFolderWindow = new CreateTestFolderWindow(folder) { Owner = Application.Current.MainWindow };
            createTestFolderWindow.ShowDialog();
            if (!string.IsNullOrEmpty(createTestFolderWindow.NewFolderName))
            {
                try
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    var testFolderName = createTestFolderWindow.NewFolderName;
                    var testFolderDesc = createTestFolderWindow.NewFolderDescription;
                    var assignTestImageCount = int.Parse(createTestFolderWindow.AssignTestImageCount.Text?.Trim() ?? "0");

                    //创建测试文件夹
                    var developerTestFolder = await DeveloperManager.Shared.CreateDeveloperFolderAsync(testFolderName, testFolderDesc, folder.OrganizationId, folder.ImageCategoryId);
                    //开发人员文件夹，选定随机数量的图像，分配到新的测试文件夹
                    var operationId = IdCreator.CreateId();

                    _ = Task.Run(async () =>
                    {
                        await DeveloperManager.Shared.AssignDeveloperFolderAsync(folder.Id, developerTestFolder.Id, assignTestImageCount, operationId);
                    });
                    var progress = 0;
                    while (progress < 100)
                    {
                        try
                        {
                            progress = await DeveloperManager.Shared.GetOperationProgressAsync(operationId);
                        }
                        catch (Exception)
                        {
                            //
                        }
                        await Task.Delay(200);
                    }
                }
                catch (Exception ex)
                {
                    Logger.WriteLineError($"创建测试文件夹失败:{ex}");
                    Dispatcher.Invoke(() =>
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"创建测试文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    });
                }
                finally
                {
                    await LoadDeveloperFoldersAsync();
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.HideLoading();
                    });
                }
            }
        }

        private async void OnDeleteDeveloperFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (DeveloperFolderExtend)menuItem.DataContext;
            var result = MessageBox.Show(Application.Current.MainWindow, "是否删除整个文件夹?", "删除文件夹", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result == MessageBoxResult.Yes)
            {
                try
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.ShowLoading();
                    });
                    var operationId = IdCreator.CreateId();

                    _ = Task.Run(async () =>
                    {
                        await DeveloperManager.Shared.DeleteDeveloperFolderAsync(folder.Id, operationId);
                    });
                    var progress = 0;
                    while (progress < 100)
                    {
                        try
                        {
                            progress = await DeveloperManager.Shared.GetOperationProgressAsync(operationId);
                        }
                        catch (Exception)
                        {
                            //
                        }
                        await Task.Delay(200);
                    }
                    Dispatcher.Invoke(() =>
                    {
                        _developerFolders.Remove(folder);
                    });
                }
                catch (Exception ex)
                {
                    Dispatcher.Invoke(() =>
                    {
                        MessageBox.Show(Application.Current.MainWindow, $"删除文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                    });
                }
                finally
                {
                    Dispatcher.Invoke(() =>
                    {
                        ContentManager.HideLoading();
                    });
                }
            }
        }

        private async void OnEditDeveloperFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (DeveloperFolderExtend)menuItem.DataContext;
            var editFolderWindow = new EditFolderWindow(folder) { Owner = Application.Current.MainWindow };
            editFolderWindow.ShowDialog();
            if (editFolderWindow.FolderUpdated)
            {
                var folderName = editFolderWindow.NewFolderName;
                var folderDesc = editFolderWindow.NewFolderDescription;
                ContentManager.ShowLoading();
                try
                {
                    await DeveloperManager.Shared.UpdateDeveloperFolderAsync(folder.Id, folderName, folderDesc);
                    if (folder.Name != folderName)
                    {
                        await DeveloperManager.Shared.UpdateTrainTaskFolderNameAsync(folder.Id, folderName);
                    }
                    var index = _developerFolders.IndexOf(folder);
                    _developerFolders.Remove(folder);
                    folder.Name = folderName;
                    folder.Description = folderDesc;
                    _developerFolders.Insert(index, folder);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"更新文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    ContentManager.HideLoading();
                }
            }
        }

        private void OnNodeDoubleClickHandler(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {

        }

        private void OnNodeMouseDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            var treeViewItem = (TreeViewItem)sender;
            treeViewItem.IsSelected = true;
            treeViewItem.Focus();
            e.Handled = true;
        }

        private async void OnSharedDeveloperFolderClick(object sender, RoutedEventArgs e)
        {
            var menuItem = (MenuItem)sender;
            var folder = (DeveloperFolderExtend)menuItem.DataContext;
            var folderImageCategory = await DeveloperManager.Shared.GetImageCategoryAsync(folder.ImageCategoryId);
            if (folderImageCategory == null || folderImageCategory.Sharers.Count == 0)
            {
                MessageBox.Show(Application.Current.MainWindow, $"文件夹 {folder?.Name} 没有可选择的共享开发人员，等待管理员维护", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
            var sharedFolderWindow = new SharedFolderWindow(folder.Name, folder.Sharers, folderImageCategory.Sharers) { Owner = Application.Current.MainWindow };
            sharedFolderWindow.ShowDialog();
            if (sharedFolderWindow.FolderUpdated)
            {
                var currSharers = sharedFolderWindow.Sharers;
                ContentManager.ShowLoading();
                try
                {
                    var index = _developerFolders.IndexOf(folder);
                    var state = ApprovalState.PendingApproval;
                    if (currSharers.Count == 0 && folder.Sharers.Count > 0)
                    {
                        state = ApprovalState.Cancel;
                        folder.IsShared = false;
                    }
                    await DeveloperManager.Shared.UpdateSharedDeveloperFolderAsync(folder.Id, state, currSharers);
                    _developerFolders.Remove(folder);
                    folder.Sharers = currSharers;
                    _developerFolders.Insert(index, folder);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"更新文件夹失败:{ex.Translate()}", "错误", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    ContentManager.HideLoading();
                }
            }
        }
    }
}