AIPlatform/aipmgr/Pages/ImageCategories.razor.cs

using aipadmin;
using AIPlatform.Protocol.Entities;
using AIPlatform.Protocol.Utilities;
using aipmgr.Models;
using aipmgr.Shared;
using aipmgr.Utilities;
using BootstrapBlazor.Components;
using System.Diagnostics.CodeAnalysis;
using System.Text.RegularExpressions;

namespace aipmgr.Pages
{
    public sealed partial class ImageCategories
    {
        [NotNull]
        private Table<ImageCategoryModel>? ImageCategoryTable { get; set; }
        private List<int> _pageItemsSource => new() { 20 };
        [NotNull]
        private List<SelectedItem>? users = new List<SelectedItem>();
        [NotNull]
        private List<SelectedItem>? _users
        {
            get => users; set
            {
                users = value;
                StateHasChanged();
            }
        }
        [NotNull]
        private List<Account>? _accounts { get; set; }
        [NotNull]
        private List<string>? _selectedUserValues { get; set; }
        [NotNull]
        private ImageCategoryModel? _currChild { get; set; } = new ImageCategoryModel();
        [NotNull]
        private Modal? _assignUserModal { get; set; }
        [NotNull]
        private Modal? _setGoldStandardModal { get; set; }
        [NotNull]
        private MessageBase? _messageBaseRef { get; set; }
        private AccountType _assignUserType { get; set; }
        private string? _assignUserModalTitle { get; set; }

        [NotNull]
        private List<SelectedItem>? _frameModeItems { get; set; }
        private async Task<ImageCategoryModel> OnAddAsync()
        {
            try
            {
                return new ImageCategoryModel();
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"新建图像分类失败，错误：{ex.Translate()}");
                return new ImageCategoryModel();
            }
        }

