王明 / Food-Labeling-Management-Platform

  using System.Text.RegularExpressions;

  using FoodLabeling.Th.Application.Contracts.Dtos.MultiTenancy;

  using FoodLabeling.Th.Application.Contracts.IServices;

  using FoodLabeling.Th.Application.Contracts.Options;

  using FoodLabeling.Th.Application.MultiTenancy;

  using FoodLabeling.Th.Domain.Entities;
  using FoodLabeling.Th.Domain.Shared.Helpers;

  using Microsoft.AspNetCore.Authorization;

  using Microsoft.AspNetCore.Mvc;

  using Microsoft.Extensions.Options;

  using SqlSugar;
  using Volo.Abp;
  using Volo.Abp.Application.Dtos;

  using Volo.Abp.Application.Services;

  using Volo.Abp.Caching;
  using Volo.Abp.Domain.Entities;

  using Volo.Abp.MultiTenancy;

  using Volo.Abp.Uow;
  using Yi.Framework.Rbac.Domain.Entities;
  using Yi.Framework.Rbac.Domain.Helpers;
  using Yi.Framework.Rbac.Domain.Shared.Consts;

  using Yi.Framework.Rbac.Domain.Shared.Options;

  using Yi.Framework.SqlSugarCore.Abstractions;

  using Yi.Framework.TenantManagement.Application.Contracts;

  using Yi.Framework.TenantManagement.Application.Contracts.Dtos;

  using Yi.Framework.TenantManagement.Domain;

  
  namespace FoodLabeling.Th.Application.Services;
  

  /// <summary>

  /// 泰额版多租户：租户下拉、公司列表与管理员凭据管理

  /// </summary>

  public class ThMultiTenancyAppService : ApplicationService, IThMultiTenancyAppService

  {

      private static readonly Guid ProtectedDefaultTenantId = Guid.Parse("11111111-1111-1111-1111-111111111111");
      private const string ProtectedDefaultTenantName = "Default";
      private static readonly HashSet<string> ProtectedDatabaseNames = new(StringComparer.OrdinalIgnoreCase)
      {
          "antis-foodlabeling-host",
          "antis-foodlabeling-us"
      };
      private static readonly Regex SafeDatabaseNameRegex =
          new(@"^[a-zA-Z0-9][a-zA-Z0-9_\-]{0,63}$", RegexOptions.Compiled);

  
      private readonly ITenantService _tenantService;

      private readonly ISqlSugarRepository<TenantAggregateRoot, Guid> _tenantRepository;
      private readonly ISqlSugarRepository<ThTenantAdminCredentialEntity, Guid> _credentialRepository;
      private readonly ISqlSugarRepository<ThTenantMenuPermissionEntity, string> _menuPermissionRepository;

      private readonly TenantSelectCredentialCipher _credentialCipher;

      private readonly RbacOptions _rbacOptions;

      private readonly FoodLabelingThTenantDatabaseOptions _tenantDatabaseOptions;
      private readonly DbConnOptions _dbConnOptions;
      private readonly IDistributedCache<TenantCacheItem> _tenantCache;

  
      public ThMultiTenancyAppService(

          ITenantService tenantService,

          ISqlSugarRepository<TenantAggregateRoot, Guid> tenantRepository,
          ISqlSugarRepository<ThTenantAdminCredentialEntity, Guid> credentialRepository,
          ISqlSugarRepository<ThTenantMenuPermissionEntity, string> menuPermissionRepository,

          TenantSelectCredentialCipher credentialCipher,

          IOptions<RbacOptions> rbacOptions,
          IOptions<FoodLabelingThTenantDatabaseOptions> tenantDatabaseOptions,
          IOptions<DbConnOptions> dbConnOptions,
          IDistributedCache<TenantCacheItem> tenantCache)

      {

          _tenantService = tenantService;

          _tenantRepository = tenantRepository;
          _credentialRepository = credentialRepository;
          _menuPermissionRepository = menuPermissionRepository;

          _credentialCipher = credentialCipher;

          _rbacOptions = rbacOptions.Value;

          _tenantDatabaseOptions = tenantDatabaseOptions.Value;
          _dbConnOptions = dbConnOptions.Value;
          _tenantCache = tenantCache;

      }
  

      /// <summary>

      /// 主库表（DefaultTenantTable）读写须将 CurrentTenant 置空
      /// </summary>
      private IDisposable UseHostTenantScope() => CurrentTenant.Change(null);

      /// <summary>

      /// 获取登录页可选租户列表（含默认管理员加密凭据）

      /// </summary>

      /// <remarks>

      /// 供 Web 登录页租户下拉使用；匿名可访问。不返回租户 Id 与数据库连接串。

      ///

      /// 示例响应：
      /// ```json
      /// [
      ///   {
      ///     "name": "Default",
      ///     "creationTime": "2026-01-01T08:00:00",
      ///     "loginAccount": "admin",
      ///     "password": "Base64CipherText",
      ///     "passwordSalt": "Base64Iv"
      ///   }
      /// ]
      /// ```
      ///
      /// 字段说明：
      /// - name: 租户名称，登录时可传 tenantName
      /// - creationTime: 租户创建时间
      /// - loginAccount: 管理员登录账号，优先读凭据表，否则为 admin
      /// - password: 优先读凭据表 AES 密文，否则 RbacOptions.AdminPassword 加密后返回
      /// - passwordSalt: AES IV（Base64），前端解密时使用
      /// </remarks>
      /// <returns>租户下拉列表</returns>
      /// <response code="200">成功返回租户列表</response>
      /// <response code="500">加密配置缺失或服务器错误</response>
      [AllowAnonymous]
      public virtual async Task<List<ThTenantSelectDto>> GetTenantSelectAsync()
      {
          var page = await _tenantService.GetListAsync(new TenantGetListInput
          {
              SkipCount = 0,
              MaxResultCount = 500
          });
  
          var credentialMap = await LoadCredentialMapAsync(page.Items.Select(x => x.Id).ToList());

          return page.Items
              .Select(x =>
              {
                  credentialMap.TryGetValue(x.Id, out var credential);
                  var resolved = ResolveEncryptedCredential(credential);
                  return new ThTenantSelectDto
                  {
                      Name = x.Name,
                      CreationTime = x.CreationTime,
                      LoginAccount = resolved.LoginAccount,
                      Password = resolved.Password,
                      PasswordSalt = resolved.PasswordSalt
                  };
              })
              .OrderBy(x => x.Name)
              .ToList();
      }
  
      /// <summary>
      /// 平台管理员分页获取公司（租户）列表及可回显加密凭据
      /// </summary>
      /// <remarks>
      /// 需登录；查询主库 YiTenant，密码优先读 fl_th_tenant_admin_credential，否则回退 RbacOptions.AdminPassword 再 AES 加密返回。
      ///
      /// 示例请求（GET，query/data）：
      /// ```json
      /// {
      ///   "keyword": "测试",
      ///   "skipCount": 0,
      ///   "maxResultCount": 20
      /// }
      /// ```
      ///

      /// 示例响应：

      /// ```json
      /// {
      ///   "totalCount": 1,
      ///   "items": [
      ///     {
      ///       "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      ///       "name": "测试公司",
      ///       "creationTime": "2026-01-01T08:00:00",
      ///       "loginAccount": "admin",
      ///       "password": "Base64CipherText",
      ///       "passwordSalt": "Base64Iv"
      ///     }
      ///   ]
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - keyword/name: 租户名称模糊匹配（keyword 优先）
      /// - skipCount: 跳过条数
      /// - maxResultCount: 每页条数
      /// </remarks>
      /// <param name="input">分页与筛选条件</param>
      /// <returns>分页公司列表</returns>
      /// <response code="200">成功返回分页列表</response>
      /// <response code="401">未登录</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpGet("th-multi-tenancy/company-list")]
      public virtual async Task<PagedResultDto<ThCompanyListItemDto>> GetCompanyListAsync(ThCompanyListInput input)
      {
          var nameFilter = !string.IsNullOrWhiteSpace(input.Keyword) ? input.Keyword : input.Name;
  
          var page = await _tenantService.GetListAsync(new TenantGetListInput
          {
              Name = nameFilter,
              SkipCount = input.SkipCount,
              MaxResultCount = input.MaxResultCount
          });
  
          var tenantIds = page.Items.Select(x => x.Id).ToList();
          var credentialMap = await LoadCredentialMapAsync(tenantIds);
          var menuPermissionMap = await LoadMenuPermissionMapAsync(tenantIds);

          var items = page.Items.Select(x =>
          {
              credentialMap.TryGetValue(x.Id, out var credential);
              var resolved = ResolveEncryptedCredential(credential);
              menuPermissionMap.TryGetValue(x.Id, out var menuKeys);
              return new ThCompanyListItemDto
              {
                  Id = x.Id,
                  Name = x.Name,
                  CreationTime = x.CreationTime,
                  LoginAccount = resolved.LoginAccount,
                  Password = resolved.Password,
                  PasswordSalt = resolved.PasswordSalt,
                  MenuPermissionKeys = menuKeys ?? new List<string>()
              };
          }).ToList();
  
          return new PagedResultDto<ThCompanyListItemDto>(page.TotalCount, items);
      }
  
      /// <summary>
      /// 修改公司（租户）默认管理员登录账号与/或密码
      /// </summary>
      /// <remarks>
      /// 需登录。password/passwordSalt 均为空时不改密码；有 password 时必须带 passwordSalt，后端解密后再写入租户库 User 哈希。
      ///
      /// 示例请求：

      /// ```json

      /// {
      ///   "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      ///   "loginAccount": "admin",
      ///   "password": "Base64CipherText",
      ///   "passwordSalt": "Base64Iv"
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（必填）
      /// - loginAccount: 新登录账号（可选）
      /// - password: AES 加密新密码（可选）
      /// - passwordSalt: AES IV（改密时必填）
      /// </remarks>
      /// <param name="input">租户 Id 与待修改凭据</param>
      /// <returns>无内容</returns>
      /// <response code="200">修改成功</response>
      /// <response code="400">参数错误或账号重复</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户或管理员不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpPut("th-multi-tenancy/company-admin")]
      public virtual async Task UpdateCompanyAdminAsync(ThUpdateCompanyAdminInputVo input)
      {
          if (input.TenantId == Guid.Empty)
          {
              throw new UserFriendlyException("租户 Id 不能为空");
          }

          var hasPassword = !string.IsNullOrWhiteSpace(input.Password);
          if (hasPassword && string.IsNullOrWhiteSpace(input.PasswordSalt))
          {
              throw new UserFriendlyException("修改密码时必须提供 passwordSalt");
          }

          TenantAggregateRoot tenant;
          ThTenantAdminCredentialEntity? existingCredential;
          using (UseHostTenantScope())
          {
              tenant = await _tenantRepository.FindAsync(input.TenantId)
                       ?? throw new UserFriendlyException("租户不存在");
              // 主键列 TenantId 映射到实体 Id，用 Queryable 按 Id 查询
              var credentials = await _credentialRepository._DbQueryable
                  .Where(c => c.Id == input.TenantId)
                  .Take(1)
                  .ToListAsync();
              existingCredential = credentials.FirstOrDefault();
          }
  
          var currentLoginAccount = existingCredential?.LoginAccount?.Trim()
                                    ?? ThTenantSelectConsts.DefaultAdminLoginAccount;
          var newLoginAccount = !string.IsNullOrWhiteSpace(input.LoginAccount)
              ? input.LoginAccount.Trim()
              : currentLoginAccount;
  
          string? plainPassword = null;
          if (hasPassword)
          {
              plainPassword = _credentialCipher.DecryptPassword(input.Password!, input.PasswordSalt!);
          }

          var (connectionString, dbType) = await ResolveTenantBusinessConnectionAsync(tenant);
          using var tenantDb = TenantBusinessDatabaseAccessor.CreateClient(connectionString, dbType);
          TenantBusinessDatabaseAccessor.EnsureDatabaseReachable(tenantDb, input.TenantId);

          var adminUsers = await tenantDb.Queryable<UserAggregateRoot>()
              .Where(u => u.UserName == currentLoginAccount && !u.IsDeleted)
              .Take(1)
              .ToListAsync();
          var adminUser = adminUsers.FirstOrDefault()
                          ?? throw new UserFriendlyException("未找到租户管理员账号");

          if (!string.Equals(newLoginAccount, currentLoginAccount, StringComparison.OrdinalIgnoreCase))
          {
              if (await tenantDb.Queryable<UserAggregateRoot>().AnyAsync(u =>
                      u.UserName == newLoginAccount && u.Id != adminUser.Id && !u.IsDeleted))
              {
                  throw new UserFriendlyException(UserConst.Exist);
              }

              await tenantDb.Updateable<UserAggregateRoot>()
                  .SetColumns(u => u.UserName == newLoginAccount)
                  .Where(u => u.Id == adminUser.Id)
                  .ExecuteCommandAsync();
          }

          if (plainPassword != null)
          {
              UserPasswordHelper.ApplyPlainPassword(adminUser, plainPassword);
              await tenantDb.Updateable<UserAggregateRoot>()
                  .SetColumns(u => u.EncryPassword.Password == adminUser.EncryPassword.Password)
                  .SetColumns(u => u.EncryPassword.Salt == adminUser.EncryPassword.Salt)
                  .Where(u => u.Id == adminUser.Id)
                  .ExecuteCommandAsync();
          }
  
          await UpsertCredentialAsync(
              input.TenantId,
              newLoginAccount,
              passwordChanged: plainPassword != null,
              plainPassword,
              existingCredential);
      }

      /// <summary>
      /// 获取 SaaS 菜单权限树
      /// </summary>
      /// <remarks>
      /// 供平台管理员配置租户菜单权限时使用；Key 与前端 saas-menu-tree 一致。
      ///
      /// 示例响应：
      /// ```json
      /// [
      ///   {
      ///     "key": "dashboard",
      ///     "title": "仪表盘",
      ///     "children": [
      ///       { "key": "dashboard:analytics", "title": "数据分析" }
      ///     ]

      ///   }

      /// ]

      /// ```

      /// </remarks>
      /// <returns>SaaS 菜单权限树</returns>
      /// <response code="200">成功返回权限树</response>
      /// <response code="401">未登录</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpGet("th-multi-tenancy/menu-permission-tree")]
      public virtual Task<List<ThSaasMenuPermissionTreeNodeDto>> GetMenuPermissionTreeAsync()
      {
          return Task.FromResult(CloneTree(ThSaasMenuPermissionCatalog.Tree));
      }

      /// <summary>
      /// 获取公司（租户）已分配的 SaaS 菜单权限
      /// </summary>
      /// <remarks>
      /// 需登录；读取主库 fl_th_tenant_menu_permission。

      ///

      /// 示例请求（GET，query/data）：
      /// ```json
      /// { "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6" }
      /// ```
      ///
      /// 示例响应：
      /// ```json
      /// {
      ///   "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      ///   "menuPermissionKeys": ["dashboard", "labeling:labels"]
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（必填）
      /// </remarks>
      /// <param name="tenantId">租户 Id</param>
      /// <returns>租户菜单权限</returns>
      /// <response code="200">成功返回菜单权限</response>
      /// <response code="400">租户 Id 无效</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpGet("th-multi-tenancy/company-menus")]
      public virtual async Task<ThCompanyMenusDto> GetCompanyMenusAsync([FromQuery] Guid tenantId)
      {
          await EnsureTenantExistsAsync(tenantId);
          var keys = await LoadMenuPermissionKeysAsync(tenantId);
          return new ThCompanyMenusDto
          {
              TenantId = tenantId,
              MenuPermissionKeys = keys
          };
      }

      /// <summary>
      /// 覆盖式设置公司（租户）SaaS 菜单权限
      /// </summary>
      /// <remarks>
      /// 需登录；写入主库 fl_th_tenant_menu_permission（先删后插）。非法 permission key 将报错。
      ///
      /// 示例请求：
      /// ```json
      /// {
      ///   "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      ///   "menuPermissionKeys": ["dashboard", "labeling:labels"]
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（必填）
      /// - menuPermissionKeys: 菜单权限 Key 列表（覆盖式，可为空表示清空）
      /// </remarks>
      /// <param name="input">租户 Id 与菜单权限 Key 列表</param>
      /// <returns>无内容</returns>
      /// <response code="200">设置成功</response>
      /// <response code="400">参数错误或存在非法 permission key</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpPut("th-multi-tenancy/company-menus")]
      [UnitOfWork]
      public virtual async Task UpdateCompanyMenusAsync([FromBody] ThUpdateCompanyMenusInputVo input)
      {
          if (input.TenantId == Guid.Empty)
          {
              throw new UserFriendlyException("租户 Id 不能为空");
          }

          await EnsureTenantExistsAsync(input.TenantId);

          var normalizedKeys = NormalizePermissionKeys(input.MenuPermissionKeys);
          var invalidKeys = ThSaasMenuPermissionCatalog.FindInvalidKeys(normalizedKeys);
          if (invalidKeys.Count > 0)
          {
              throw new UserFriendlyException($"存在非法菜单权限 Key：{string.Join(", ", invalidKeys)}");
          }

          using (UseHostTenantScope())
          {
              await _menuPermissionRepository.DeleteAsync(x => x.TenantId == input.TenantId);

              if (normalizedKeys.Count == 0)
              {
                  return;
              }

              var now = DateTime.Now;
              var entities = normalizedKeys.Select(key => new ThTenantMenuPermissionEntity
              {
                  Id = YitIdHelper.NextId().ToString(),
                  TenantId = input.TenantId,
                  PermissionKey = key,
                  CreationTime = now
              }).ToList();
  
              await _menuPermissionRepository.InsertRangeAsync(entities);
          }
      }

      /// <summary>
      /// 获取租户内角色及已绑定菜单 Id
      /// </summary>
      /// <remarks>
      /// 需登录；在指定租户业务库查询 Role / RoleMenu。
      ///
      /// 示例请求（GET，query/data）：
      /// ```json
      /// { "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6" }
      /// ```
      ///
      /// 示例响应：
      /// ```json
      /// [
      ///   {
      ///     "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      ///     "roleName": "管理员",
      ///     "roleCode": "admin",
      ///     "state": true,
      ///     "menuIds": ["11111111-1111-1111-1111-111111111111"]
      ///   }
      /// ]
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（必填）

      /// </remarks>

      /// <param name="tenantId">租户 Id</param>
      /// <returns>角色及菜单绑定列表</returns>
      /// <response code="200">成功返回角色列表</response>
      /// <response code="400">租户 Id 无效</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpGet("th-multi-tenancy/company-roles")]
      public virtual async Task<List<ThCompanyRoleItemDto>> GetCompanyRolesAsync([FromQuery] Guid tenantId)
      {
          var tenant = await EnsureTenantExistsAsync(tenantId);
          var (connectionString, dbType) = await ResolveTenantBusinessConnectionAsync(tenant);
          using var tenantDb = TenantBusinessDatabaseAccessor.CreateClient(connectionString, dbType);
          TenantBusinessDatabaseAccessor.EnsureDatabaseReachable(tenantDb, tenantId);

          var roles = await tenantDb.Queryable<RoleAggregateRoot>()
              .Where(r => !r.IsDeleted)
              .OrderBy(r => r.OrderNum)
              .ToListAsync();

          if (roles.Count == 0)
          {
              return new List<ThCompanyRoleItemDto>();
          }

          var roleIds = roles.Select(r => r.Id).ToList();
          var roleMenuLinks = await tenantDb.Queryable<RoleMenuEntity>()
              .Where(rm => roleIds.Contains(rm.RoleId))
              .ToListAsync();

          var menuIdsByRole = roleMenuLinks
              .GroupBy(x => x.RoleId)
              .ToDictionary(
                  g => g.Key,
                  g => g.Select(x => x.MenuId.ToString()).ToList());

          return roles.Select(role => new ThCompanyRoleItemDto
          {
              Id = role.Id,
              RoleName = role.RoleName,
              RoleCode = role.RoleCode,
              State = role.State,
              MenuIds = menuIdsByRole.TryGetValue(role.Id, out var menuIds)
                  ? menuIds
                  : new List<string>()
          }).ToList();
      }

      /// <summary>
      /// 覆盖式设置租户内角色的菜单绑定
      /// </summary>
      /// <remarks>
      /// 需登录；在指定租户业务库覆盖写入 RoleMenu，逻辑对齐 RbacRoleMenuAppService.Set。
      ///
      /// 示例请求：
      /// ```json
      /// {
      ///   "tenantId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      ///   "roleId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      ///   "menuIds": ["11111111-1111-1111-1111-111111111111"]
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（必填）
      /// - roleId: 角色 Id（必填）
      /// - menuIds: 菜单 Id 列表（覆盖式，可为空表示清空）
      /// </remarks>
      /// <param name="input">租户、角色与菜单 Id 列表</param>
      /// <returns>无内容</returns>
      /// <response code="200">设置成功</response>
      /// <response code="400">参数错误或菜单 Id 无效</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户或角色不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      [HttpPut("th-multi-tenancy/company-role-menus")]
      [UnitOfWork]
      public virtual async Task UpdateCompanyRoleMenusAsync([FromBody] ThUpdateCompanyRoleMenusInputVo input)

      {

          if (input.TenantId == Guid.Empty)
          {
              throw new UserFriendlyException("租户 Id 不能为空");
          }

          if (input.RoleId == Guid.Empty)
          {
              throw new UserFriendlyException("角色 Id 不能为空");
          }
  
          var tenant = await EnsureTenantExistsAsync(input.TenantId);
          var menuIds = ParseMenuIds(input.MenuIds);
          var (connectionString, dbType) = await ResolveTenantBusinessConnectionAsync(tenant);
          using var tenantDb = TenantBusinessDatabaseAccessor.CreateClient(connectionString, dbType);
          TenantBusinessDatabaseAccessor.EnsureDatabaseReachable(tenantDb, input.TenantId);
  
          var roles = await tenantDb.Queryable<RoleAggregateRoot>()
              .Where(x => x.Id == input.RoleId && !x.IsDeleted)
              .Take(1)
              .ToListAsync();
          var role = roles.FirstOrDefault();
          if (role is null)

          {

              throw new UserFriendlyException("角色不存在");
          }

          if (menuIds.Count == 0)
          {
              await tenantDb.Deleteable<RoleMenuEntity>()
                  .Where(x => x.RoleId == input.RoleId)
                  .ExecuteCommandAsync();
              return;
          }
  
          var existMenuIds = await tenantDb.Queryable<MenuAggregateRoot>()
              .Where(x => !x.IsDeleted)
              .Where(x => menuIds.Contains(x.Id))
              .Select(x => x.Id)
              .ToListAsync();
  
          var missingMenuIds = menuIds.Except(existMenuIds).ToList();
          if (missingMenuIds.Count > 0)
          {
              throw new UserFriendlyException(
                  $"存在无效或未删除的菜单 Id：{string.Join(", ", missingMenuIds)}");
          }

          await tenantDb.Deleteable<RoleMenuEntity>()
              .Where(x => x.RoleId == input.RoleId)
              .ExecuteCommandAsync();

          var entities = existMenuIds.Select(menuId =>
          {
              var entity = new RoleMenuEntity
              {
                  RoleId = input.RoleId,
                  MenuId = menuId
              };
              EntityHelper.TrySetId(entity, () => GuidGenerator.Create());
              return entity;
          }).ToList();
  
          if (entities.Count > 0)
          {
              await tenantDb.Insertable(entities).ExecuteCommandAsync();
          }
      }

      /// <summary>
      /// 删除公司（租户），可选 DROP 对应业务库
      /// </summary>
      /// <remarks>
      /// 需登录。在主库 scope 执行：校验非 Default 租户后，按 dropDatabase 决定是否 DROP 业务库；
      /// 删除 YiTenant（软删）及 fl_th_tenant_admin_credential、fl_th_tenant_menu_permission 附属记录，并清理租户缓存。
      ///
      /// 受保护规则：禁止删除 Name=Default 或 Id=11111111-1111-1111-1111-111111111111；
      /// 禁止 DROP antis-foodlabeling-host、antis-foodlabeling-us；
      /// 连接串为空或库名解析/校验失败时仅删主库记录，不 DROP。
      ///
      /// 示例请求（DELETE）：
      /// ```
      /// DELETE /api/app/th-multi-tenancy/company/3a227b24-3d9b-ea2d-81f3-6c4fedccb1d2?dropDatabase=true
      /// ```
      ///
      /// 示例响应：
      /// ```json
      /// {
      ///   "tenantId": "3a227b24-3d9b-ea2d-81f3-6c4fedccb1d2",
      ///   "name": "中国麦当劳公司",
      ///   "databaseName": "antis-foodlabeling-t46d56528",
      ///   "databaseDropped": true,
      ///   "tenantDeleted": true,
      ///   "message": null
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - tenantId: 租户 Id（路径参数，必填）
      /// - dropDatabase: 是否 DROP 业务库，默认 true
      /// </remarks>
      /// <param name="tenantId">租户 Id</param>
      /// <param name="dropDatabase">是否 DROP 业务库</param>
      /// <returns>删除执行结果</returns>
      /// <response code="200">删除成功或部分跳过 DROP 时返回结果</response>
      /// <response code="400">租户 Id 无效或受保护租户</response>
      /// <response code="401">未登录</response>
      /// <response code="404">租户不存在</response>
      /// <response code="500">DROP 或删除失败</response>
      [Authorize]
      [HttpDelete("th-multi-tenancy/company/{tenantId}")]
      [UnitOfWork]
      public virtual async Task<ThDeleteCompanyResultDto> DeleteCompanyAsync(
          [FromRoute] Guid tenantId,
          [FromQuery] bool dropDatabase = true)
      {
          if (tenantId == Guid.Empty)
          {
              throw new UserFriendlyException("租户 Id 不能为空");
          }

          EnsureTenantDeletable(tenantId, null);

          TenantAggregateRoot tenant;
          using (UseHostTenantScope())
          {
              tenant = await _tenantRepository.FindAsync(tenantId)
                       ?? throw new UserFriendlyException("租户不存在");
          }

          EnsureTenantDeletable(tenant.Id, tenant.Name);

          var databaseName = ExtractConnectionValue(tenant.TenantConnectionString, "database");
          var result = new ThDeleteCompanyResultDto
          {
              TenantId = tenant.Id,
              Name = tenant.Name,
              DatabaseName = databaseName
          };

          if (dropDatabase)
          {
              var dropDecision = EvaluateDatabaseDrop(databaseName);
              if (dropDecision.CanDrop)

              {

                  ExecuteDropDatabase(tenant.DbType, dropDecision.PrivilegedConnectionString!, databaseName!);
                  result.DatabaseDropped = true;
              }
              else
              {
                  result.Message = dropDecision.SkipReason;
              }
          }
          else
          {
              result.Message = "dropDatabase=false，已跳过 DROP DATABASE";
          }

          await _tenantService.DeleteAsync(new[] { tenantId });
          result.TenantDeleted = true;

          using (UseHostTenantScope())
          {
              await _credentialRepository._Db.Ado.ExecuteCommandAsync(
                  "DELETE FROM `fl_th_tenant_admin_credential` WHERE `TenantId` = @TenantId",
                  new List<SugarParameter> { new("@TenantId", tenantId.ToString()) });
  
              await _menuPermissionRepository.DeleteAsync(x => x.TenantId == tenantId);
          }
  
          await RemoveTenantCacheAsync(tenant.Id, tenant.Name);
  
          return result;
      }

      /// <inheritdoc />
      public virtual Task<ThCurrentTenantDto> GetCurrentTenantAsync()
      {
          return Task.FromResult(new ThCurrentTenantDto
          {
              TenantId = CurrentTenant.Id,
              TenantName = CurrentTenant.Name
          });
      }
  
      private async Task<Dictionary<Guid, ThTenantAdminCredentialEntity>> LoadCredentialMapAsync(
          IReadOnlyCollection<Guid> tenantIds)
      {
          if (tenantIds.Count == 0)
          {
              return new Dictionary<Guid, ThTenantAdminCredentialEntity>();
          }
  
          using (UseHostTenantScope())
          {
              var list = await _credentialRepository._DbQueryable
                  .Where(c => tenantIds.Contains(c.Id))
                  .ToListAsync();
              return list.ToDictionary(c => c.Id);
          }
      }
  
      private (string LoginAccount, string Password, string PasswordSalt) ResolveEncryptedCredential(
          ThTenantAdminCredentialEntity? credential)
      {
          if (credential != null
              && !string.IsNullOrEmpty(credential.PasswordCipher)
              && !string.IsNullOrEmpty(credential.PasswordIv))
          {
              var loginAccount = string.IsNullOrWhiteSpace(credential.LoginAccount)
                  ? ThTenantSelectConsts.DefaultAdminLoginAccount
                  : credential.LoginAccount;
              return (loginAccount, credential.PasswordCipher, credential.PasswordIv);
          }
  
          var plainPassword = _rbacOptions.AdminPassword ?? string.Empty;
          var encrypted = _credentialCipher.EncryptPassword(plainPassword);
          var account = string.IsNullOrWhiteSpace(credential?.LoginAccount)
              ? ThTenantSelectConsts.DefaultAdminLoginAccount
              : credential!.LoginAccount;
          return (account, encrypted.Password, encrypted.PasswordSalt);
      }
  
      private async Task UpsertCredentialAsync(
          Guid tenantId,
          string loginAccount,
          bool passwordChanged,
          string? plainPassword,
          ThTenantAdminCredentialEntity? existingCredential)
      {
          string passwordCipher;
          string passwordIv;
  
          if (passwordChanged)
          {
              var encrypted = _credentialCipher.EncryptPassword(plainPassword!);
              passwordCipher = encrypted.Password;
              passwordIv = encrypted.PasswordSalt;
          }
          else if (existingCredential != null
                   && !string.IsNullOrEmpty(existingCredential.PasswordCipher)
                   && !string.IsNullOrEmpty(existingCredential.PasswordIv))
          {
              passwordCipher = existingCredential.PasswordCipher;
              passwordIv = existingCredential.PasswordIv;
          }
          else
          {
              var encrypted = _credentialCipher.EncryptPassword(_rbacOptions.AdminPassword ?? string.Empty);
              passwordCipher = encrypted.Password;
              passwordIv = encrypted.PasswordSalt;
          }
  
          using (UseHostTenantScope())
          {
              var now = DateTime.Now;
              // 使用 Ado 参数化写入，避免实体映射差异导致 Insertable NRE
              if (existingCredential == null)
              {
                  await _credentialRepository._Db.Ado.ExecuteCommandAsync(
                      @"INSERT INTO `fl_th_tenant_admin_credential`
                          (`TenantId`, `LoginAccount`, `PasswordCipher`, `PasswordIv`, `LastModificationTime`)
                        VALUES (@TenantId, @LoginAccount, @PasswordCipher, @PasswordIv, @LastModificationTime)",
                      new List<SugarParameter>
                      {
                          new("@TenantId", tenantId.ToString()),
                          new("@LoginAccount", loginAccount),
                          new("@PasswordCipher", passwordCipher),
                          new("@PasswordIv", passwordIv),
                          new("@LastModificationTime", now)
                      });
                  return;
              }
  
              await _credentialRepository._Db.Ado.ExecuteCommandAsync(
                  @"UPDATE `fl_th_tenant_admin_credential`
                    SET `LoginAccount` = @LoginAccount,
                        `PasswordCipher` = @PasswordCipher,
                        `PasswordIv` = @PasswordIv,
                        `LastModificationTime` = @LastModificationTime
                    WHERE `TenantId` = @TenantId",
                  new List<SugarParameter>

                  {

                      new("@TenantId", tenantId.ToString()),
                      new("@LoginAccount", loginAccount),
                      new("@PasswordCipher", passwordCipher),
                      new("@PasswordIv", passwordIv),
                      new("@LastModificationTime", now)
                  });
          }
      }

      private async Task<TenantAggregateRoot> EnsureTenantExistsAsync(Guid tenantId)
      {
          if (tenantId == Guid.Empty)
          {
              throw new UserFriendlyException("租户 Id 不能为空");
          }

          using (UseHostTenantScope())
          {
              return await _tenantRepository.FindAsync(tenantId)
                     ?? throw new UserFriendlyException("租户不存在");
          }
      }

      /// <summary>
      /// 解析租户业务库连接串（必要时按配置回填主库 YiTenant），供直连 SqlSugar 使用。
      /// </summary>
      private Task<(string ConnectionString, DbType DbType)> ResolveTenantBusinessConnectionAsync(
          TenantAggregateRoot tenant)
      {
          return TenantBusinessDatabaseAccessor.ResolveConnectionAsync(
              tenant,
              _tenantDatabaseOptions,
              PersistTenantConnectionStringAsync);
      }

      private async Task PersistTenantConnectionStringAsync(TenantAggregateRoot tenant)
      {
          using (UseHostTenantScope())
          {
              await _tenantRepository.UpdateAsync(tenant);
          }
      }

      private async Task<List<string>> LoadMenuPermissionKeysAsync(Guid tenantId)
      {
          using (UseHostTenantScope())
          {
              return await _menuPermissionRepository._DbQueryable
                  .Where(x => x.TenantId == tenantId)
                  .OrderBy(x => x.CreationTime)
                  .Select(x => x.PermissionKey)
                  .ToListAsync();
          }
      }

      private async Task<Dictionary<Guid, List<string>>> LoadMenuPermissionMapAsync(
          IReadOnlyCollection<Guid> tenantIds)
      {
          if (tenantIds.Count == 0)
          {
              return new Dictionary<Guid, List<string>>();
          }

          using (UseHostTenantScope())
          {
              var list = await _menuPermissionRepository._DbQueryable
                  .Where(x => tenantIds.Contains(x.TenantId))
                  .ToListAsync();
  
              return list
                  .GroupBy(x => x.TenantId)
                  .ToDictionary(
                      g => g.Key,
                      g => g.Select(x => x.PermissionKey).Distinct(StringComparer.OrdinalIgnoreCase).ToList());
          }
      }

      private static List<string> NormalizePermissionKeys(IEnumerable<string>? keys)
      {
          if (keys == null)
          {
              return new List<string>();
          }

          return keys
              .Where(x => !string.IsNullOrWhiteSpace(x))
              .Select(x => x.Trim())
              .Distinct(StringComparer.OrdinalIgnoreCase)

              .ToList();

      }
  

      private static List<Guid> ParseMenuIds(IEnumerable<string>? menuIds)
      {
          if (menuIds == null)
          {
              return new List<Guid>();
          }

          var result = new List<Guid>();
          var invalid = new List<string>();

          foreach (var raw in menuIds.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x.Trim()).Distinct())
          {
              if (Guid.TryParse(raw, out var id))
              {
                  result.Add(id);
              }
              else
              {
                  invalid.Add(raw);
              }
          }