王明 / Food-Labeling-Management-Platform

  using System.IO;

  using FoodLabeling.Application.Contracts.Dtos.Common;
  using FoodLabeling.Application.Contracts.Dtos.TeamMember;
  using FoodLabeling.Application.Contracts.IServices;

  using FoodLabeling.Application.Helpers;
  using FoodLabeling.Application.Options;

  using FoodLabeling.Application.Services.DbModels;
  using FoodLabeling.Domain.Entities;

  using Microsoft.AspNetCore.Mvc;
  using Microsoft.Extensions.Options;
  using QuestPDF.Fluent;
  using QuestPDF.Helpers;
  using QuestPDF.Infrastructure;

  using SqlSugar;
  using Volo.Abp;
  using Volo.Abp.Application.Services;
  using Volo.Abp.Domain.Entities;
  using Volo.Abp.Guids;
  using Yi.Framework.Rbac.Domain.Entities;

  using Yi.Framework.Rbac.Domain.Entities.ValueObjects;
  using Yi.Framework.Rbac.Domain.Helpers;

  using Yi.Framework.Rbac.Domain.Managers;
  using Yi.Framework.SqlSugarCore.Abstractions;
  
  namespace FoodLabeling.Application.Services;
  
  /// <summary>

  /// 成员（Team Member）服务，对外仅在 food-labeling-us 暴露

  /// </summary>
  public class TeamMemberAppService : ApplicationService, ITeamMemberAppService
  {
      private readonly ISqlSugarRepository<UserAggregateRoot, Guid> _userRepository;
      private readonly UserManager _userManager;
      private readonly ISqlSugarDbContext _dbContext;
      private readonly IGuidGenerator _guidGenerator;

      private readonly IOptionsSnapshot<FoodLabelingBatchImportOptions> _batchImportOptions;

  
      public TeamMemberAppService(
          ISqlSugarRepository<UserAggregateRoot, Guid> userRepository,
          UserManager userManager,
          ISqlSugarDbContext dbContext,

          IGuidGenerator guidGenerator,
          IOptionsSnapshot<FoodLabelingBatchImportOptions> batchImportOptions)

      {
          _userRepository = userRepository;
          _userManager = userManager;
          _dbContext = dbContext;
          _guidGenerator = guidGenerator;

          _batchImportOptions = batchImportOptions;

      }
  

      /// <inheritdoc />

      public async Task<PagedResultWithPageDto<TeamMemberGetListOutputDto>> GetListAsync(TeamMemberGetListInputVo input)
      {

          var pageIndex = PagedQueryConvention.PageIndexFromSkipCount(input.SkipCount);

          var pageSize = input.MaxResultCount;

          RefAsync<int> total = 0;
  

          var scopeLocationIds = await TeamMemberListScopeHelper.ResolveListLocationIdsAsync(
              CurrentUser,
              _dbContext,
              input.PartnerId,
              input.GroupId,
              input.LocationId);

  
          var query = await BuildFilteredUserQueryAsync(input, scopeLocationIds);

          var users = await query

              .OrderByIF(!string.IsNullOrWhiteSpace(input.Sorting), input.Sorting!)
              .OrderByDescending(u => u.CreationTime)
              .ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
  

          var items = await MapUsersToOutputAsync(
              users,

              scopeLocationIds,
              restrictAssignedLocationsToFilter: scopeLocationIds is not null);

  
          var totalCount = (long)total;
          return new PagedResultWithPageDto<TeamMemberGetListOutputDto>
          {
              PageIndex = pageIndex,
              PageSize = pageSize,
              TotalCount = totalCount,
              TotalPages = (int)Math.Ceiling(totalCount / (double)pageSize),
              Items = items
          };
      }
  

      /// <inheritdoc />

      public async Task<TeamMemberGetOutputDto> GetAsync(Guid id)
      {
          var user = await _userRepository.GetByIdAsync(id);
          if (user is null || user.IsDeleted)
          {
              throw new UserFriendlyException("成员不存在");
          }
  
          var userIdString = id.ToString();
          var links = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
              .Where(x => !x.IsDeleted && x.UserId == userIdString)
              .ToListAsync();
  
          var locationIds = links.Select(x => x.LocationId).Distinct().ToList();
          var locations = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
              .Where(x => !x.IsDeleted)
              .WhereIF(locationIds.Count > 0, x => locationIds.Contains(x.Id.ToString()))
              .Select(x => new { x.Id, x.LocationCode, x.LocationName })
              .ToListAsync();
  
          var assigned = locations.Select(x => new TeamMemberAssignedLocationDto
          {
              Id = x.Id.ToString(),
              LocationCode = x.LocationCode,
              LocationName = x.LocationName
          }).ToList();
  
          var role = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity>().FirstAsync(x => x.UserId == id);
  

          var partnerIds = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(
              _dbContext.SqlSugarClient, locationIds);
          var regionIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
              _dbContext.SqlSugarClient, locationIds);
  

          if (await TeamMemberRoleHelper.IsCompanyAdminRoleAsync(_dbContext.SqlSugarClient, role?.RoleId) &&
              partnerIds.Count > 0)
          {
              (regionIds, assigned) = await ApplyCompanyAdminDisplayScopeAsync(
                  role?.RoleId, partnerIds, regionIds, assigned);
              locationIds = assigned.Select(x => x.Id).ToList();
          }
  

          return new TeamMemberGetOutputDto
          {
              Id = user.Id,
              FullName = user.Name ?? string.Empty,
              UserName = user.UserName,
              Email = user.Email,
              Phone = user.Phone,
              State = user.State,
              RoleId = role?.RoleId,

              PartnerIds = partnerIds,
              RegionIds = regionIds,
              GroupIds = regionIds,

              LocationIds = locationIds,
              AssignedLocations = assigned
          };
      }
  

      /// <inheritdoc />

      public async Task<TeamMemberGetOutputDto> CreateAsync(TeamMemberCreateInputVo input)
      {

          var mergedLocationIds = await ResolveTeamMemberLocationIdsForSaveAsync(input, input.RoleId);

          var user = new UserAggregateRoot

          {

              UserName = input.UserName.Trim(),

              Name = input.FullName.Trim(),

              Nick = input.FullName.Trim(),

              Email = input.Email?.Trim(),

              Phone = input.Phone,
              State = input.State,
              EncryPassword = new EncryPasswordValueObject(input.Password.Trim())

          };
  
          EntityHelper.TrySetId(user, _guidGenerator.Create);
          user.BuildPassword();
  
          await _userManager.CreateAsync(user);
  
          if (input.RoleId != null)
          {
              await _userManager.GiveUserSetRoleAsync(new List<Guid> { user.Id }, new List<Guid> { input.RoleId.Value });
          }
  

          await UpsertUserLocationsAsync(user.Id, mergedLocationIds);

  
          return await GetAsync(user.Id);
      }
  

      /// <inheritdoc />

      public async Task<TeamMemberGetOutputDto> UpdateAsync(Guid id, TeamMemberUpdateInputVo input)
      {

          var mergedLocationIds = await ResolveTeamMemberLocationIdsForSaveAsync(input);

  
          var user = await _userRepository.GetByIdAsync(id);
          if (user is null || user.IsDeleted)
          {
              throw new UserFriendlyException("成员不存在");
          }
  
          user.Name = input.FullName.Trim();
          user.UserName = input.UserName.Trim();
          user.Email = input.Email?.Trim();
          user.Phone = input.Phone;
          user.State = input.State;
  

          var passwordChanged = false;

          if (!string.IsNullOrWhiteSpace(input.Password))
          {

              UserPasswordHelper.ApplyPlainPassword(user, input.Password);
              passwordChanged = true;

          }
  
          await _userRepository.UpdateAsync(user);

          if (passwordChanged)
          {
              await UserPasswordHelper.EnsurePasswordColumnsPersistedAsync(
                  _userRepository,
                  user.Id,
                  user.EncryPassword.Password,
                  user.EncryPassword.Salt);
          }

          if (input.RoleId != null)
          {
              await _userManager.GiveUserSetRoleAsync(new List<Guid> { id }, new List<Guid> { input.RoleId.Value });
          }
          else
          {
              await _userManager.GiveUserSetRoleAsync(new List<Guid> { id }, new List<Guid>());
          }
  

          await UpsertUserLocationsAsync(id, mergedLocationIds);

  
          return await GetAsync(id);
      }
  

      /// <inheritdoc />

      public async Task DeleteAsync(Guid id)
      {
          var user = await _userRepository.GetByIdAsync(id);
          if (user is null || user.IsDeleted)
          {
              return;
          }
  
          user.IsDeleted = true;
          await _userRepository.UpdateAsync(user);
  
          var userIdString = id.ToString();
          var currentUserId = CurrentUser?.Id?.ToString();
          await _dbContext.SqlSugarClient.Updateable<UserLocationDbEntity>()
              .SetColumns(x => new UserLocationDbEntity
              {
                  IsDeleted = true,
                  LastModificationTime = DateTime.Now,
                  LastModifierId = currentUserId
              })
              .Where(x => x.UserId == userIdString && !x.IsDeleted)
              .ExecuteCommandAsync();
      }
  

      /// <inheritdoc />
      public Task<IActionResult> DownloadTeamMemberImportTemplateAsync()
      {
          var opt = _batchImportOptions.Value;

          var fileName = opt.TeamMemberTemplateFileName?.Trim();
          if (string.IsNullOrWhiteSpace(fileName))
          {

              fileName = "Team-Member-批量导入模板.xlsx";

          }
  

          var stream = TeamMemberBatchExcelHelper.BuildImportTemplateWorkbook();

          const string contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
          return Task.FromResult<IActionResult>(new FileStreamResult(stream, contentType)
          {
              FileDownloadName = fileName
          });
      }
  
      /// <inheritdoc />
      public async Task<IActionResult> ExportTeamMembersPdfAsync([FromQuery] TeamMemberGetListInputVo input)
      {
          QuestPDF.Settings.License = LicenseType.Community;
  

          var scopeLocationIds = await TeamMemberListScopeHelper.ResolveListLocationIdsAsync(
              CurrentUser,
              _dbContext,
              input.PartnerId,
              input.GroupId,
              input.LocationId);

  
          var query = await BuildFilteredUserQueryAsync(input, scopeLocationIds);

          var users = await query
              .OrderByIF(!string.IsNullOrWhiteSpace(input.Sorting), input.Sorting!)
              .OrderByDescending(u => u.CreationTime)
              .ToListAsync();
  

          var rows = await MapUsersToOutputAsync(
              users,
              scopeLocationIds,
              restrictAssignedLocationsToFilter: scopeLocationIds is not null);

          var regionNameMap = await LoadRegionNameMapAsync(
              rows.SelectMany(r => r.RegionIds).Distinct(StringComparer.Ordinal));
  

          var fileName = $"team-members_{Clock.Now:yyyy-MM-dd_HH-mm-ss}.pdf";
          var document = Document.Create(container =>
          {
              container.Page(page =>
              {
                  page.Margin(22);
                  page.DefaultTextStyle(x => x.FontSize(8));
                  page.Header().Text("Team Members").SemiBold().FontSize(16);
                  page.Content().PaddingTop(8).Table(table =>
                  {
                      table.ColumnsDefinition(c =>
                      {

                          c.RelativeColumn(1.3f);
                          c.RelativeColumn(1.5f);
                          c.RelativeColumn(1.0f);
                          c.RelativeColumn(1.0f);

                          c.RelativeColumn(1.4f);

                          c.RelativeColumn(2.0f);

                          c.RelativeColumn(0.7f);
                      });
  
                      static IContainer CellHeader(IContainer c) =>
                          c.Background(Colors.Grey.Lighten3).Padding(4).DefaultTextStyle(x => x.SemiBold());
  
                      table.Cell().Element(CellHeader).Text("Name");
                      table.Cell().Element(CellHeader).Text("Email");
                      table.Cell().Element(CellHeader).Text("Phone");
                      table.Cell().Element(CellHeader).Text("Role");

                      table.Cell().Element(CellHeader).Text("Region");

                      table.Cell().Element(CellHeader).Text("Assigned Locations");
                      table.Cell().Element(CellHeader).Text("Status");
  
                      foreach (var e in rows)
                      {

                          var regionText = e.RegionIds.Count == 0
                              ? "无"
                              : string.Join("; ",
                                  e.RegionIds.Select(id =>
                                      regionNameMap.TryGetValue(id, out var name) && !string.IsNullOrWhiteSpace(name)
                                          ? name
                                          : id));

                          var locText = e.AssignedLocations.Count == 0
                              ? "无"
                              : string.Join("; ",
                                  e.AssignedLocations.Select(a =>
                                      $"{a.LocationCode} - {a.LocationName}"));
                          var status = e.State ? "Active" : "Inactive";
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                              .Text(e.FullName ?? string.Empty);
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                              .Text(e.Email ?? "无");
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                              .Text(e.Phone?.ToString() ?? "无");
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                              .Text(string.IsNullOrWhiteSpace(e.RoleName) ? "无" : e.RoleName);
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)

                              .Text(regionText);
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)

                              .Text(locText);
                          table.Cell().BorderBottom(0.5f).BorderColor(Colors.Grey.Lighten2).Padding(3)
                              .Text(status);
                      }
                  });
              });
          });
  
          var stream = new MemoryStream();
          document.GeneratePdf(stream);
          stream.Position = 0;
          return new FileStreamResult(stream, "application/pdf") { FileDownloadName = fileName };
      }
  
      /// <inheritdoc />
      public async Task<TeamMemberBatchImportResultDto> ImportTeamMembersBatchAsync(
          [FromForm] TeamMemberBatchImportInputVo input)
      {
          if (input?.File is null || input.File.Length == 0)
          {
              throw new UserFriendlyException("请上传 Excel 文件（form 字段名：file）");
          }
  
          var opt = _batchImportOptions.Value;
          if (input.File.Length > opt.MaxUploadBytes)
          {
              throw new UserFriendlyException($"文件过大，最大允许 {opt.MaxUploadBytes / 1024 / 1024} MB");
          }
  
          var ext = Path.GetExtension(input.File.FileName)?.ToLowerInvariant();
          if (ext != ".xlsx")
          {
              throw new UserFriendlyException("仅支持 .xlsx 格式的 Excel 文件");
          }
  
          var roleMap = await BuildRoleNameToIdMapAsync();
          await using var uploadStream = input.File.OpenReadStream();
          var parseErrors = new List<TeamMemberBatchImportErrorDto>();
          var rows = TeamMemberBatchExcelHelper.ParseImportWorkbook(
              uploadStream,
              opt.MaxImportRows <= 0 ? 5000 : opt.MaxImportRows,
              roleMap,
              opt.TeamMemberImportDefaultPassword?.Trim() ?? string.Empty,
              out var headerErrors);
          parseErrors.AddRange(headerErrors);
  
          var result = new TeamMemberBatchImportResultDto();
          if (rows.Count == 0 && parseErrors.Count > 0)
          {
              result.Errors = parseErrors;
              result.FailCount = parseErrors.Count;
              return result;
          }
  
          foreach (var (rowNum, vo) in rows)
          {
              try
              {

                  if (vo.RegionIds is { Count: > 0 })
                  {
                      vo.RegionIds = await ResolveRegionIdsFromImportTokensAsync(vo.RegionIds);
                  }
  
                  if (vo.LocationIds is { Count: > 0 })
                  {
                      vo.LocationIds = await ResolveLocationIdsFromImportTokensAsync(vo.LocationIds);
                  }
  

                  await CreateAsync(vo);
                  result.SuccessCount++;
              }
              catch (UserFriendlyException ex)
              {
                  result.FailCount++;
                  result.Errors.Add(new TeamMemberBatchImportErrorDto
                  {
                      RowNumber = rowNum,
                      UserName = vo.UserName,
                      Message = ex.Message
                  });
              }
          }
  
          result.Errors.InsertRange(0, parseErrors);
          return result;
      }
  
      /// <inheritdoc />
      public async Task<TeamMemberBulkUpdateResultDto> UpdateTeamMembersBulkAsync(
          [FromBody] TeamMemberBulkUpdateInputVo input)
      {
          if (input?.Items is null || input.Items.Count == 0)
          {
              throw new UserFriendlyException("请至少提交一条编辑数据（items 不能为空）");
          }
  
          var opt = _batchImportOptions.Value;
          var maxItems = opt.MaxBulkUpdateItems <= 0 ? 500 : opt.MaxBulkUpdateItems;
          if (input.Items.Count > maxItems)
          {
              throw new UserFriendlyException($"单次批量编辑最多允许 {maxItems} 条，请分批提交");
          }
  
          var effectiveCount = input.Items.Count(static x => x is not null && x.Id != Guid.Empty);
          if (effectiveCount == 0)
          {
              throw new UserFriendlyException("没有有效的成员 Id（请为待保存行填写 id）");
          }
  
          var result = new TeamMemberBulkUpdateResultDto();
          for (var i = 0; i < input.Items.Count; i++)
          {
              var item = input.Items[i];
              if (item is null || item.Id == Guid.Empty)
              {
                  continue;
              }
  
              try
              {
                  await UpdateAsync(item.Id, item);
                  result.SuccessCount++;
              }
              catch (UserFriendlyException ex)
              {
                  result.FailCount++;
                  result.Errors.Add(new TeamMemberBulkUpdateErrorDto
                  {
                      RowNumber = i + 1,
                      Id = item.Id,
                      Message = ex.Message
                  });
              }
          }
  
          return result;
      }
  
      private async Task<Dictionary<string, Guid>> BuildRoleNameToIdMapAsync()
      {
          var roles = await _dbContext.SqlSugarClient.Queryable<RoleAggregateRoot>()
              .Where(r => !r.IsDeleted)
              .Select(r => new { r.Id, r.RoleName })
              .ToListAsync();
  
          return roles
              .Where(r => !string.IsNullOrWhiteSpace(r.RoleName))
              .GroupBy(r => TeamMemberBatchExcelHelper.NormalizeRoleKey(r.RoleName!))
              .ToDictionary(g => g.Key, g => g.First().Id);
      }
  
      private async Task<List<string>> ResolveLocationIdsFromImportTokensAsync(List<string> tokens)
      {
          var result = new List<string>();
          foreach (var raw in tokens)
          {
              var s = raw.Trim();
              if (string.IsNullOrEmpty(s))
              {
                  continue;
              }
  
              var idx = s.IndexOf(" -", StringComparison.Ordinal);
              var key = idx > 0 ? s[..idx].Trim() : s.Trim();
              if (Guid.TryParse(key, out var gid))
              {
                  var byId = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                      .Where(x => !x.IsDeleted && x.Id == gid)
                      .FirstAsync();
                  if (byId is null)
                  {
                      throw new UserFriendlyException($"无效门店 Id：{key}");
                  }
  
                  result.Add(byId.Id.ToString());
                  continue;
              }
  
              var byCode = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                  .Where(x => !x.IsDeleted && x.LocationCode == key)
                  .FirstAsync();
              if (byCode is null)
              {

                  throw new UserFriendlyException($"未找到门店 LocationCode：{key}（亦可填 location.Id Guid）");

              }
  
              result.Add(byCode.Id.ToString());
          }
  
          return result.Distinct().ToList();
      }
  

      private async Task<List<string>> ResolveRegionIdsFromImportTokensAsync(List<string> tokens)
      {
          var result = new List<string>();
          foreach (var raw in tokens)
          {
              var s = raw.Trim();
              if (string.IsNullOrEmpty(s))
              {
                  continue;
              }
  
              var idx = s.IndexOf(" -", StringComparison.Ordinal);
              var key = idx > 0 ? s[..idx].Trim() : s.Trim();
  
              if (Guid.TryParse(key, out _))
              {
                  var byId = await _dbContext.SqlSugarClient.Queryable<FlGroupDbEntity>()
                      .Where(x => !x.IsDeleted && x.Id == key)
                      .FirstAsync();
                  if (byId is null)
                  {
                      throw new UserFriendlyException($"无效 Region Id：{key}");
                  }
  
                  result.Add(byId.Id.Trim());
                  continue;
              }
  
              var matches = await _dbContext.SqlSugarClient.Queryable<FlGroupDbEntity>()
                  .Where(x => !x.IsDeleted)
                  .ToListAsync();
              matches = matches
                  .Where(x => string.Equals(x.GroupName?.Trim(), key, StringComparison.OrdinalIgnoreCase))
                  .ToList();
  
              if (matches.Count == 0)
              {
                  throw new UserFriendlyException($"未找到 Region：{key}（可填 fl_group.Id 或 GroupName）");
              }
  
              if (matches.Count > 1)
              {
                  throw new UserFriendlyException(
                      $"Region 名称「{key}」存在多条记录，请改用 fl_group.Id（Guid）");
              }
  
              result.Add(matches[0].Id.Trim());
          }
  
          return result.Distinct(StringComparer.Ordinal).ToList();
      }
  
      private async Task<Dictionary<string, string>> LoadRegionNameMapAsync(IEnumerable<string> regionIds)
      {
          var ids = regionIds
              .Where(x => !string.IsNullOrWhiteSpace(x))
              .Select(x => x.Trim())
              .Distinct(StringComparer.Ordinal)
              .ToList();
          if (ids.Count == 0)
          {
              return new Dictionary<string, string>(StringComparer.Ordinal);
          }
  
          var groups = await _dbContext.SqlSugarClient.Queryable<FlGroupDbEntity>()
              .Where(x => !x.IsDeleted && ids.Contains(x.Id))
              .Select(x => new { x.Id, x.GroupName })
              .ToListAsync();
  
          return groups
              .Where(x => !string.IsNullOrWhiteSpace(x.Id))
              .ToDictionary(
                  x => x.Id.Trim(),
                  x => x.GroupName?.Trim() ?? x.Id.Trim(),
                  StringComparer.Ordinal);
      }
  

      private async Task<ISugarQueryable<UserAggregateRoot>> BuildFilteredUserQueryAsync(
          TeamMemberGetListInputVo input,
          List<string>? scopeLocationIds)

      {
          var keyword = input.Keyword?.Trim();
          var query = _userRepository._DbQueryable
              .Where(u => !u.IsDeleted)
              .WhereIF(!string.IsNullOrWhiteSpace(keyword),
                  u => (u.Name != null && u.Name.Contains(keyword!)) ||
                       u.UserName.Contains(keyword!) ||
                       (u.Email != null && u.Email.Contains(keyword!)) ||
                       (u.Phone != null && u.Phone.ToString()!.Contains(keyword!)))
              .WhereIF(input.State != null, u => u.State == input.State);
  
          if (input.RoleId != null)
          {
              var userIds = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity>()
                  .Where(ur => ur.RoleId == input.RoleId.Value)
                  .Select(ur => ur.UserId)
                  .ToListAsync();
              query = query.Where(u => userIds.Contains(u.Id));
          }
  

          if (scopeLocationIds is not null)

          {

              if (scopeLocationIds.Count == 0)
              {
                  query = query.Where(_ => false);
              }
              else
              {

                  var scopeGuidSet = TeamMemberListScopeHelper.ParseGuidHashSet(scopeLocationIds);
                  var userLocationLinks = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()
                      .Where(x => !x.IsDeleted)
                      .Select(x => new { x.UserId, x.LocationId })

                      .ToListAsync();

  
                  var allowedUserGuids = userLocationLinks
                      .Where(x =>
                          Guid.TryParse(x.LocationId, out var locGuid) && scopeGuidSet.Contains(locGuid))
                      .Select(x => x.UserId)
                      .Select(TeamMemberListScopeHelper.NormalizeScopeKey)
                      .Where(x => !string.IsNullOrEmpty(x))
                      .Select(x => Guid.Parse(x))
                      .Distinct()
                      .ToList();
  
                  if (allowedUserGuids.Count == 0)
                  {
                      query = query.Where(_ => false);
                  }
                  else
                  {
                      query = query.Where(u => allowedUserGuids.Contains(u.Id));
                  }

              }

          }
  
          return query;
      }
  
      private async Task<List<TeamMemberGetListOutputDto>> MapUsersToOutputAsync(
          List<UserAggregateRoot> users,

          List<string>? scopeLocationIds,

          bool restrictAssignedLocationsToFilter)
      {
          if (users.Count == 0)
          {
              return new List<TeamMemberGetListOutputDto>();
          }
  
          var userIds = users.Select(x => x.Id).ToList();

          var userGuidKeys = userIds.Select(TeamMemberListScopeHelper.UserKey).ToHashSet(StringComparer.Ordinal);

  
          var userRolePairs = await _dbContext.SqlSugarClient.Queryable<UserRoleEntity, RoleAggregateRoot>((ur, r) => ur.RoleId == r.Id)
              .Where(ur => userIds.Contains(ur.UserId))
              .Select((ur, r) => new { ur.UserId, r.Id, r.RoleName })
              .ToListAsync();
  

          var roleIdByUser = userRolePairs

              .GroupBy(x => x.UserId)

              .ToDictionary(g => g.Key, g => (Guid?)g.First().Id);

          var allUserLocations = await _dbContext.SqlSugarClient.Queryable<UserLocationDbEntity>()

              .Where(x => !x.IsDeleted)

              .Select(x => new { x.UserId, x.LocationId })
              .ToListAsync();
  
          var scopeGuidSet = scopeLocationIds is { Count: > 0 }
              ? TeamMemberListScopeHelper.ParseGuidHashSet(scopeLocationIds)
              : null;

          var userLocations = allUserLocations
              .Where(x => userGuidKeys.Contains(TeamMemberListScopeHelper.NormalizeScopeKey(x.UserId)))
              .Where(x =>
                  scopeGuidSet is null ||
                  (Guid.TryParse(x.LocationId, out var locGuid) && scopeGuidSet.Contains(locGuid)))
              .ToList();

  
          var locationIds = userLocations.Select(x => x.LocationId).Distinct().ToList();

          var locationGuidList = TeamMemberListScopeHelper.ParseGuidList(locationIds);

          var locations = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
              .Where(x => !x.IsDeleted)

              .WhereIF(locationGuidList.Count > 0, x => locationGuidList.Contains(x.Id))

              .Select(x => new { x.Id, x.LocationCode, x.LocationName })
              .ToListAsync();

          var locationMap = locations.ToDictionary(
              x => TeamMemberListScopeHelper.UserKey(x.Id),
              x => x);

  
          var assignedMap = userLocations

              .GroupBy(x => TeamMemberListScopeHelper.NormalizeScopeKey(x.UserId))

              .ToDictionary(
                  g => g.Key,
                  g => g.Select(x =>
                  {

                      var locKey = TeamMemberListScopeHelper.NormalizeScopeKey(x.LocationId);
                      if (locationMap.TryGetValue(locKey, out var loc))
                      {
                          return new TeamMemberAssignedLocationDto
                          {
                              Id = loc.Id.ToString(),
                              LocationCode = loc.LocationCode,
                              LocationName = loc.LocationName
                          };
                      }
  
                      if (locationMap.TryGetValue(x.LocationId, out loc))

                      {
                          return new TeamMemberAssignedLocationDto
                          {
                              Id = loc.Id.ToString(),
                              LocationCode = loc.LocationCode,
                              LocationName = loc.LocationName
                          };
                      }
  
                      return null;
                  }).Where(x => x != null).Cast<TeamMemberAssignedLocationDto>().ToList());
  

          var scopeIdsMap = await BuildTeamMemberScopeIdsMapAsync(assignedMap, roleIdByUser);

          var items = new List<TeamMemberGetListOutputDto>();
          foreach (var u in users)

          {

              roleIdByUser.TryGetValue(u.Id, out var listRoleId);
              var roleName = userRolePairs.FirstOrDefault(x => x.UserId == u.Id)?.RoleName;
              var userKey = TeamMemberListScopeHelper.UserKey(u.Id);
              assignedMap.TryGetValue(userKey, out var assigned);
              scopeIdsMap.TryGetValue(userKey, out var scopeIds);
  
              var partnerIds = scopeIds?.PartnerIds ?? new List<string>();
              var regionIds = scopeIds?.RegionIds ?? new List<string>();
              var assignedLocations = assigned ?? new List<TeamMemberAssignedLocationDto>();
  
              (regionIds, assignedLocations) = await ApplyCompanyAdminDisplayScopeAsync(
                  listRoleId, partnerIds, regionIds, assignedLocations);
  
              var locationIdList = assignedLocations
                  .Select(x => x.Id)
                  .Where(x => !string.IsNullOrWhiteSpace(x))
                  .Distinct(StringComparer.OrdinalIgnoreCase)
                  .ToList();

              items.Add(new TeamMemberGetListOutputDto

              {
                  Id = u.Id,
                  FullName = u.Name ?? string.Empty,
                  UserName = u.UserName,
                  Email = u.Email,
                  Phone = u.Phone,
                  State = u.State,

                  RoleId = listRoleId,
                  RoleName = TeamMemberRoleHelper.FormatDisplayRoleName(roleName),
                  PartnerIds = partnerIds,
                  RegionIds = regionIds,
                  LocationIds = locationIdList,
                  AssignedLocations = assignedLocations
              });
          }
  
          return items;

      }
  

      private async Task<Dictionary<string, TeamMemberScopeIds>> BuildTeamMemberScopeIdsMapAsync(

          Dictionary<string, List<TeamMemberAssignedLocationDto>> assignedMap,
          Dictionary<Guid, Guid?> roleIdByUser)

      {
          var result = new Dictionary<string, TeamMemberScopeIds>(StringComparer.Ordinal);
          foreach (var (userId, assigned) in assignedMap)
          {
              var locationIds = assigned
                  .Select(x => x.Id)
                  .Where(x => !string.IsNullOrWhiteSpace(x))
                  .Select(x => x.Trim())
                  .Distinct(StringComparer.Ordinal)
                  .ToList();

  
              var partnerIds = locationIds.Count == 0
                  ? new List<string>()
                  : await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(
                      _dbContext.SqlSugarClient, locationIds);
              var regionIds = locationIds.Count == 0
                  ? new List<string>()
                  : await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
                      _dbContext.SqlSugarClient, locationIds);
  
              if (Guid.TryParse(userId, out var userGuid) &&
                  roleIdByUser.TryGetValue(userGuid, out var roleId) &&
                  await TeamMemberRoleHelper.IsCompanyAdminRoleAsync(_dbContext.SqlSugarClient, roleId) &&
                  partnerIds.Count > 0)

              {

                  var allRegions = await LocationScopeBindingHelper.ResolveGroupIdsFromPartnerIdsAsync(
                      _dbContext.SqlSugarClient, partnerIds);
                  if (allRegions.Count > 0)
                  {
                      regionIds = allRegions;
                  }

              }
  

              result[userId] = new TeamMemberScopeIds
              {
                  PartnerIds = partnerIds,
                  RegionIds = regionIds
              };
          }
  
          return result;
      }
  

      /// <summary>
      /// Company Admin 列表/详情：展示所选 Company 下全部 Region 与门店。
      /// </summary>
      private async Task<(List<string> RegionIds, List<TeamMemberAssignedLocationDto> AssignedLocations)>
          ApplyCompanyAdminDisplayScopeAsync(
              Guid? roleId,
              List<string> partnerIds,
              List<string> regionIds,
              List<TeamMemberAssignedLocationDto> assigned)
      {
          if (!await TeamMemberRoleHelper.IsCompanyAdminRoleAsync(_dbContext.SqlSugarClient, roleId) ||
              partnerIds.Count == 0)
          {
              return (regionIds, assigned);
          }
  
          var allRegions = await LocationScopeBindingHelper.ResolveGroupIdsFromPartnerIdsAsync(
              _dbContext.SqlSugarClient, partnerIds);
          var allLocationIds = await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(
              _dbContext.SqlSugarClient, partnerIds);
          var allAssigned = await BuildAssignedLocationDtosAsync(allLocationIds);
  
          return (
              allRegions.Count > 0 ? allRegions : regionIds,
              allAssigned.Count > 0 ? allAssigned : assigned);
      }
  
      private async Task<List<TeamMemberAssignedLocationDto>> BuildAssignedLocationDtosAsync(
          IReadOnlyList<string> locationIds)
      {
          var ids = LocationScopeBindingHelper.NormalizeIds(locationIds);
          if (ids.Count == 0)
          {
              return new List<TeamMemberAssignedLocationDto>();
          }
  
          var guidList = ids
              .Select(x => Guid.TryParse(x, out var g) ? g : (Guid?)null)
              .Where(x => x.HasValue)
              .Select(x => x!.Value)
              .ToList();
          if (guidList.Count == 0)
          {
              return new List<TeamMemberAssignedLocationDto>();
          }
  
          var locations = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
              .Where(x => !x.IsDeleted && guidList.Contains(x.Id))
              .Select(x => new { x.Id, x.LocationCode, x.LocationName })
              .ToListAsync();
  
          return locations
              .OrderBy(x => x.LocationCode)
              .Select(x => new TeamMemberAssignedLocationDto
              {
                  Id = x.Id.ToString(),
                  LocationCode = x.LocationCode,
                  LocationName = x.LocationName
              })
              .ToList();
      }
  

      private sealed class TeamMemberScopeIds
      {
          public List<string> PartnerIds { get; init; } = new();
          public List<string> RegionIds { get; init; } = new();
      }
  
      private Task<List<string>> ResolveTeamMemberLocationIdsForSaveAsync(TeamMemberUpdateInputVo input) =>
          ResolveTeamMemberLocationIdsForSaveAsync(new TeamMemberCreateInputVo
          {
              PartnerId = input.PartnerId,
              PartnerIds = input.PartnerIds,
              RegionIds = input.RegionIds,
              GroupIds = input.GroupIds,
              LocationIds = input.LocationIds