        private async Task<bool> OnDeleteAsync(IEnumerable<ImageCategoryModel> items)
        {
            try
            {
                var result = false;
                foreach (var item in items)
                {
                    if (item.Level == CategoryLevel.Organization)
                    {
                        await _messageBaseRef.ShowMessageBaseAsync($"{item.Name} 是组织，不可删除", Color.Warning);
                        continue;
                    }
                    if (item.HasChildren)
                    {
                        await _messageBaseRef.ShowMessageBaseAsync($"{item.Name} 包含子级，不可删除", Color.Warning);
                        continue;
                    }
                    await AdminManager.Shared.DeleteImageCategoryAsync(item.Id);
                    result = true;
                    //await _messageBaseRef.ShowMessageBaseAsync($"{item.Name} 删除成功", Color.Success);
                }
                return await Task.FromResult(result);
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"删除图像分类失败，错误：{ex.Translate()}");
                return await Task.FromResult(false);
            }
        }

        #region 搜索，树型默认展开第一级

        private async Task<QueryData<ImageCategoryModel>> OnQueryAsync(QueryPageOptions options)
        {
            try
            {
                _accounts = await AdminManager.Shared.GetAccountsAsync();
                var items = new List<ImageCategoryModel>();
                var totalCount = 0;
                var keyword = options.SearchText;
                var pageIndex = options.PageIndex - 1;
                var pageSize = options.PageItems;
                if (string.IsNullOrEmpty(keyword))
                {
                    var organizations = await AdminManager.Shared.GetOrganizationsAsync(pageIndex, pageSize, keyword);
                    foreach (var item in organizations)
                    {
                        var vo = MapHelper.Map<ImageCategoryModel, Organization>(item);
                        vo.CreateTime = vo.CreateTime.ToLocalTime();
                        vo.UpdateTime = vo.UpdateTime.ToLocalTime();
                        vo.Level = CategoryLevel.Organization;
                        vo.HasChildren = await AdminManager.Shared.ExistOrganizationChildrenAsync(item.Id);
                        items.Add(vo);
                    }
                    totalCount = await AdminManager.Shared.GetOrganizationCountAsync(keyword);
                }
                else
                {
                    var categories = await AdminManager.Shared.GetImageCategoriesAsync(pageIndex, pageSize, keyword);
                    foreach (var item in categories)
                    {
                        var vo = MapHelper.Map<ImageCategoryModel, ImageCategory>(item);
                        if (vo.VideoItem.IntervalFrame <= 0)
                        {
                            vo.VideoItem.IntervalFrame = 1;
                        }
                        vo.CreateTime = vo.CreateTime.ToLocalTime();
                        vo.UpdateTime = vo.UpdateTime.ToLocalTime();
                        vo.HasChildren = false;
                        items.Add(vo);
                    }
                    totalCount = await AdminManager.Shared.GetImageCategoriesCountAsync(keyword);
                }
                return await Task.FromResult(new QueryData<ImageCategoryModel>()
                {
                    Items = items,
                    TotalCount = totalCount,
                });
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"查询图像分类失败，错误：{ex.Translate()}");
                return new QueryData<ImageCategoryModel>();
            }
        }

        private async Task<IEnumerable<TableTreeNode<ImageCategoryModel>>> TreeNodeConverter(IEnumerable<ImageCategoryModel> items)
        {
            // 构造树状数据结构
            var ret = await BuildTreeNodesAsync(items);
            return await Task.FromResult(ret);
        }

        private async Task<IEnumerable<TableTreeNode<ImageCategoryModel>>> BuildTreeNodesAsync(IEnumerable<ImageCategoryModel> items)
        {
            try
            {
                var ret = new List<TableTreeNode<ImageCategoryModel>>();
                foreach (var item in items)
                {
                    var children = await OnTreeExpand(item);
                    ret.Add(new TableTreeNode<ImageCategoryModel>(item)
                    {
                        // 是否含子数据
                        HasChildren = item.HasChildren,
                        // 如果子项集合有值 则默认展开此节点
                        IsExpand = item.HasChildren,
                        // 获得子项集合
                        Items = children,
                    });
                }
                return ret;
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"获取图像分类失败，错误：{ex.Translate()}");
                return new List<TableTreeNode<ImageCategoryModel>>();
            }
        }

        private async Task<IEnumerable<TableTreeNode<ImageCategoryModel>>> OnTreeExpand(ImageCategoryModel tree)
        {
            try
            {
                var imageCategories = await AdminManager.Shared.GetImageCategoriesByParentIdAsync(tree.Id);
                var children = new List<TableTreeNode<ImageCategoryModel>>();
                foreach (var item in imageCategories)
                {
                    var vo = MapHelper.Map<ImageCategoryModel, ImageCategory>(item);
                    if (vo.VideoItem.IntervalFrame <= 0)
                    {
                        vo.VideoItem.IntervalFrame = 1;
                    }
                    vo.CreateTime = vo.CreateTime.ToLocalTime();
                    vo.UpdateTime = vo.UpdateTime.ToLocalTime();
                    vo.GoldStandardQuantityItem ??= new GoldStandardQuantityItem();
                    vo.SelfCheckQuantityItem ??= new SelfCheckQuantityItem();
                    children.Add(new TableTreeNode<ImageCategoryModel>(vo) { HasChildren = vo.HasChildren });
                }
                return children;
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"获取图像分类失败，错误：{ex.Translate()}");
                return new List<TableTreeNode<ImageCategoryModel>>();
            }
        }

        #endregion 搜索，树型默认展开第一级

        #region 分配标注/开发/共享人员/采集人员

        private async Task OnAssignUserAsync(ImageCategoryModel item, AccountType accountType)
        {
            try
            {
                await LoadingManager.OpenAsync();
                _assignUserType = accountType;
                _currChild = item;
                _users.Clear();
                switch (_assignUserType)
                {
                    case AccountType.Labeler:
                        _assignUserModalTitle = "分配标注人员";
                        foreach (var labeler in _accounts)
                        {
                            if (labeler.Organizations.Any(x => x.Id == item.OrganizationId && labeler.Roles.Contains(Role.Labeler)))
                            {
                                _users.Add(new SelectedItem
                                {
                                    Value = labeler.Id.ToString(),
                                    Text = labeler.Name
                                });
                            }
                        }
                        _selectedUserValues = item.Labelers.Select(x => x.Id.ToString()).ToList();
                        break;
                    case AccountType.Developer:
                        _assignUserModalTitle = "分配开发人员";
                        foreach (var developer in _accounts)
                        {
                            if (developer.Organizations.Any(x => x.Id == item.OrganizationId && developer.Roles.Contains(Role.Developer)))
                            {
                                _users.Add(new SelectedItem
                                {
                                    Value = developer.Id.ToString(),
                                    Text = developer.Name
                                });
                            }
                        }
                        _selectedUserValues = item.Developers.Select(x => x.Id.ToString()).ToList();
                        break;
                    case AccountType.Sharer:
                        _assignUserModalTitle = "分配共享开发人员";
                        foreach (var developer in _accounts)
                        {
                            if (developer.Organizations.Any(x => x.Id == item.OrganizationId && developer.Roles.Contains(Role.Developer)))
                            {
                                _users.Add(new SelectedItem
                                {
                                    Value = developer.Id.ToString(),
                                    Text = developer.Name
                                });
                            }
                        }
                        _selectedUserValues = item.Sharers.Select(x => x.Id.ToString()).ToList();
                        break;

                    case AccountType.Gatherer:
                        _assignUserModalTitle = "分配采集人员";
                        foreach (var gatherer in _accounts)
                        {
                            if (gatherer.Organizations.Any(x => x.Id == item.OrganizationId && gatherer.Roles.Contains(Role.Gatherer)))
                            {
                                _users.Add(new SelectedItem
                                {
                                    Value = gatherer.Id.ToString(),
                                    Text = gatherer.Name
                                });
                            }
                        }
                        _selectedUserValues = item.Gatherers.Select(x => x.Id.ToString()).ToList();
                        break;

                    default:
                        _assignUserModalTitle = "分配人员";
                        break;
                }
                StateHasChanged();
                await _assignUserModal.Show();
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"{_assignUserModalTitle}失败，错误：{ex.Translate()}");
            }
            finally
            {
                await LoadingManager.CloseAsync();
            }
        }

        private async void OnConfirmUserAsync()
        {
            try
            {
                await LoadingManager.OpenAsync();
                var users = new List<EntityBase>();
                foreach (var user in _users)
                {
                    if (_selectedUserValues.Contains(user.Value))
                    {
                        users.Add(new EntityBase { Id = long.Parse(user.Value), Name = user.Text });
                    }
                }
                await AdminManager.Shared.UpdateImageCategoryUsersAsync(_currChild.Id, _assignUserType, users);
                switch (_assignUserType)
                {
                    case AccountType.Labeler:
                        _currChild.Labelers = users;
                        break;
                    case AccountType.Developer:
                        _currChild.Developers = users;
                        break;
                    case AccountType.Sharer:
                        _currChild.Sharers = users;
                        break;
                    case AccountType.Gatherer:
                        _currChild.Gatherers = users;
                        break;
                    default:
                        break;
                }
                await _assignUserModal.Close();
                //await ImageCategoryTable.QueryAsync();
                await InvokeAsync(StateHasChanged);
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"{_assignUserModalTitle}失败，错误：{ex.Translate()}");
            }
            finally
            {
                await LoadingManager.CloseAsync();
            }
        }

        private Task OnCloseUserAsync()
        {
            _assignUserModalTitle = "";
            _currChild = new ImageCategoryModel();
            _selectedUserValues.Clear();
            return Task.CompletedTask;
        }

        #endregion 分配标注/开发/共享人员/采集人员

        #region 设置金标准/自校验/视频标注帧

        private async Task OnSetGoldStandardAsync(ImageCategoryModel item)
        {
            try
            {
                await LoadingManager.OpenAsync();
                _currChild = item;
                StateHasChanged();
                await _setGoldStandardModal.Show();
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"获取金标准设置失败，错误：{ex.Translate()}");
            }
            finally
            {
                await LoadingManager.CloseAsync();
            }
        }

        private async void OnConfirmGoldStandardAsync()
        {
            try
            {
                var similarityThreshold = _currChild.VideoItem.SimilarityThreshold;
                if (similarityThreshold != 0 && similarityThreshold != 1 && !Regex.IsMatch(similarityThreshold.ToString(), @"^\d+(\.\d{1,2})?$"))
                {
                    await _messageBaseRef.ShowMessageBaseAsync($"提交金标准设置失败，相似度阈值取值范围为（0~1），最多可保留2位小数。");
                    return;
                }
                await LoadingManager.OpenAsync();
                await AdminManager.Shared.UpdateImageCategoryGoldStandardAndSelfCheckQuantityItemAsync(_currChild.Id, _currChild.GoldStandardQuantityItem.Proportion, _currChild.GoldStandardQuantityItem.QualifiedPeople, _currChild.SelfCheckQuantityItem.Proportion, _currChild.IsSupportedSkipFrame, _currChild.VideoItem, _currChild.DifficultyLevel);

                await _setGoldStandardModal.Close();
                //await ImageCategoryTable.QueryAsync();
                await InvokeAsync(StateHasChanged);
            }
            catch (Exception ex)
            {
                await _messageBaseRef.ShowMessageBaseAsync($"提交金标准设置失败，错误：{ex.Translate()}");
            }
            finally
            {
                await LoadingManager.CloseAsync();
            }
        }

        private Task OnCloseGoldStandardAsync()
        {
            _currChild = new ImageCategoryModel();
            return Task.CompletedTask;
        }

        #endregion 设置金标准/自校验/视频标注帧
    }
}