1

杨鑫
2 parents 5fe058a8 0a93339e
Showing 239 changed files with 14786 additions and 1727 deletions
泰额版/Food Labeling Management Code/Yi.Abp.Net8/framework/Yi.Framework.SqlSugarCore/SqlSugarDbContextFactory.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/AuthSession/CurrentUserBriefDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/AuthSession/CurrentUserMenuPermissionsOutputDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Common/ITrainingFileScopeInput.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Label/LabelBatchCreateItemInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Label/LabelCreateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Label/LabelGetOutputDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Label/LabelUpdateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelAlertTimer/LabelAlertTimerCheckExpiredInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelAlertTimer/LabelAlertTimerCheckExpiredOutputDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelAlertTimer/LabelAlertTimerGetListInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelAlertTimer/LabelAlertTimerListItemDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelCategory/LabelCategoryCreateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelMultipleOption/LabelMultipleOptionCreateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/LabelType/LabelTypeCreateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Product/ProductBatchImportOnlineInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Product/ProductBatchImportOnlineResultDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Product/ProductCreateInputVo.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/Product/ProductGetOutputDto.cs
泰额版/Food Labeling Management Code/Yi.Abp.Net8/module/food-labeling-us/FoodLabeling.Application.Contracts/Dtos/ProductCategory/ProductCategoryCreateInputVo.cs
@@ -21,10 +21,13 @@ namespace Yi.Framework.SqlSugarCore
     {
         #region Properties
  
+        private ISqlSugarClient? _sqlSugarClient;
+        private readonly object _clientLock = new();
+
         /// <summary>
-        /// SqlSugar客户端实例
+        /// SqlSugar 客户端（延迟按当前租户解析连接串，避免构造时 CurrentTenant 尚未就绪落到 host 库）
         /// </summary>
-        public ISqlSugarClient SqlSugarClient { get; private set; }
+        public ISqlSugarClient SqlSugarClient => GetOrCreateClient();
  
         /// <summary>
         /// 延迟服务提供者
@@ -75,22 +78,62 @@ namespace Yi.Framework.SqlSugarCore
         public SqlSugarDbContextFactory(IAbpLazyServiceProvider lazyServiceProvider)
         {
             LazyServiceProvider = lazyServiceProvider;
+        }
  
-            // 异步获取租户配置
-            var tenantConfiguration = AsyncHelper.RunSync(async () => await TenantConfigurationWrapper.GetAsync());
-           
-            // 构建数据库连接配置
-            var connectionConfig = BuildConnectionConfig(options =>
+        private ISqlSugarClient GetOrCreateClient()
+        {
+            // 必须每次按当前租户解析连接串：MultiTenancyMiddleware 查 YiTenant 时会先 Change(null)
+            // 创建主库客户端；若缓存不切换，后续业务会误连 host。
+            var tenantConfiguration =
+                AsyncHelper.RunSync(async () => await TenantConfigurationWrapper.GetAsync());
+            var connectionString = tenantConfiguration.GetCurrentConnectionString();
+            var dbType = GetCurrentDbType(tenantConfiguration.GetCurrentConnectionName());
+
+            if (_sqlSugarClient is not null &&
+                string.Equals(
+                    _sqlSugarClient.CurrentConnectionConfig?.ConnectionString,
+                    connectionString,
+                    StringComparison.Ordinal))
             {
-                options.ConnectionString = tenantConfiguration.GetCurrentConnectionString();
-                options.DbType = GetCurrentDbType(tenantConfiguration.GetCurrentConnectionName());
-            });
+                return _sqlSugarClient;
+            }
  
-            // 创建SqlSugar客户端实例
-            SqlSugarClient = new SqlSugarClient(connectionConfig);
+            lock (_clientLock)
+            {
+                if (_sqlSugarClient is not null &&
+                    string.Equals(
+                        _sqlSugarClient.CurrentConnectionConfig?.ConnectionString,
+                        connectionString,
+                        StringComparison.Ordinal))
+                {
+                    return _sqlSugarClient;
+                }
  
-            // 配置数据库AOP
-            ConfigureDbAop(SqlSugarClient);
+                if (_sqlSugarClient is not null)
+                {
+                    try
+                    {
+                        _sqlSugarClient.Dispose();
+                    }
+                    catch
+                    {
+                        // ignore dispose race
+                    }
+
+                    _sqlSugarClient = null;
+                }
+
+                var connectionConfig = BuildConnectionConfig(options =>
+                {
+                    options.ConnectionString = connectionString;
+                    options.DbType = dbType;
+                });
+
+                var client = new SqlSugarClient(connectionConfig);
+                ConfigureDbAop(client);
+                _sqlSugarClient = client;
+                return _sqlSugarClient;
+            }
         }
  
         /// <summary>
@@ -5,6 +5,9 @@ namespace FoodLabeling.Application.Contracts.Dtos.AuthSession;
 /// </summary>
 public class CurrentUserBriefDto
 {
+    /// <summary>
+    /// 当前登录用户 Id（非租户 Id）。
+    /// </summary>
     public Guid Id { get; set; }
  
     public string UserName { get; set; } = string.Empty;
@@ -5,6 +5,11 @@ namespace FoodLabeling.Application.Contracts.Dtos.AuthSession;
 /// </summary>
 public class CurrentUserMenuPermissionsOutputDto
 {
+    /// <summary>
+    /// 当前登录用户 Id（JSON: <c>userId</c>）。与 <see cref="User"/>.<see cref="CurrentUserBriefDto.Id"/> 一致，非租户 Id。
+    /// </summary>
+    public Guid UserId { get; set; }
+
     public CurrentUserBriefDto User { get; set; } = new();
  
     public List<string> RoleCodes { get; set; } = new();
+namespace FoodLabeling.Application.Contracts.Dtos.Common;
+
+/// <summary>
+/// 培训文件创建/编辑入参中的 Company / Region / Location 适用范围字段。
+/// </summary>
+public interface ITrainingFileScopeInput : ILabelEntityPartnerScopeInput
+{
+    /// <summary>适用 Region：ALL / SPECIFIED</summary>
+    string? AppliedRegionType { get; }
+
+    /// <summary>适用 Region（<c>fl_group.Id</c>）；与 <see cref="GroupIds"/> 合并；可含 <c>ALL</c></summary>
+    List<string>? RegionIds { get; }
+
+    /// <summary>与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c></summary>
+    List<string>? GroupIds { get; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED（与 <see cref="AppliedLocationType"/> 二选一）</summary>
+    string? AvailabilityType { get; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED（<see cref="AvailabilityType"/> 别名）</summary>
+    string? AppliedLocationType { get; }
+
+    /// <summary>适用门店（<c>location.Id</c>）；可含 <c>ALL</c></summary>
+    List<string>? LocationIds { get; }
+}
@@ -13,6 +13,9 @@ public class LabelBatchCreateItemInputVo
  
     public List<string>? PartnerIds { get; set; }
  
+    /// <summary>适用 Company（单选）</summary>
+    public List<string>? CompanyIds { get; set; }
+
     public string? AppliedRegionType { get; set; }
  
     public List<string>? RegionIds { get; set; }
@@ -2,6 +2,7 @@ namespace FoodLabeling.Application.Contracts.Dtos.Label;
  
 public class LabelCreateInputVo
 {
+    /// <summary>标签编码（可选；未传或空字符串时由后端自动生成唯一编码）</summary>
     public string? LabelCode { get; set; }
  
     public string LabelName { get; set; } = string.Empty;
@@ -9,32 +10,38 @@ public class LabelCreateInputVo
     public string TemplateCode { get; set; } = string.Empty;
  
     /// <summary>
-    /// 适用 Company（<c>fl_partner.Id</c>）；与 <see cref="PartnerIds"/> 合并，用于解析所属门店
+    /// 适用 Company（<c>fl_partner.Id</c>）；与 <see cref="PartnerIds"/> / <see cref="CompanyIds"/> 合并，单选
     /// </summary>
     public string? PartnerId { get; set; }
  
     /// <summary>
-    /// 适用 Company 多选（<c>fl_partner.Id</c>）
+    /// 适用 Company 多选字段（仅支持 1 个；与 <see cref="CompanyIds"/> 相同）
     /// </summary>
     public List<string>? PartnerIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 范围：<c>ALL</c>（全选）/ <c>SPECIFIED</c>（按 <see cref="RegionIds"/>）。传了有效 regionIds 时按 SPECIFIED 处理。
+    /// 适用 Company（单选，<c>fl_partner.Id</c>）；与 <see cref="PartnerId"/> / <see cref="PartnerIds"/> 合并
+    /// </summary>
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>
+    /// 适用 Region 范围：<c>ALL</c> / <c>SPECIFIED</c>。
+    /// 亦可在 <see cref="RegionIds"/> / <see cref="LocationIds"/> 传哨兵 <c>["ALL"]</c>（即使本字段为 SPECIFIED 亦归档 ALL；POST/PUT 均支持）。
     /// </summary>
     public string? AppliedRegionType { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（<c>fl_group.Id</c>）；与 <see cref="GroupIds"/> 合并，落库 <c>fl_label_region</c>
+    /// 适用 Region 多选（<c>fl_group.Id</c>）；与 <see cref="GroupIds"/> 合并；可含 <c>ALL</c>
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）
+    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）；可含 <c>ALL</c>
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店 Id 数组（<c>location.Id</c>，落库 <c>fl_label_location</c>）；主字段
+    /// 适用门店 Id 数组（<c>location.Id</c>）；可含 <c>ALL</c>；落库 <c>fl_label_location</c>
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
@@ -17,11 +17,14 @@ public class LabelGetOutputDto
  
     public string LocationName { get; set; } = string.Empty;
  
-    /// <summary>适用 Company Id（由所属门店反推）</summary>
+    /// <summary>适用 Company Id（单选；优先落库 <c>fl_label.PartnerId</c>）</summary>
     public string? PartnerId { get; set; }
  
     public List<string> PartnerIds { get; set; } = new();
  
+    /// <summary>与 <see cref="PartnerIds"/> 相同（兼容字段，单选）</summary>
+    public List<string> CompanyIds { get; set; } = new();
+
     /// <summary>适用 Region 范围：ALL / SPECIFIED</summary>
     public string AppliedRegionType { get; set; } = "SPECIFIED";
  
@@ -10,17 +10,23 @@ public class LabelUpdateInputVo
  
     public List<string>? PartnerIds { get; set; }
  
+    /// <summary>适用 Company（单选）；与 <see cref="PartnerId"/> / <see cref="PartnerIds"/> 合并</summary>
+    public List<string>? CompanyIds { get; set; }
+
     /// <summary>
-    /// 适用 Region 范围：<c>ALL</c> / <c>SPECIFIED</c>（见 <see cref="RegionIds"/>）
+    /// 适用 Region 范围：<c>ALL</c> / <c>SPECIFIED</c>。
+    /// 亦可在 <see cref="RegionIds"/> / <see cref="LocationIds"/> 传哨兵 <c>["ALL"]</c>（与新增一致，PUT 支持）。
     /// </summary>
     public string? AppliedRegionType { get; set; }
  
+    /// <summary>适用 Region 多选；可含 <c>ALL</c></summary>
     public List<string>? RegionIds { get; set; }
  
+    /// <summary>与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c></summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店 Id 数组（<c>location.Id</c>，落库 <c>fl_label_location</c>）；主字段，全量覆盖
+    /// 适用门店 Id 数组；可含 <c>ALL</c>；落库 <c>fl_label_location</c>，全量覆盖
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
+namespace FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+
+/// <summary>
+/// 检查告警计时器是否过期入参（至少提供一个标识）
+/// </summary>
+public class LabelAlertTimerCheckExpiredInputVo
+{
+    public string? TimerId { get; set; }
+
+    public string? BatchId { get; set; }
+
+    public string? PrintTaskId { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+
+/// <summary>
+/// 检查告警计时器是否过期出参
+/// </summary>
+public class LabelAlertTimerCheckExpiredOutputDto
+{
+    /// <summary>是否找到计时器记录</summary>
+    public bool Found { get; set; }
+
+    /// <summary>是否已过期；无记录时为 false（仅展示用，不用于拦截打印）</summary>
+    public bool IsExpired { get; set; }
+
+    public DateTime? ExpiresAt { get; set; }
+
+    /// <summary>剩余秒数（已过期为 0）</summary>
+    public int RemainingSeconds { get; set; }
+
+    /// <summary>状态：<c>expired</c> 或 <c>running</c></summary>
+    public string? Status { get; set; }
+
+    public string? Title { get; set; }
+
+    public string? Subtitle { get; set; }
+
+    public string? TimerId { get; set; }
+
+    public string? BatchId { get; set; }
+}
+using Volo.Abp.Application.Dtos;
+
+namespace FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+
+/// <summary>
+/// 告警计时器分页列表入参
+/// </summary>
+public class LabelAlertTimerGetListInputVo : PagedAndSortedResultRequestDto
+{
+    /// <summary>
+    /// 当前门店 Id（location.Id，Guid 字符串）。
+    /// <c>list</c> 必填；<c>app-list</c> 可空（空则取已选门店缓存）。
+    /// </summary>
+    public string? LocationId { get; set; }
+
+    /// <summary>
+    /// 打印日期（<c>yyyy-MM-dd</c>）；按 PrintedAt 筛选该日记录。
+    /// </summary>
+    public string? DateDay { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+
+/// <summary>
+/// 告警计时器列表项
+/// </summary>
+public class LabelAlertTimerListItemDto
+{
+    public string Id { get; set; } = string.Empty;
+
+    public string BatchId { get; set; } = string.Empty;
+
+    public string PrintTaskId { get; set; } = string.Empty;
+
+    public string LabelId { get; set; } = string.Empty;
+
+    public string? LabelCode { get; set; }
+
+    public string Title { get; set; } = string.Empty;
+
+    public string Subtitle { get; set; } = string.Empty;
+
+    /// <summary>总时长（秒），同 DurationSeconds</summary>
+    public int TotalTime { get; set; }
+
+    /// <summary>剩余时长（秒）</summary>
+    public int RemainingTime { get; set; }
+
+    /// <summary>状态：<c>expired</c> 或 <c>running</c></summary>
+    public string Status { get; set; } = string.Empty;
+
+    public DateTime ExpiresAt { get; set; }
+
+    public DateTime PrintedAt { get; set; }
+
+    public string LocationId { get; set; } = string.Empty;
+
+    public string? ProductName { get; set; }
+}
@@ -4,7 +4,8 @@ namespace FoodLabeling.Application.Contracts.Dtos.LabelCategory;
  
 public class LabelCategoryCreateInputVo : ILabelEntityPartnerScopeInput
 {
-    public string CategoryCode { get; set; } = string.Empty;
+    /// <summary>分类编码（可选；未传或空字符串时由后端自动生成唯一编码）</summary>
+    public string? CategoryCode { get; set; }
  
     public string CategoryName { get; set; } = string.Empty;
  
@@ -37,25 +38,28 @@ public class LabelCategoryCreateInputVo : ILabelEntityPartnerScopeInput
     public List<string>? CompanyIds { get; set; }
  
     /// <summary>
-    /// 门店可用范围：ALL / SPECIFIED
+    /// 门店可用范围：ALL / SPECIFIED。
+    /// <c>regionIds</c>/<c>groupIds</c>/<c>locationIds</c> 可传哨兵 <c>["ALL"]</c>（大小写不敏感）；
+    /// 即使本字段为 SPECIFIED，Id 数组为 ALL 时仍归档为 ALL（POST/PUT 均支持）。
     /// </summary>
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
-    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重
+    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重；可含 <c>ALL</c>
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同
+    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c>
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店（多选），<c>location.Id</c>；与 Region 合并后写入 <c>fl_label_category_location</c>
+    /// 适用门店（多选），<c>location.Id</c>；可含 <c>ALL</c>；与 Region 合并后写入 <c>fl_label_category_location</c>
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
-    public int OrderNum { get; set; }
+    /// <summary>排序；未传或 null 时默认 0</summary>
+    public int? OrderNum { get; set; }
 }
  
@@ -4,7 +4,7 @@ namespace FoodLabeling.Application.Contracts.Dtos.LabelMultipleOption;
  
 public class LabelMultipleOptionCreateInputVo : ILabelEntityPartnerScopeInput
 {
-    /// <summary>多选项编码（可选；未传或空字符串时存空，列表/详情出参为「无」）</summary>
+    /// <summary>多选项编码（可选；未传或空字符串时由后端自动生成唯一编码）</summary>
     public string? OptionCode { get; set; }
  
     public string OptionName { get; set; } = string.Empty;
@@ -25,25 +25,27 @@ public class LabelMultipleOptionCreateInputVo : ILabelEntityPartnerScopeInput
     public List<string>? CompanyIds { get; set; }
  
     /// <summary>
-    /// 门店可用范围：ALL / SPECIFIED；传了 <see cref="RegionIds"/> 或 <see cref="LocationIds"/> 时自动为 SPECIFIED
+    /// 门店可用范围：ALL / SPECIFIED；传了 <see cref="RegionIds"/> 或 <see cref="LocationIds"/> 时自动为 SPECIFIED。
+    /// Id 数组可传哨兵 <c>ALL</c>（POST/PUT 新增与编辑均支持），归档为 <c>availabilityType=ALL</c> 且不写门店快照。
     /// </summary>
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
-    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重
+    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重。可传 <c>ALL</c>。
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同
+    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同。可传 <c>ALL</c>。
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店（多选），<c>location.Id</c>；与 Region 合并后写入 <c>fl_label_multiple_option_location</c>
+    /// 适用门店（多选），<c>location.Id</c>；与 Region 合并后写入 <c>fl_label_multiple_option_location</c>。可传 <c>ALL</c>。
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
-    public int OrderNum { get; set; }
+    /// <summary>排序；未传或 null 时默认 0</summary>
+    public int? OrderNum { get; set; }
 }
  
@@ -4,7 +4,8 @@ namespace FoodLabeling.Application.Contracts.Dtos.LabelType;
  
 public class LabelTypeCreateInputVo : ILabelEntityPartnerScopeInput
 {
-    public string TypeCode { get; set; } = string.Empty;
+    /// <summary>类型编码；为空时由后端自动生成唯一编码</summary>
+    public string? TypeCode { get; set; }
  
     public string TypeName { get; set; } = string.Empty;
  
@@ -22,25 +23,28 @@ public class LabelTypeCreateInputVo : ILabelEntityPartnerScopeInput
     public List<string>? CompanyIds { get; set; }
  
     /// <summary>
-    /// 门店可用范围：ALL / SPECIFIED；传了 <see cref="RegionIds"/> 或 <see cref="LocationIds"/> 时自动为 SPECIFIED
+    /// 门店可用范围：ALL / SPECIFIED。
+    /// <c>regionIds</c>/<c>groupIds</c>/<c>locationIds</c> 可传哨兵 <c>["ALL"]</c>（大小写不敏感）；
+    /// 即使本字段为 SPECIFIED，Id 数组为 ALL 时仍归档为 ALL（POST/PUT 均支持）。
     /// </summary>
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
-    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重
+    /// 适用 Region（多选），<c>fl_group.Id</c>；与 <see cref="GroupIds"/> 合并去重；可含 <c>ALL</c>
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同
+    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c>
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店（多选），<c>location.Id</c>；与 Region 合并后写入 <c>fl_label_type_location</c>
+    /// 适用门店（多选），<c>location.Id</c>；可含 <c>ALL</c>；与 Region 合并后写入 <c>fl_label_type_location</c>
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
-    public int OrderNum { get; set; }
+    /// <summary>排序；未传或 null 时默认 0</summary>
+    public int? OrderNum { get; set; }
 }
  
+namespace FoodLabeling.Application.Contracts.Dtos.Product;
+
+/// <summary>
+/// 产品 JSON 在线批量导入请求体
+/// </summary>
+public class ProductBatchImportOnlineInputVo
+{
+    /// <summary>
+    /// 待导入行，每元素与单条 <c>POST /api/app/product</c> 的 <see cref="ProductCreateInputVo"/> 一致
+    /// </summary>
+    public List<ProductCreateInputVo> Items { get; set; } = new();
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Product;
+
+/// <summary>
+/// 产品 JSON 在线批量导入结果
+/// </summary>
+public class ProductBatchImportOnlineResultDto
+{
+    public int SuccessCount { get; set; }
+
+    public int FailCount { get; set; }
+
+    public List<ProductBatchImportOnlineErrorDto> Errors { get; set; } = new();
+}
+
+/// <summary>
+/// 产品 JSON 在线批量导入单条失败信息
+/// </summary>
+public class ProductBatchImportOnlineErrorDto
+{
+    /// <summary>
+    /// 在请求 <c>items</c> 数组中的序号（从 0 开始）
+    /// </summary>
+    public int Index { get; set; }
+
+    /// <summary>
+    /// 产品名称（<c>productName</c>），便于定位失败行
+    /// </summary>
+    public string? ProductName { get; set; }
+
+    public string Message { get; set; } = string.Empty;
+}
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
+using FoodLabeling.Application.Contracts.Json;
  
 namespace FoodLabeling.Application.Contracts.Dtos.Product;
  
@@ -35,18 +37,46 @@ public class ProductCreateInputVo
     public string? AvailabilityType { get; set; }
  
     /// <summary>
-    /// 适用 Company（<c>fl_partner.Id</c>，UI 称 Company）；展开该公司下全部门店后与 Region/门店合并写入 <c>fl_location_product</c>
+    /// 适用 Company：ALL / SPECIFIED（产品 Company 仅支持 SPECIFIED + 单选具体 Guid）。
     /// </summary>
+    public string? AppliedPartnerType { get; set; }
+
+    /// <summary>
+    /// 适用 Company（<c>fl_partner.Id</c>，UI 称 Company）；展开该公司下全部门店后与 Region/门店合并写入 <c>fl_location_product</c>。
+    /// 与 <see cref="CompanyIds"/> 二选一或同值；产品 Company <b>仅支持单选</b>，<b>不支持 ALL</b>。
+    /// 兼容前端误传数组：<c>"partnerId":["{guid}"]</c> 与字符串等价。
+    /// </summary>
+    [JsonConverter(typeof(StringOrFirstArrayItemJsonConverter))]
     public string? PartnerId { get; set; }
  
     /// <summary>
-    /// 适用 Region（<c>fl_group.Id</c>，UI 称 Region；库字段为 <c>location.GroupName</c>）
+    /// 适用 Company Id 列表（与 <see cref="CompanyIds"/> 同义，前端常用字段）。<b>仅支持单选</b>。
+    /// </summary>
+    public List<string>? PartnerIds { get; set; }
+
+    /// <summary>
+    /// 适用 Company（推荐前端字段）。<b>仅支持单选</b>：数组最多 1 个具体 Guid；<b>不支持 ALL</b>。
+    /// 传多个 Guid 或含 <c>ALL</c> 将报错；与 <see cref="PartnerId"/> 同时传时须一致。
+    /// </summary>
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>适用 Region：ALL / SPECIFIED（与 <see cref="AvailabilityType"/> 独立，用于前端显式声明）</summary>
+    public string? AppliedRegionType { get; set; }
+
+    /// <summary>
+    /// 适用 Region（<c>fl_group.Id</c>，UI 称 Region；库字段为 <c>location.GroupName</c>）。
+    /// 与 <see cref="RegionIds"/> 合并；含 <c>ALL</c> 且无具体门店时，有具体 Company 则展开该公司门店，否则归档全局 ALL。
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店 Id 列表；与 <see cref="GroupIds"/> 合并后写入 <c>fl_location_product</c>。
-    /// 不传则不在本接口写入门店关联。
+    /// 适用 Region（与 <see cref="GroupIds"/> 同义，前端常用字段）。
+    /// </summary>
+    public List<string>? RegionIds { get; set; }
+
+    /// <summary>
+    /// 适用门店 Id 列表。有具体 Guid 时以门店为准；含 <c>ALL</c> 且已指定 Company/Region 时表示该范围内全选（SPECIFIED 快照）；
+    /// 无具体 Company/Region 时归档全局 ALL。
     /// </summary>
     public List<string>? LocationIds { get; set; }
 }
@@ -29,17 +29,25 @@ public class ProductGetOutputDto
     /// <summary>适用门店：ALL / SPECIFIED</summary>
     public string AvailabilityType { get; set; } = "SPECIFIED";
  
-    /// <summary>适用 Company Id（<c>fl_partner.Id</c>，由关联门店反推；多公司时取第一个）</summary>
+    /// <summary>适用 Company Id（<c>fl_partner.Id</c>，由关联门店反推；多公司时取第一个；ALL 时为 null）</summary>
     public string? PartnerId { get; set; }
  
-    /// <summary>适用 Company Id 列表（去重）</summary>
+    /// <summary>适用 Company Id 列表（去重；历史数据可能多条）</summary>
     public List<string> PartnerIds { get; set; } = new();
  
+    /// <summary>
+    /// 适用 Company（与编辑入参对齐）。单选：0～1 个具体 Guid；不支持 ALL。
+    /// </summary>
+    public List<string> CompanyIds { get; set; } = new();
+
     /// <summary>适用 Region Id（<c>fl_group.Id</c>，由关联门店反推）</summary>
     public List<string> GroupIds { get; set; } = new();
  
+    /// <summary>适用 Region（与 <see cref="GroupIds"/> 同义）</summary>
+    public List<string> RegionIds { get; set; } = new();
+
     /// <summary>
-    /// 适用门店 Id 列表（来自 fl_location_product）
+    /// 适用门店 Id 列表（来自 fl_location_product；覆盖 Region 全集时可折叠为 <c>["ALL"]</c>）
     /// </summary>
     public List<string> LocationIds { get; set; } = new();
 }
 namespace FoodLabeling.Application.Contracts.Dtos.ProductCategory;
  
+using FoodLabeling.Application.Contracts.Dtos.Common;
+
 /// <summary>
 /// 产品模块：新增类别入参
 /// </summary>
-public class ProductCategoryCreateInputVo
+public class ProductCategoryCreateInputVo : ILabelEntityPartnerScopeInput
 {
-    /// <summary>
-    /// 类别编码（可选，不传或空字符串表示无编码）
-    /// </summary>
+    /// <summary>类别编码（可选；未传或空字符串时由后端自动生成唯一编码）</summary>
     public string? CategoryCode { get; set; }
  
     public string CategoryName { get; set; } = string.Empty;
@@ -30,25 +30,40 @@ public class ProductCategoryCreateInputVo
     public bool State { get; set; } = true;
  
     /// <summary>
-    /// 门店可用范围：ALL / SPECIFIED
+    /// 适用 Company：ALL / SPECIFIED。
+    /// <c>partnerIds</c>/<c>companyIds</c> 可传哨兵 <c>["ALL"]</c>（大小写不敏感）。
+    /// </summary>
+    public string? AppliedPartnerType { get; set; }
+
+    /// <summary>适用 Company（<c>fl_partner.Id</c>）</summary>
+    public List<string>? PartnerIds { get; set; }
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同（兼容字段）</summary>
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>
+    /// 门店可用范围：ALL / SPECIFIED。
+    /// <c>regionIds</c>/<c>groupIds</c>/<c>locationIds</c> 可传哨兵 <c>["ALL"]</c>（大小写不敏感）；
+    /// 即使本字段为 SPECIFIED，Id 数组为 ALL 时仍归档为 ALL（POST/PUT 均支持）。
     /// </summary>
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
-    /// 适用 Region（**多选**），<c>fl_group.Id</c> 数组；与 <see cref="GroupIds"/> 等价，推荐本字段。
+    /// 适用 Region（**多选**），<c>fl_group.Id</c>；可含 <c>ALL</c>；与 <see cref="GroupIds"/> 合并去重。
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同；传任一会合并去重。
+    /// 适用 Region（多选），与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c>。
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店（**多选**），<c>location.Id</c> 数组；与 Region 合并后写入 <c>fl_product_category_location</c>。
+    /// 适用门店（**多选**），<c>location.Id</c>；可含 <c>ALL</c>；与 Region 合并后写入 <c>fl_product_category_location</c>。
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
-    public int OrderNum { get; set; } = 0;
+    /// <summary>排序；未传或 null 时默认 0</summary>
+    public int? OrderNum { get; set; }
 }
  
@@ -21,6 +21,16 @@ public class ProductCategoryGetListOutputDto
  
     public string AvailabilityType { get; set; } = "ALL";
  
+    public string AppliedPartnerType { get; set; } = "ALL";
+
+    /// <summary>适用 Company 展示</summary>
+    public string Company { get; set; } = string.Empty;
+
+    public List<string> PartnerIds { get; set; } = new();
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同</summary>
+    public List<string> CompanyIds { get; set; } = new();
+
     public int OrderNum { get; set; }
  
     public DateTime LastEdited { get; set; }
@@ -22,6 +22,16 @@ public class ProductCategoryGetOutputDto
  
     public string AvailabilityType { get; set; } = "ALL";
  
+    public string AppliedPartnerType { get; set; } = "ALL";
+
+    /// <summary>列表/详情 Company 展示</summary>
+    public string Company { get; set; } = string.Empty;
+
+    public List<string> PartnerIds { get; set; } = new();
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同</summary>
+    public List<string> CompanyIds { get; set; } = new();
+
     /// <summary>适用 Region Id 列表（多选，<c>fl_group.Id</c>；由绑定门店反推）</summary>
     public List<string> RegionIds { get; set; } = new();
  
@@ -9,6 +9,12 @@ namespace FoodLabeling.Application.Contracts.Dtos.ProductLocation;
 public class ProductLocationGetListInputVo : PagedAndSortedResultRequestDto
 {
     /// <summary>
+    /// Company Id（<c>fl_partner.Id</c>）；未传 <see cref="LocationId"/> 时按该公司下门店展开，
+    /// 并包含 <c>AvailabilityType=ALL</c> 的产品。
+    /// </summary>
+    public string? PartnerId { get; set; }
+
+    /// <summary>
     /// 门店Id（location.Id，string 表示）
     /// </summary>
     public string? LocationId { get; set; }
@@ -18,4 +24,3 @@ public class ProductLocationGetListInputVo : PagedAndSortedResultRequestDto
     /// </summary>
     public string? ProductId { get; set; }
 }
-
@@ -24,11 +24,16 @@ public class RbacRoleCreateInputVo
     public int? OrderNum { get; set; }
  
     /// <summary>
-    /// 绑定菜单 Id；与 accessPermissions 同时传时以本字段为准
+    /// 绑定菜单 Id；与 menuPermissionKeys / accessPermissions 同时传时以本字段为准
     /// </summary>
     public List<Guid>? MenuIds { get; set; }
  
     /// <summary>
+    /// 绑定菜单 Id（字符串 Guid 列表）；与 <see cref="MenuIds"/> 等价，<see cref="MenuIds"/> 优先
+    /// </summary>
+    public List<string>? MenuPermissionKeys { get; set; }
+
+    /// <summary>
     /// 按 PermissionCode 绑定菜单：JSON 数组字符串（如 <c>["manage_labels"]</c>）、英文逗号分隔；传空字符串表示清空绑定；不传则不修改已有绑定（仅编辑时）
     /// </summary>
     public string? AccessPermissions { get; set; }
@@ -28,5 +28,10 @@ public class RbacRoleGetListOutputDto
     /// 角色访问权限码列表（与库字段 AccessPermissionCodes 对应）
     /// </summary>
     public List<string> AccessPermissionCodes { get; set; } = new();
+
+    /// <summary>
+    /// 已绑定菜单 Id 列表（字符串 Guid，与前端 menuPermissionKeys 字段一致）
+    /// </summary>
+    public List<string> MenuPermissionKeys { get; set; } = new();
 }
  
+namespace FoodLabeling.Application.Contracts.Dtos.TeamMember;
+
+/// <summary>
+/// 成员 JSON 在线批量导入请求体
+/// </summary>
+public class TeamMemberBatchImportOnlineInputVo
+{
+    /// <summary>
+    /// 待导入行，每元素与单条 <c>POST /api/app/team-member</c> 的 <see cref="TeamMemberCreateInputVo"/> 一致
+    /// </summary>
+    public List<TeamMemberCreateInputVo> Items { get; set; } = new();
+}
+namespace FoodLabeling.Application.Contracts.Dtos.TeamMember;
+
+/// <summary>
+/// 成员 JSON 在线批量导入结果
+/// </summary>
+public class TeamMemberBatchImportOnlineResultDto
+{
+    public int SuccessCount { get; set; }
+
+    public int FailCount { get; set; }
+
+    public List<TeamMemberBatchImportOnlineErrorDto> Errors { get; set; } = new();
+}
+
+/// <summary>
+/// 成员 JSON 在线批量导入单条失败信息
+/// </summary>
+public class TeamMemberBatchImportOnlineErrorDto
+{
+    /// <summary>
+    /// 在请求 <c>items</c> 数组中的序号（从 0 开始）
+    /// </summary>
+    public int Index { get; set; }
+
+    /// <summary>
+    /// 登录账号（<c>userName</c>），便于定位失败行
+    /// </summary>
+    public string? UserName { get; set; }
+
+    public string Message { get; set; } = string.Empty;
+}
@@ -28,20 +28,28 @@ public class TeamMemberCreateInputVo
     public List<string>? PartnerIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（<c>fl_group.Id</c>）；Company Admin 仅传 Company 时可省略，后端自动绑定该公司下全部 Region 与门店
+    /// 适用 Region 多选（<c>fl_group.Id</c>）；可含 <c>ALL</c> 哨兵（大小写不敏感，与具体 Guid 同传时以 ALL 为准）。
+    /// Company Admin 仅传 Company 时可省略；<c>locationIds</c> 为空且含 ALL 时展开该公司全部 Region 下门店。
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）
+    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）；可含 <c>ALL</c>。
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店多选（<c>location.Id</c>）；Company Admin 仅传 Company 时可省略，与 Region 合并后写入 <c>userlocation</c>
+    /// 适用门店多选（<c>location.Id</c>）；可含 <c>ALL</c> 哨兵。
+    /// 有具体 Region 时展开该 Region 下门店；仅有 Company 时展开该公司全部门店。
+    /// Company Admin 仅传 Company 时可省略。
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
+    /// <summary>
+    /// 适用门店多选别名（与 <see cref="LocationIds"/> 合并解析）；可含 <c>ALL</c> 或门店 Guid。
+    /// </summary>
+    public List<string>? Locations { get; set; }
+
     public bool State { get; set; } = true;
 }
  
@@ -19,12 +19,13 @@ public class TeamMemberGetOutputDto
     /// <summary>适用 Company Id（多选，由绑定门店反推）</summary>
     public List<string> PartnerIds { get; set; } = new();
  
-    /// <summary>适用 Region Id（多选，<c>fl_group.Id</c>）</summary>
+    /// <summary>适用 Region Id（多选，<c>fl_group.Id</c>；覆盖该公司全部 Region 时回显 <c>["ALL"]</c>）</summary>
     public List<string> RegionIds { get; set; } = new();
  
     /// <summary>与 <see cref="RegionIds"/> 相同</summary>
     public List<string> GroupIds { get; set; } = new();
  
+    /// <summary>绑定门店 Id；覆盖该公司全部门店时回显 <c>["ALL"]</c>（库中仍存展开 Guid）</summary>
     public List<string> LocationIds { get; set; } = new();
  
     public List<TeamMemberAssignedLocationDto> AssignedLocations { get; set; } = new();
@@ -28,20 +28,26 @@ public class TeamMemberUpdateInputVo
     public List<string>? PartnerIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（<c>fl_group.Id</c>）；Company Admin 仅传 Company 时可省略
+    /// 适用 Region 多选（<c>fl_group.Id</c>）；可含 <c>ALL</c> 哨兵（大小写不敏感，与具体 Guid 同传时以 ALL 为准）。
     /// </summary>
     public List<string>? RegionIds { get; set; }
  
     /// <summary>
-    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）
+    /// 适用 Region 多选（与 <see cref="RegionIds"/> 相同）；可含 <c>ALL</c>。
     /// </summary>
     public List<string>? GroupIds { get; set; }
  
     /// <summary>
-    /// 适用门店多选（<c>location.Id</c>）；Company Admin 仅传 Company 时可省略
+    /// 适用门店多选（<c>location.Id</c>）；可含 <c>ALL</c> 哨兵。
+    /// 有具体 Region 时表示该 Region 下全部门店；仅有 Company 时按公司全部门店落库。
     /// </summary>
     public List<string>? LocationIds { get; set; }
  
+    /// <summary>
+    /// 适用门店多选别名（与 <see cref="LocationIds"/> 合并解析）；可含 <c>ALL</c> 或门店 Guid。
+    /// </summary>
+    public List<string>? Locations { get; set; }
+
     public bool State { get; set; } = true;
 }
  
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingCategoryCreateInputVo
+{
+    public string CategoryName { get; set; } = string.Empty;
+
+    /// <summary>空=一级分类；有值=二级分类</summary>
+    public string? ParentId { get; set; }
+
+    public int OrderNum { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingCategoryGetOutputDto
+{
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryName { get; set; } = string.Empty;
+
+    public string? ParentId { get; set; }
+
+    public int OrderNum { get; set; }
+
+    public DateTime CreationTime { get; set; }
+
+    public DateTime? LastModificationTime { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingCategoryTreeInputVo
+{
+    /// <summary>关键字（匹配分类名或文件名）</summary>
+    public string? Keyword { get; set; }
+
+    /// <summary>按门店筛选可见文件；不传则不过滤文件权限</summary>
+    public string? LocationId { get; set; }
+
+    /// <summary>是否包含文件列表，默认 true</summary>
+    public bool IncludeFiles { get; set; } = true;
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingCategoryTreeNodeDto
+{
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryName { get; set; } = string.Empty;
+
+    public string? ParentId { get; set; }
+
+    public int OrderNum { get; set; }
+
+    public List<TrainingCategoryTreeNodeDto> Children { get; set; } = new();
+
+    public List<TrainingFileDto> Files { get; set; } = new();
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingCategoryUpdateInputVo
+{
+    public string CategoryName { get; set; } = string.Empty;
+
+    public int OrderNum { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileDto
+{
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryId { get; set; } = string.Empty;
+
+    public string FileName { get; set; } = string.Empty;
+
+    public string FileUrl { get; set; } = string.Empty;
+
+    /// <summary>image / doc / other</summary>
+    public string FileType { get; set; } = "other";
+
+    public long FileSize { get; set; }
+
+    public int OrderNum { get; set; }
+
+    public string AppliedPartnerType { get; set; } = "ALL";
+
+    /// <summary>Company 展示（ALL 时为 All Companies）</summary>
+    public string Company { get; set; } = string.Empty;
+
+    public List<string> PartnerIds { get; set; } = new();
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同</summary>
+    public List<string> CompanyIds { get; set; } = new();
+
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    /// <summary>Region 展示</summary>
+    public string Region { get; set; } = string.Empty;
+
+    public List<string> RegionIds { get; set; } = new();
+
+    /// <summary>与 <see cref="RegionIds"/> 相同</summary>
+    public List<string> GroupIds { get; set; } = new();
+
+    public string AvailabilityType { get; set; } = "ALL";
+
+    /// <summary>Location 展示</summary>
+    public string Location { get; set; } = string.Empty;
+
+    public List<string> LocationIds { get; set; } = new();
+
+    public DateTime CreationTime { get; set; }
+
+    public DateTime? LastModificationTime { get; set; }
+}
+using FoodLabeling.Application.Contracts.Dtos.Common;
+
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileScopeInputVo : ITrainingFileScopeInput
+{
+    public string? AppliedPartnerType { get; set; }
+
+    public List<string>? PartnerIds { get; set; }
+
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>适用 Region：ALL / SPECIFIED</summary>
+    public string? AppliedRegionType { get; set; }
+
+    public List<string>? RegionIds { get; set; }
+
+    public List<string>? GroupIds { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED</summary>
+    public string? AvailabilityType { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED（<see cref="AvailabilityType"/> 别名）</summary>
+    public string? AppliedLocationType { get; set; }
+
+    public List<string>? LocationIds { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileScopeOutputDto
+{
+    public string AppliedPartnerType { get; set; } = "ALL";
+
+    public string Company { get; set; } = string.Empty;
+
+    public List<string> PartnerIds { get; set; } = new();
+
+    public List<string> CompanyIds { get; set; } = new();
+
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    public string Region { get; set; } = string.Empty;
+
+    public List<string> RegionIds { get; set; } = new();
+
+    public List<string> GroupIds { get; set; } = new();
+
+    public string AvailabilityType { get; set; } = "ALL";
+
+    public string Location { get; set; } = string.Empty;
+
+    public List<string> LocationIds { get; set; } = new();
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileSortInputVo
+{
+    public List<TrainingFileSortItemVo> Items { get; set; } = new();
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileSortItemVo
+{
+    public string Id { get; set; } = string.Empty;
+
+    public int OrderNum { get; set; }
+}
+using FoodLabeling.Application.Contracts.Dtos.Common;
+
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileUpdateInputVo : ITrainingFileScopeInput
+{
+    public string FileName { get; set; } = string.Empty;
+
+    public int OrderNum { get; set; }
+
+    /// <summary>适用 Company：ALL / SPECIFIED</summary>
+    public string? AppliedPartnerType { get; set; }
+
+    /// <summary>适用 Company（<c>fl_partner.Id</c>）；可含 <c>ALL</c></summary>
+    public List<string>? PartnerIds { get; set; }
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同；可含 <c>ALL</c></summary>
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>适用 Region：ALL / SPECIFIED</summary>
+    public string? AppliedRegionType { get; set; }
+
+    /// <summary>适用 Region（<c>fl_group.Id</c>）；与 <see cref="GroupIds"/> 合并；可含 <c>ALL</c></summary>
+    public List<string>? RegionIds { get; set; }
+
+    /// <summary>与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c></summary>
+    public List<string>? GroupIds { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED</summary>
+    public string? AvailabilityType { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED（<see cref="AvailabilityType"/> 别名）</summary>
+    public string? AppliedLocationType { get; set; }
+
+    /// <summary>适用门店（<c>location.Id</c>）；可含 <c>ALL</c></summary>
+    public List<string>? LocationIds { get; set; }
+}
+using FoodLabeling.Application.Contracts.Dtos.Common;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileUploadInputVo : ITrainingFileScopeInput
+{
+    [FromForm(Name = "file")]
+    public IFormFile File { get; set; } = default!;
+
+    [FromForm(Name = "categoryId")]
+    public string CategoryId { get; set; } = string.Empty;
+
+    [FromForm(Name = "orderNum")]
+    public int OrderNum { get; set; }
+
+    /// <summary>适用 Company：ALL / SPECIFIED</summary>
+    [FromForm(Name = "appliedPartnerType")]
+    public string? AppliedPartnerType { get; set; }
+
+    /// <summary>适用 Company（<c>fl_partner.Id</c>）；可含 <c>ALL</c></summary>
+    [FromForm(Name = "partnerIds")]
+    public List<string>? PartnerIds { get; set; }
+
+    /// <summary>与 <see cref="PartnerIds"/> 相同；可含 <c>ALL</c></summary>
+    [FromForm(Name = "companyIds")]
+    public List<string>? CompanyIds { get; set; }
+
+    /// <summary>适用 Region：ALL / SPECIFIED</summary>
+    [FromForm(Name = "appliedRegionType")]
+    public string? AppliedRegionType { get; set; }
+
+    /// <summary>适用 Region（<c>fl_group.Id</c>）；与 <see cref="GroupIds"/> 合并；可含 <c>ALL</c></summary>
+    [FromForm(Name = "regionIds")]
+    public List<string>? RegionIds { get; set; }
+
+    /// <summary>与 <see cref="RegionIds"/> 相同；可含 <c>ALL</c></summary>
+    [FromForm(Name = "groupIds")]
+    public List<string>? GroupIds { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED</summary>
+    [FromForm(Name = "availabilityType")]
+    public string? AvailabilityType { get; set; }
+
+    /// <summary>适用 Location：ALL / SPECIFIED（<see cref="AvailabilityType"/> 别名）</summary>
+    [FromForm(Name = "appliedLocationType")]
+    public string? AppliedLocationType { get; set; }
+
+    /// <summary>适用门店（<c>location.Id</c>）；可含 <c>ALL</c></summary>
+    [FromForm(Name = "locationIds")]
+    public List<string>? LocationIds { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class TrainingFileUploadOutputDto
+{
+    public string Id { get; set; } = string.Empty;
+
+    public string FileName { get; set; } = string.Empty;
+
+    public string FileUrl { get; set; } = string.Empty;
+
+    public string FileType { get; set; } = "other";
+
+    public long FileSize { get; set; }
+}
+namespace FoodLabeling.Application.Contracts.Dtos.Training;
+
+public class UsAppTrainingTreeInputVo
+{
+    public string LocationId { get; set; } = string.Empty;
+
+    public string? Keyword { get; set; }
+}
@@ -12,8 +12,11 @@ public interface IAuthSessionAppService : IApplicationService
     /// 获取当前登录用户的角色编码、权限码与可见菜单树
     /// </summary>
     /// <remarks>
-    /// 与框架 <c>UserManager.GetInfoAsync</c> 一致；用户名为 <c>admin</c> 时返回全部未删除菜单（与 <c>AccountService.GetVue3Router</c> 行为对齐）。
-    /// 返回体额外包含：<c>lastUpdated</c>（系统编辑全局时间戳，与任意写接口成功联动；无戳时回退用户 LastModificationTime）、<c>role</c>（角色展示名，多角色英文逗号拼接）、<c>fullName</c>（姓名优先，其次昵称、用户名）。
+    /// 非 SaaS（<c>EnabledSaasMultiTenancy=false</c>）且用户名为 <c>admin</c> 时返回全部未删除菜单（与 <c>AccountService.GetVue3Router</c> 行为对齐）。
+    /// SaaS 开启时：平台主库登录（JWT / <c>__tenant</c> 无业务租户 Id，含全 0）即使用户名为 <c>admin</c> 也仅返回平台菜单
+    /// （<c>PermissionCode</c> 以 <c>menu.platform</c> 开头或 <c>Router</c> 以 <c>/platform</c> 开头，含祖先节点以成树）；
+    /// 公司业务租户登录时即使用户名为 <c>admin</c> 也按 RoleMenu 关联查询，与 <c>UpdateCompanyMenus</c> 同步的管理员菜单权限一致。
+    /// 返回体额外包含：<c>userId</c>（当前登录用户 Id，与 <c>user.id</c> 一致，非租户 Id）、<c>lastUpdated</c>（系统编辑全局时间戳，与任意写接口成功联动；无戳时回退用户 LastModificationTime）、<c>role</c>（角色展示名，多角色英文逗号拼接）、<c>fullName</c>（姓名优先，其次昵称、用户名）。
     /// 角色名通过 <c>Role</c> 表直查（<c>RoleDbEntity</c>），避免走仓储 IDataPermission。
     /// </remarks>
     /// <returns>用户简要信息、权限码与菜单树</returns>
+using FoodLabeling.Application.Contracts.Dtos.Common;
+using FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+using Volo.Abp.Application.Services;
+
+namespace FoodLabeling.Application.Contracts.IServices;
+
+/// <summary>
+/// 标签告警计时器（App）
+/// </summary>
+public interface ILabelAlertTimerAppService : IApplicationService
+{
+    Task<PagedResultWithPageDto<LabelAlertTimerListItemDto>> GetListAsync(LabelAlertTimerGetListInputVo input);
+
+    /// <summary>
+    /// App：当前账号当前门店告警列表（含倒计时；locationId 可省略，走已选门店缓存）
+    /// </summary>
+    Task<PagedResultWithPageDto<LabelAlertTimerListItemDto>> GetAppListAsync(LabelAlertTimerGetListInputVo input);
+
+    Task DeleteAsync(string id);
+
+    Task<LabelAlertTimerCheckExpiredOutputDto> CheckExpiredAsync(LabelAlertTimerCheckExpiredInputVo input);
+}
@@ -21,7 +21,8 @@ public interface ILabelAppService : IApplicationService
     Task<LabelGetOutputDto> GetAsync(string id);
  
     /// <summary>
-    /// 新增标签。Body 支持 <c>appliedRegionType</c>（ALL/SPECIFIED）、<c>regionIds</c> / <c>groupIds</c>（落库 <c>fl_label_region</c>）、<c>locationIds</c>（主字段，落库 <c>fl_label_location</c>）；<c>locationId</c> 与 <c>locationIds</c> 合并；<c>labelTypeId</c> 可选。
+    /// 新增标签。Body 支持 <c>appliedRegionType</c>（ALL/SPECIFIED）、
+    /// <c>regionIds</c> / <c>groupIds</c> / <c>locationIds</c>（可含哨兵 <c>ALL</c>，归档为 AppliedRegionType=ALL）。
     /// </summary>
     Task<LabelGetOutputDto> CreateAsync(LabelCreateInputVo input);
  
@@ -31,7 +32,7 @@ public interface ILabelAppService : IApplicationService
     Task<LabelBatchCreateResultDto> BatchCreateAsync(LabelBatchCreateInputVo input);
  
     /// <summary>
-    /// 编辑标签（id=LabelCode）。适用 Region / 门店字段同 <see cref="CreateAsync"/>。
+    /// 编辑标签（id=LabelCode）。范围传参与 <see cref="CreateAsync"/> 一致，支持 Id 数组传 <c>ALL</c>。
     /// </summary>
     Task<LabelGetOutputDto> UpdateAsync(string id, LabelUpdateInputVo input);
  
@@ -9,8 +9,10 @@ public interface ILabelCategoryAppService
  
     Task<LabelCategoryGetOutputDto> GetAsync(string id);
  
+    /// <summary>新增标签分类；<c>regionIds</c>/<c>groupIds</c>/<c>locationIds</c> 支持哨兵 <c>ALL</c>。</summary>
     Task<LabelCategoryGetOutputDto> CreateAsync(LabelCategoryCreateInputVo input);
  
+    /// <summary>编辑标签分类；范围传参与新增一致，支持 <c>ALL</c>。</summary>
     Task<LabelCategoryGetOutputDto> UpdateAsync(string id, LabelCategoryUpdateInputVo input);
  
     Task DeleteAsync(string id);
@@ -9,8 +9,14 @@ public interface ILabelMultipleOptionAppService
  
     Task<LabelMultipleOptionGetOutputDto> GetAsync(string id);
  
+    /// <summary>
+    /// 新增多选项；<c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c> 可传 <c>ALL</c> 哨兵（POST）。
+    /// </summary>
     Task<LabelMultipleOptionGetOutputDto> CreateAsync(LabelMultipleOptionCreateInputVo input);
  
+    /// <summary>
+    /// 编辑多选项；适用范围与新增相同，<c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c> 可传 <c>ALL</c>（PUT）。
+    /// </summary>
     Task<LabelMultipleOptionGetOutputDto> UpdateAsync(string id, LabelMultipleOptionUpdateInputVo input);
  
     Task DeleteAsync(string id);
@@ -25,12 +25,14 @@ public interface ILabelTemplateAppService : IApplicationService
  
     /// <summary>
     /// 新增标签模板；body 支持 Company/Region/Location 三维范围（各维度 ALL/SPECIFIED + Id 数组）。
+    /// <c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c>、<c>appliedLocationIds</c> 可传 <c>ALL</c> 哨兵（POST）。
     /// </summary>
     Task<LabelTemplateGetOutputDto> CreateAsync(LabelTemplateCreateInputVo input);
  
     /// <summary>
     /// 编辑标签模板（版本号 +1，重建 elements）；适用范围多选规则同新增。
     /// body 支持 <c>printOrientation</c>（<c>vertical</c> / <c>horizontal</c>，横打不交换 Width/Height）。
+    /// <c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c>、<c>appliedLocationIds</c> 可传 <c>ALL</c> 哨兵（PUT）。
     /// </summary>
     Task<LabelTemplateGetOutputDto> UpdateAsync(string id, LabelTemplateUpdateInputVo input);
  
@@ -9,8 +9,10 @@ public interface ILabelTypeAppService
  
     Task<LabelTypeGetOutputDto> GetAsync(string id);
  
+    /// <summary>新增标签类型；<c>regionIds</c>/<c>groupIds</c>/<c>locationIds</c> 支持哨兵 <c>ALL</c>。</summary>
     Task<LabelTypeGetOutputDto> CreateAsync(LabelTypeCreateInputVo input);
  
+    /// <summary>编辑标签类型；范围传参与新增一致，支持 <c>ALL</c>。</summary>
     Task<LabelTypeGetOutputDto> UpdateAsync(string id, LabelTypeUpdateInputVo input);
  
     Task DeleteAsync(string id);
@@ -32,8 +32,10 @@ public interface IProductAppService : IApplicationService
     /// </summary>
     /// <remarks>
     /// <see cref="ProductCreateInputVo.ProductCode"/> 可选；为空时后端生成唯一编码（如 PRD_ + Guid）。
-    /// 若传 <see cref="ProductCreateInputVo.PartnerId"/>（Company）、<see cref="ProductCreateInputVo.GroupIds"/>（Region）
-    /// 和/或 <see cref="ProductCreateInputVo.LocationIds"/>，合并后写入 fl_location_product。
+    /// Company 传 <see cref="ProductCreateInputVo.CompanyIds"/>（推荐，仅单选具体 Guid，<b>不支持 ALL</b>）
+    /// 或 <see cref="ProductCreateInputVo.PartnerId"/>；
+    /// 再与 <see cref="ProductCreateInputVo.GroupIds"/> / <see cref="ProductCreateInputVo.LocationIds"/> 合并写入 fl_location_product。
+    /// Region/Location 数组含 <c>["ALL"]</c> 时，即使 AvailabilityType 为 SPECIFIED 也归档为 ALL，清空 fl_location_product 快照。
     /// </remarks>
     Task<ProductGetOutputDto> CreateAsync(ProductCreateInputVo input);
  
@@ -41,8 +43,8 @@ public interface IProductAppService : IApplicationService
     /// 编辑产品
     /// </summary>
     /// <remarks>
-    /// 当请求体包含 <see cref="ProductCreateInputVo.PartnerId"/>、<see cref="ProductCreateInputVo.GroupIds"/>
-    /// 和/或 <see cref="ProductCreateInputVo.LocationIds"/> 时，合并后整表替换门店关联；均不传则不改。
+    /// 当请求体包含 <c>companyIds</c>/<c>partnerId</c>、<c>groupIds</c> 和/或 <c>locationIds</c> 时，合并后整表替换门店关联；均不传则不改。
+    /// Company <b>仅支持单选</b>（<c>companyIds</c> 最多 1 个具体 Guid，<b>不支持 ALL</b>）。Region/Location ALL 哨兵规则同 <see cref="CreateAsync"/>。
     /// </remarks>
     Task<ProductGetOutputDto> UpdateAsync(Guid id, ProductUpdateInputVo input);
  
@@ -74,5 +76,36 @@ public interface IProductAppService : IApplicationService
     /// 批量编辑产品（JSON 一次提交多行，与单条 <c>PUT</c> 字段一致）
     /// </summary>
     Task<ProductBulkUpdateResultDto> UpdateProductsBulkAsync(ProductBulkUpdateInputVo input);
+
+    /// <summary>
+    /// JSON 在线批量导入产品（逐行调用 <see cref="CreateAsync"/>，部分成功）
+    /// </summary>
+    /// <remarks>
+    /// 请求体为 JSON，每行字段与单条新增 <see cref="ProductCreateInputVo"/> 一致。
+    ///
+    /// 示例请求：
+    /// ```json
+    /// {
+    ///   "items": [
+    ///     {
+    ///       "productName": "Tuna &amp; Bacon Sub",
+    ///       "categoryId": "CATEGORY_ID",
+    ///       "productCode": "40001",
+    ///       "state": true,
+    ///       "locationIds": ["LOCATION_GUID"]
+    ///     }
+    ///   ]
+    /// }
+    /// ```
+    ///
+    /// 参数说明：
+    /// - items: 待导入行数组；<c>index</c> 从 0 起；单次最多 <c>MaxImportRows</c> 条（默认 5000）
+    /// </remarks>
+    /// <param name="input">批量导入请求体</param>
+    /// <returns>成功数、失败数及失败明细（<c>index</c>、<c>productName</c>、<c>message</c>）</returns>
+    /// <response code="200">全部或部分行处理完成，见返回体中的计数与 errors</response>
+    /// <response code="400">整单校验失败（如 items 为空、超过单次条数上限）</response>
+    /// <response code="500">服务器错误</response>
+    Task<ProductBatchImportOnlineResultDto> BatchImportOnlineAsync(ProductBatchImportOnlineInputVo input);
 }
  
@@ -17,12 +17,12 @@ public interface IProductCategoryAppService : IApplicationService
     Task<ProductCategoryGetOutputDto> GetAsync(string id);
  
     /// <summary>
-    /// 新增类别；<c>categoryCode</c> 可选；body 传 <c>regionIds</c>（Region 多选）与 <c>locationIds</c>（门店多选）绑定适用范围。
+    /// 新增类别；支持 <c>companyIds</c>/<c>partnerIds</c> 与 Region/Location 哨兵 <c>ALL</c>（POST）。
     /// </summary>
     Task<ProductCategoryGetOutputDto> CreateAsync(ProductCategoryCreateInputVo input);
  
     /// <summary>
-    /// 编辑类别；<c>categoryCode</c> 可选；<c>regionIds</c>/<c>locationIds</c> 多选数组规则同新增；传空数组 <c>[]</c> 可清空对应范围。
+    /// 编辑类别；范围传参与新增一致，<c>companyIds</c> 全选回显/保存支持 <c>["ALL"]</c>（PUT）。
     /// </summary>
     Task<ProductCategoryGetOutputDto> UpdateAsync(string id, ProductCategoryUpdateInputVo input);
  
@@ -14,8 +14,14 @@ public interface ITeamMemberAppService
  
     Task<TeamMemberGetOutputDto> GetAsync(Guid id);
  
+    /// <summary>
+    /// 新增成员（POST <c>/api/app/team-member</c>）。<c>locationIds</c> / <c>regionIds</c> / <c>groupIds</c> / <c>locations</c> 可传 <c>ALL</c> 哨兵。
+    /// </summary>
     Task<TeamMemberGetOutputDto> CreateAsync(TeamMemberCreateInputVo input);
  
+    /// <summary>
+    /// 更新成员（PUT <c>/api/app/team-member/{id}</c>）。范围传参规则与 <see cref="CreateAsync"/> 相同。
+    /// </summary>
     Task<TeamMemberGetOutputDto> UpdateAsync(Guid id, TeamMemberUpdateInputVo input);
  
     Task DeleteAsync(Guid id);
@@ -39,4 +45,37 @@ public interface ITeamMemberAppService
     /// 批量编辑成员（JSON 一次提交多行）
     /// </summary>
     Task<TeamMemberBulkUpdateResultDto> UpdateTeamMembersBulkAsync(TeamMemberBulkUpdateInputVo input);
+
+    /// <summary>
+    /// JSON 在线批量导入成员（逐行调用 <see cref="CreateAsync"/>，部分成功）
+    /// </summary>
+    /// <remarks>
+    /// 请求体为 JSON，每行字段与单条新增 <see cref="TeamMemberCreateInputVo"/> 一致；
+    /// <c>password</c> 为空时使用配置 <c>TeamMemberImportDefaultPassword</c>。
+    ///
+    /// 示例请求：
+    /// ```json
+    /// {
+    ///   "items": [
+    ///     {
+    ///       "fullName": "John Doe",
+    ///       "userName": "john@example.com",
+    ///       "email": "john@example.com",
+    ///       "roleId": "ROLE_GUID",
+    ///       "locationIds": ["LOCATION_GUID"],
+    ///       "state": true
+    ///     }
+    ///   ]
+    /// }
+    /// ```
+    ///
+    /// 参数说明：
+    /// - items: 待导入行数组；<c>index</c> 从 0 起；单次最多 <c>MaxImportRows</c> 条（默认 5000）
+    /// </remarks>
+    /// <param name="input">批量导入请求体</param>
+    /// <returns>成功数、失败数及失败明细（<c>index</c>、<c>userName</c>、<c>message</c>）</returns>
+    /// <response code="200">全部或部分行处理完成，见返回体中的计数与 errors</response>
+    /// <response code="400">整单校验失败（如 items 为空、超过单次条数上限）</response>
+    /// <response code="500">服务器错误</response>
+    Task<TeamMemberBatchImportOnlineResultDto> BatchImportOnlineAsync(TeamMemberBatchImportOnlineInputVo input);
 }
+using FoodLabeling.Application.Contracts.Dtos.Training;
+using Volo.Abp.Application.Services;
+
+namespace FoodLabeling.Application.Contracts.IServices;
+
+public interface ITrainingAppService : IApplicationService
+{
+    Task<List<TrainingCategoryTreeNodeDto>> GetCategoryTreeAsync(TrainingCategoryTreeInputVo input);
+
+    Task<TrainingCategoryGetOutputDto> CreateCategoryAsync(TrainingCategoryCreateInputVo input);
+
+    Task<TrainingCategoryGetOutputDto> UpdateCategoryAsync(string id, TrainingCategoryUpdateInputVo input);
+
+    Task DeleteCategoryAsync(string id);
+
+    Task<TrainingFileDto> UploadFileAsync(TrainingFileUploadInputVo input);
+
+    Task<TrainingFileDto> UpdateFileAsync(string id, TrainingFileUpdateInputVo input);
+
+    Task DeleteFileAsync(string id);
+
+    Task SortFilesAsync(TrainingFileSortInputVo input);
+
+    Task<TrainingFileScopeOutputDto> GetFileScopeAsync(string id);
+
+    Task<TrainingFileScopeOutputDto> SetFileScopeAsync(string id, TrainingFileScopeInputVo input);
+}
+using FoodLabeling.Application.Contracts.Dtos.Training;
+using Volo.Abp.Application.Services;
+
+namespace FoodLabeling.Application.Contracts.IServices;
+
+/// <summary>
+/// App 培训 / 资料中心
+/// </summary>
+public interface IUsAppTrainingAppService : IApplicationService
+{
+    Task<List<TrainingCategoryTreeNodeDto>> GetTreeAsync(UsAppTrainingTreeInputVo input);
+}
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace FoodLabeling.Application.Contracts.Json;
+
+/// <summary>
+/// 反序列化时兼容 JSON 字符串或字符串数组（取首个非空元素），用于前端误把单选字段传成数组的场景（如 <c>partnerId</c>）。
+/// </summary>
+public sealed class StringOrFirstArrayItemJsonConverter : JsonConverter<string?>
+{
+    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        switch (reader.TokenType)
+        {
+            case JsonTokenType.Null:
+                return null;
+            case JsonTokenType.String:
+                return reader.GetString();
+            case JsonTokenType.StartArray:
+            {
+                string? first = null;
+                while (reader.Read())
+                {
+                    if (reader.TokenType == JsonTokenType.EndArray)
+                    {
+                        break;
+                    }
+
+                    if (reader.TokenType == JsonTokenType.Null)
+                    {
+                        continue;
+                    }
+
+                    if (reader.TokenType != JsonTokenType.String)
+                    {
+                        throw new JsonException("partnerId 数组元素必须是字符串");
+                    }
+
+                    var item = reader.GetString()?.Trim();
+                    if (first is null && !string.IsNullOrWhiteSpace(item))
+                    {
+                        first = item;
+                    }
+                }
+
+                return first;
+            }
+            default:
+                throw new JsonException($"无法将 JSON token {reader.TokenType} 转为字符串（partnerId）");
+        }
+    }
+
+    public override void Write(Utf8JsonWriter writer, string? value, JsonSerializerOptions options)
+    {
+        if (value is null)
+        {
+            writer.WriteNullValue();
+        }
+        else
+        {
+            writer.WriteStringValue(value);
+        }
+    }
+}
@@ -10,4 +10,7 @@ public static class UsAppJwtClaims
  
     /// <summary>美国版移动端 App</summary>
     public const string ClientKindUsApp = "us-app";
+
+    /// <summary>泰额版 App（us-app-auth 转发 th-app-auth 签发）</summary>
+    public const string ClientKindThApp = "th_app";
 }
@@ -4,10 +4,35 @@
   <ItemGroup>
     <PackageReference Include="ClosedXML" Version="0.102.3" />
     <PackageReference Include="Lazy.Captcha.Core" Version="2.0.7" />
+    <PackageReference Include="MySqlConnector" Version="2.4.0" />
     <PackageReference Include="QuestPDF" Version="2024.12.2" />
   </ItemGroup>
  
   <ItemGroup>
+    <EmbeddedResource Include="..\scripts\fl_entity_applied_region_type.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_entity_applied_region_type.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_label_partner_id.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_label_partner_id.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_product_category_partner_scope.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_product_category_partner_scope.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_userlocation.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_userlocation.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_team_member_scope.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_team_member_scope.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_training.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_training.sql</LogicalName>
+    </EmbeddedResource>
+    <EmbeddedResource Include="..\scripts\fl_label_alert_timer.sql">
+      <LogicalName>FoodLabeling.TenantMigrations.fl_label_alert_timer.sql</LogicalName>
+    </EmbeddedResource>
+  </ItemGroup>
+
+  <ItemGroup>
     <ProjectReference Include="..\..\..\framework\Yi.Framework.Ddd.Application\Yi.Framework.Ddd.Application.csproj" />
     <ProjectReference Include="..\..\rbac\Yi.Framework.Rbac.Application.Contracts\Yi.Framework.Rbac.Application.Contracts.csproj" />
     <ProjectReference Include="..\FoodLabeling.Application.Contracts\FoodLabeling.Application.Contracts.csproj" />
@@ -23,22 +23,36 @@ public static class AllScopeBindingHelper
             return selected.Count == 0;
         }
  
-        if (selected.Count != universe.Count)
+        var universeSet = new HashSet<string>(
+            universe.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x.Trim()),
+            StringComparer.OrdinalIgnoreCase);
+        var selectedSet = new HashSet<string>(
+            selected.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x.Trim()),
+            StringComparer.OrdinalIgnoreCase);
+
+        if (selectedSet.Count != universeSet.Count)
         {
             return false;
         }
  
-        var set = new HashSet<string>(universe, StringComparer.Ordinal);
-        return selected.All(id => set.Contains(id));
+        return selectedSet.SetEquals(universeSet);
     }
  
-    /// <summary>解析维度类型：显式 ALL、空数组 ALL、或 Id 列表全选时视为 ALL。</summary>
+    /// <summary>
+    /// 解析维度类型：显式 ALL、空数组 ALL、或 Id 列表全选时视为 ALL。
+    /// 入参显式 <see cref="ScopeSpecified"/> 时保留 SPECIFIED 并落库全部 Id，不因「当前上下文全选」折叠为 ALL。
+    /// </summary>
     public static string ResolveDimensionType(
         string? declaredType,
         IReadOnlyList<string> ids,
         bool hasArrayInPayload,
         bool isFullSelection)
     {
+        if (IsDeclaredSpecified(declaredType))
+        {
+            return ScopeSpecified;
+        }
+
         if (isFullSelection || (ids.Count == 0 && IsDeclaredAll(declaredType)))
         {
             return ScopeAll;
@@ -61,6 +75,9 @@ public static class AllScopeBindingHelper
     public static bool IsDeclaredAll(string? type) =>
         string.Equals((type ?? ScopeAll).Trim(), ScopeAll, StringComparison.OrdinalIgnoreCase);
  
+    public static bool IsDeclaredSpecified(string? type) =>
+        string.Equals((type ?? string.Empty).Trim(), ScopeSpecified, StringComparison.OrdinalIgnoreCase);
+
     /// <summary>全部 Company（<c>fl_partner.Id</c>）。</summary>
     public static async Task<List<string>> ResolveAllPartnerIdsAsync(ISqlSugarClient db)
     {
@@ -87,20 +104,51 @@ public static class AllScopeBindingHelper
         return LocationScopeBindingHelper.NormalizeIds(rows);
     }
  
-    /// <summary>全部门店；可按 Company / Region 限定。</summary>
+    /// <summary>
+    /// 全部门店；可按 Company / Region 限定。
+    /// 同时传 Company 与 Region 时取<strong>交集</strong>（该 Region 下且属于这些 Company 的门店），
+    /// 禁止并集——否则回显「区内全选」无法折叠为 <c>locationIds:["ALL"]</c>。
+    /// </summary>
     public static async Task<List<string>> ResolveAllLocationIdsAsync(
         ISqlSugarClient db,
         IReadOnlyList<string>? partnerIds,
         IReadOnlyList<string>? regionIds)
     {
+        var partners = LocationScopeBindingHelper.NormalizeIds(partnerIds);
+        var regions = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+
+        if (regions.Count > 0)
+        {
+            var fromRegions = await LocationScopeBindingHelper.ResolveLocationIdsFromGroupIdsAsync(db, regions);
+            if (partners.Count == 0)
+            {
+                return LocationScopeBindingHelper.NormalizeIds(fromRegions);
+            }
+
+            var partnerLocSet = new HashSet<string>(
+                await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partners),
+                StringComparer.OrdinalIgnoreCase);
+            return LocationScopeBindingHelper.NormalizeIds(
+                fromRegions.Where(id => partnerLocSet.Contains(id)).ToList());
+        }
+
+        if (partners.Count > 0)
+        {
+            return await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partners);
+        }
+
         var merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
             db,
-            partnerIds,
-            regionIds,
+            (IReadOnlyList<string>?)null,
+            null,
             null);
         return LocationScopeBindingHelper.NormalizeIds(merged);
     }
  
+    /// <summary>Id 数组是否含 <c>ALL</c> 哨兵（大小写不敏感；与具体 Guid 同传时以 ALL 为准）。</summary>
+    public static bool HasAllScopeSentinelSelection(IReadOnlyList<string>? ids) =>
+        LocationScopeBindingHelper.ContainsAllScopeSentinel(ids);
+
     /// <summary>Company 维度是否应存为 ALL（含「勾选了全部 Company」）。</summary>
     public static async Task<(string Type, List<string> Ids)> NormalizePartnerScopeAsync(
         ISqlSugarClient db,
@@ -110,6 +158,10 @@ public static class AllScopeBindingHelper
         bool hasArrayInPayload)
     {
         var ids = LabelEntityPartnerScopeHelper.NormalizePartnerIds(partnerIds, companyIds);
+        if (HasAllScopeSentinelSelection(ids))
+        {
+            return (ScopeAll, new List<string>());
+        }
         var allPartners = await ResolveAllPartnerIdsAsync(db);
         // 勾选当前全部 Company（含前端仍传 SPECIFIED + 全量 Id）→ 归档 ALL，后续新增 Company 动态适用
         var isFull = ids.Count > 0 && IsFullIdSelection(ids, allPartners);
@@ -125,7 +177,12 @@ public static class AllScopeBindingHelper
         bool hasArrayInPayload,
         IReadOnlyList<string>? partnerIdsForContext)
     {
-        var ids = LocationScopeBindingHelper.NormalizeIds(regionIds);
+        if (HasAllScopeSentinelSelection(regionIds))
+        {
+            return (ScopeAll, new List<string>());
+        }
+
+        var ids = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
         var allRegions = await ResolveAllRegionIdsAsync(db, partnerIdsForContext);
         var isFull = ids.Count > 0 && IsFullIdSelection(ids, allRegions);
         var type = ResolveDimensionType(declaredType, ids, hasArrayInPayload, isFull);
@@ -141,7 +198,12 @@ public static class AllScopeBindingHelper
         IReadOnlyList<string>? partnerIdsForContext,
         IReadOnlyList<string>? regionIdsForContext)
     {
-        var ids = LocationScopeBindingHelper.NormalizeIds(locationIds);
+        if (HasAllScopeSentinelSelection(locationIds))
+        {
+            return (ScopeAll, new List<string>());
+        }
+
+        var ids = LocationScopeBindingHelper.FilterConcreteScopeIds(locationIds);
         var allLocations = await ResolveAllLocationIdsAsync(db, partnerIdsForContext, regionIdsForContext);
         var isFull = ids.Count > 0 && IsFullIdSelection(ids, allLocations);
         var type = ResolveDimensionType(declaredType, ids, hasArrayInPayload, isFull);
@@ -162,7 +224,7 @@ public static class AllScopeBindingHelper
             return new List<string> { partnerId.Trim() };
         }
  
-        var regionIds = LocationScopeBindingHelper.NormalizeIds(regionOrGroupIds);
+        var regionIds = LocationScopeBindingHelper.FilterConcreteScopeIds(regionOrGroupIds);
         if (regionIds.Count > 0)
         {
             var rows = await db.Queryable<FlGroupDbEntity>()
@@ -173,7 +235,7 @@ public static class AllScopeBindingHelper
             return normalized.Count > 0 ? normalized : null;
         }
  
-        var locIds = LocationScopeBindingHelper.NormalizeIds(locationIds);
+        var locIds = LocationScopeBindingHelper.FilterConcreteScopeIds(locationIds);
         if (locIds.Count == 0)
         {
             return null;
@@ -195,27 +257,55 @@ public static class AllScopeBindingHelper
         bool hasScopeArrays,
         IReadOnlyList<string>? partnerIdsForContext)
     {
+        var concreteLocations = LocationScopeBindingHelper.FilterConcreteScopeIds(locationIds);
+        var concreteRegions = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+
+        // 具体 Region（非全局 ALL）下即使覆盖该区全部门店，也只存 SPECIFIED 快照，不升全局 AvailabilityType=ALL
+        if (concreteRegions.Count > 0)
+        {
+            return false;
+        }
+
+        // locationIds 含 ALL 且无具体 Region：由调用方按 Company 展开或归档全局 ALL
+        if (HasAllScopeSentinelSelection(locationIds))
+        {
+            return true;
+        }
+
+        if (HasAllScopeSentinelSelection(regionIds) && concreteLocations.Count == 0)
+        {
+            return true;
+        }
+
         if (IsDeclaredAll(declaredAvailabilityType)
-            && LocationScopeBindingHelper.NormalizeIds(regionIds).Count == 0
-            && LocationScopeBindingHelper.NormalizeIds(locationIds).Count == 0)
+            && concreteRegions.Count == 0
+            && concreteLocations.Count == 0)
         {
             return true;
         }
  
         if (hasScopeArrays
-            && LocationScopeBindingHelper.NormalizeIds(regionIds).Count == 0
-            && LocationScopeBindingHelper.NormalizeIds(locationIds).Count == 0
+            && concreteRegions.Count == 0
+            && concreteLocations.Count == 0
             && IsDeclaredAll(declaredAvailabilityType))
         {
             return true;
         }
  
-        // 前端 Select All 常传 SPECIFIED + 当前全量 Id：覆盖 Company 上下文全部门店时归档 ALL
-        var merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
+        // 前端 Select All 常传 SPECIFIED + 当前全量 Id：覆盖上下文全部门店时归档 ALL。
+        // 有具体 locationIds 时：只按这些门店落 SPECIFIED 快照，禁止再升成 AvailabilityType=ALL
+        // （否则「Region=ALL + 选 1 店」在公司仅 1 店或误判全选时会清空快照并回显成全局 ALL）。
+        if (concreteLocations.Count > 0)
+        {
+            return false;
+        }
+
+        List<string> merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
             db,
             (IReadOnlyList<string>?)null,
-            regionIds,
-            locationIds);
+            concreteRegions,
+            concreteLocations);
+
         if (merged.Count == 0)
         {
             return false;
@@ -224,14 +314,14 @@ public static class AllScopeBindingHelper
         var partnerContext = LocationScopeBindingHelper.NormalizeIds(partnerIdsForContext);
         if (partnerContext.Count == 0)
         {
-            partnerContext = await ResolvePartnerContextFromScopeAsync(db, null, regionIds, locationIds)
+            partnerContext = await ResolvePartnerContextFromScopeAsync(db, null, concreteRegions, concreteLocations)
                              ?? new List<string>();
         }
  
         var allLocations = await ResolveAllLocationIdsAsync(
             db,
             partnerContext.Count > 0 ? partnerContext : null,
-            null);
+            concreteRegions.Count > 0 ? concreteRegions : null);
         return IsFullIdSelection(merged, allLocations);
     }
  
@@ -244,10 +334,35 @@ public static class AllScopeBindingHelper
         IReadOnlyList<string>? locationIds,
         bool hasScopePayload)
     {
+        // partnerId 字符串为 ALL 哨兵：全选 Company，归档 ALL（禁止把 ALL 当 Guid 查库）
+        if (LocationScopeBindingHelper.IsAllScopeSentinel(partnerId))
+        {
+            return true;
+        }
+
+        var concreteLocations = LocationScopeBindingHelper.FilterConcreteScopeIds(locationIds);
+        var concreteGroups = LocationScopeBindingHelper.FilterConcreteScopeIds(groupIds);
+
+        // 具体 Region 下不升全局 AvailabilityType=ALL（与 ShouldTreatMergedLocationScopeAsAllAsync 一致）
+        if (concreteGroups.Count > 0)
+        {
+            return false;
+        }
+
+        if (HasAllScopeSentinelSelection(locationIds))
+        {
+            return true;
+        }
+
+        if (HasAllScopeSentinelSelection(groupIds) && concreteLocations.Count == 0)
+        {
+            return true;
+        }
+
         if (IsDeclaredAll(declaredAvailabilityType)
             && string.IsNullOrWhiteSpace(partnerId)
-            && LocationScopeBindingHelper.NormalizeIds(groupIds).Count == 0
-            && LocationScopeBindingHelper.NormalizeIds(locationIds).Count == 0)
+            && concreteGroups.Count == 0
+            && concreteLocations.Count == 0)
         {
             return true;
         }
@@ -257,20 +372,29 @@ public static class AllScopeBindingHelper
             return false;
         }
  
+        // 有具体门店时不升全局 ALL
+        if (concreteLocations.Count > 0)
+        {
+            return false;
+        }
+
         var merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
             db,
             partnerId,
-            groupIds,
-            locationIds);
+            concreteGroups,
+            concreteLocations);
+
         if (merged.Count == 0)
         {
             return false;
         }
  
-        // 未传 partnerId 时从 Region/门店反推 Company，避免用「全系统门店」误判导致无法归档 ALL
         var partnerContext = await ResolvePartnerContextFromScopeAsync(
-            db, partnerId, groupIds, locationIds);
-        var allLocations = await ResolveAllLocationIdsAsync(db, partnerContext, null);
+            db, partnerId, concreteGroups, concreteLocations);
+        var allLocations = await ResolveAllLocationIdsAsync(
+            db,
+            partnerContext,
+            concreteGroups.Count > 0 ? concreteGroups : null);
         return IsFullIdSelection(merged, allLocations);
     }
  
@@ -302,4 +426,169 @@ public static class AllScopeBindingHelper
             : await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(db, locs);
         return (partnerIds, regionIds, locs);
     }
+
+    /// <summary>
+    /// 标签/产品分类等：解析 Region + Location 落库（对齐 Label：Region=ALL 时可保留具体门店快照）。
+    /// </summary>
+    public sealed class LabelEntityRegionLocationSaveResult
+    {
+        public string AvailabilityType { get; init; } = ScopeSpecified;
+
+        public string AppliedRegionType { get; init; } = ScopeAll;
+
+        public List<string> LocationIds { get; init; } = new();
+    }
+
+    public static async Task<LabelEntityRegionLocationSaveResult> ResolveLabelEntityRegionLocationForSaveAsync(
+        ISqlSugarClient db,
+        string? declaredAvailabilityType,
+        IReadOnlyList<string>? partnerIdsForContext,
+        IReadOnlyList<string>? mergedRegionIdsRaw,
+        IReadOnlyList<string>? locationIdsRaw,
+        bool hasScopeArrays)
+    {
+        var normalizedLocationIds = LocationScopeBindingHelper.NormalizeIds(locationIdsRaw);
+        var mergedRegionIds = LocationScopeBindingHelper.NormalizeIds(mergedRegionIdsRaw);
+        var regionIds = LocationScopeBindingHelper.FilterConcreteScopeIds(mergedRegionIds);
+        var explicitLocationIds = LocationScopeBindingHelper.FilterConcreteScopeIds(normalizedLocationIds);
+        var locationHasAll = HasAllScopeSentinelSelection(normalizedLocationIds);
+        var regionHasAllSentinel = HasAllScopeSentinelSelection(mergedRegionIds);
+        var hasConcretePartner = LocationScopeBindingHelper.NormalizeIds(partnerIdsForContext).Count > 0;
+        // 用户显式传具体门店 Id 时一律 SPECIFIED，不因「恰好覆盖 Region 全集」归档 ALL
+        var userExplicitLocations = explicitLocationIds.Count > 0 && !locationHasAll;
+
+        // 前端 Select All Region 常展开为全量 Guid，需识别为 Region=ALL
+        var regionHasAll = regionHasAllSentinel;
+        if (!regionHasAll && regionIds.Count > 0)
+        {
+            var allRegions = await ResolveAllRegionIdsAsync(
+                db,
+                hasConcretePartner ? partnerIdsForContext : null);
+            regionHasAll = allRegions.Count > 0 && IsFullIdSelection(regionIds, allRegions);
+        }
+
+        // location ALL 哨兵，或具体 Region 下「空选/全选门店」：有 Company/Region 上下文则展开 SPECIFIED
+        var locationCoversConcreteRegions = false;
+        if (!locationHasAll && !userExplicitLocations && regionIds.Count > 0 && !regionHasAll)
+        {
+            if (explicitLocationIds.Count == 0)
+            {
+                locationCoversConcreteRegions = true;
+            }
+            else
+            {
+                var regionUniverse = await ResolveAllLocationIdsAsync(
+                    db,
+                    hasConcretePartner ? partnerIdsForContext : null,
+                    regionIds);
+                locationCoversConcreteRegions = regionUniverse.Count > 0
+                                               && IsFullIdSelection(explicitLocationIds, regionUniverse);
+            }
+        }
+
+        if (!userExplicitLocations && (locationHasAll || locationCoversConcreteRegions))
+        {
+            var expandRegions = regionHasAll ? null : (regionIds.Count > 0 ? regionIds : null);
+            var expanded = await LocationScopeBindingHelper.ExpandScopedAllLocationsForSaveAsync(
+                db,
+                hasConcretePartner ? partnerIdsForContext : null,
+                expandRegions);
+            if (expanded is not null)
+            {
+                return new LabelEntityRegionLocationSaveResult
+                {
+                    AvailabilityType = ScopeSpecified,
+                    AppliedRegionType = regionHasAll || regionIds.Count == 0 ? ScopeAll : ScopeSpecified,
+                    LocationIds = expanded
+                };
+            }
+
+            return new LabelEntityRegionLocationSaveResult
+            {
+                AvailabilityType = ScopeAll,
+                AppliedRegionType = ScopeAll,
+                LocationIds = new List<string>()
+            };
+        }
+
+        // Region=ALL + 具体门店：Region 存 ALL，门店 SPECIFIED 快照（可回显 regionIds=["ALL"] + 单个 locationId）
+        if (regionHasAll && explicitLocationIds.Count > 0)
+        {
+            await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(db, explicitLocationIds);
+            return new LabelEntityRegionLocationSaveResult
+            {
+                AvailabilityType = ScopeSpecified,
+                AppliedRegionType = ScopeAll,
+                LocationIds = explicitLocationIds
+            };
+        }
+
+        // Region=ALL 且无具体门店 → 双 ALL
+        if (regionHasAll)
+        {
+            return new LabelEntityRegionLocationSaveResult
+            {
+                AvailabilityType = ScopeAll,
+                AppliedRegionType = ScopeAll,
+                LocationIds = new List<string>()
+            };
+        }
+
+        // 有具体门店（可同传具体 Region）：以门店为准
+        if (explicitLocationIds.Count > 0)
+        {
+            await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(db, explicitLocationIds);
+            return new LabelEntityRegionLocationSaveResult
+            {
+                AvailabilityType = ScopeSpecified,
+                AppliedRegionType = ScopeSpecified,
+                LocationIds = explicitLocationIds
+            };
+        }
+
+        if (await ShouldTreatMergedLocationScopeAsAllAsync(
+                db,
+                declaredAvailabilityType,
+                regionIds,
+                explicitLocationIds,
+                hasScopeArrays,
+                partnerIdsForContext))
+        {
+            return new LabelEntityRegionLocationSaveResult
+            {
+                AvailabilityType = ScopeAll,
+                AppliedRegionType = ScopeAll,
+                LocationIds = new List<string>()
+            };
+        }
+
+        var availabilityType = (declaredAvailabilityType ?? ScopeAll).Trim().ToUpperInvariant();
+        if (regionIds.Count > 0)
+        {
+            availabilityType = ScopeSpecified;
+        }
+        else if (hasScopeArrays && IsDeclaredAll(availabilityType))
+        {
+            availabilityType = ScopeAll;
+        }
+
+        if (availabilityType != ScopeAll && availabilityType != ScopeSpecified)
+        {
+            throw new UserFriendlyException("门店可用范围不合法（ALL/SPECIFIED）");
+        }
+
+        var locationSpecified = string.Equals(availabilityType, ScopeSpecified, StringComparison.OrdinalIgnoreCase);
+        var savedLocationIds = await LocationScopeBindingHelper.ResolveEntityLocationIdsForSaveAsync(
+            db,
+            locationSpecified,
+            regionIds,
+            explicitLocationIds);
+
+        return new LabelEntityRegionLocationSaveResult
+        {
+            AvailabilityType = locationSpecified ? ScopeSpecified : ScopeAll,
+            AppliedRegionType = locationSpecified ? ScopeSpecified : ScopeAll,
+            LocationIds = savedLocationIds
+        };
+    }
 }
@@ -11,6 +11,10 @@ public static class EntityLocationScopeDisplayHelper
     /// <summary>
     /// 根据可用范围类型与已解析的 Region/Location Id、名称，生成列表展示文案。
     /// </summary>
+    /// <remarks>
+    /// 有具体门店 Guid 时始终展示门店名称，不因「覆盖某 Region 下全部门店」误显示 All Location
+    /// （常见于 <c>AppliedRegionType=ALL</c> + 单个 <c>locationIds</c>）。
+    /// </remarks>
     public static async Task<(string Region, string Location)> BuildListDisplayAsync(
         ISqlSugarClient db,
         string? availabilityType,
@@ -18,7 +22,8 @@ public static class EntityLocationScopeDisplayHelper
         IReadOnlyList<string> locationIds,
         IEnumerable<string> regionNames,
         IEnumerable<string> locationNames,
-        IReadOnlyList<string>? partnerIdsForContext)
+        IReadOnlyList<string>? partnerIdsForContext,
+        string? appliedRegionType = null)
     {
         if (AllScopeBindingHelper.IsDeclaredAll(availabilityType))
         {
@@ -29,27 +34,33 @@ public static class EntityLocationScopeDisplayHelper
         var normLocationIds = LocationScopeBindingHelper.NormalizeIds(locationIds);
         var partnerContext = partnerIdsForContext is { Count: > 0 } ? partnerIdsForContext : null;
  
-        var allRegionIds = await AllScopeBindingHelper.ResolveAllRegionIdsAsync(db, partnerContext);
-        var regionIsAll = normRegionIds.Count > 0
-                          && allRegionIds.Count > 0
-                          && AllScopeBindingHelper.IsFullIdSelection(normRegionIds, allRegionIds);
-
-        var regionContextForLocations = regionIsAll ? null : normRegionIds.Count > 0 ? normRegionIds : null;
-        var allLocationIds = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(
-            db,
-            partnerContext,
-            regionContextForLocations);
-        var locationIsAll = normLocationIds.Count > 0
-                            && allLocationIds.Count > 0
-                            && AllScopeBindingHelper.IsFullIdSelection(normLocationIds, allLocationIds);
-
-        var regionDisplay = regionIsAll
-            ? AllScopeBindingHelper.AllRegionsDisplay
-            : JoinDistinctNames(regionNames);
+        string regionDisplay;
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedRegionType)
+            || AllScopeBindingHelper.HasAllScopeSentinelSelection(normRegionIds))
+        {
+            regionDisplay = AllScopeBindingHelper.AllRegionsDisplay;
+        }
+        else
+        {
+            var allRegionIds = await AllScopeBindingHelper.ResolveAllRegionIdsAsync(db, partnerContext);
+            var regionIsAll = normRegionIds.Count > 0
+                              && allRegionIds.Count > 0
+                              && AllScopeBindingHelper.IsFullIdSelection(normRegionIds, allRegionIds);
+            regionDisplay = regionIsAll
+                ? AllScopeBindingHelper.AllRegionsDisplay
+                : JoinDistinctNames(regionNames);
+        }
  
-        var locationDisplay = locationIsAll
-            ? AllScopeBindingHelper.AllLocationsDisplay
-            : JoinDistinctNames(locationNames);
+        // 具体门店 Guid → 显示门店名；仅 AvailabilityType=ALL 或 locationIds 含 ALL 哨兵才显示 All Location
+        string locationDisplay;
+        if (AllScopeBindingHelper.HasAllScopeSentinelSelection(normLocationIds))
+        {
+            locationDisplay = AllScopeBindingHelper.AllLocationsDisplay;
+        }
+        else
+        {
+            locationDisplay = JoinDistinctNames(locationNames);
+        }
  
         return (regionDisplay, locationDisplay);
     }
+using System.Globalization;
+using FoodLabeling.Application.Services.DbModels;
+using FoodLabeling.Domain.Shared.Helpers;
+using SqlSugar;
+
+namespace FoodLabeling.Application.Helpers;
+
+/// <summary>
+/// 打印成功后写入告警计时器（按 BatchId 幂等，一条批次一条计时器）。
+/// </summary>
+public static class LabelAlertTimerWriteHelper
+{
+    /// <summary>
+    /// 根据打印批次创建告警计时器；已存在未删除记录或无有效过期时刻时直接返回。
+    /// </summary>
+    public static async Task TryCreateFromPrintBatchAsync(
+        ISqlSugarClient db,
+        string batchId,
+        string? createdBy,
+        CancellationToken ct = default)
+    {
+        var bid = batchId?.Trim();
+        if (string.IsNullOrWhiteSpace(bid))
+        {
+            return;
+        }
+
+        ct.ThrowIfCancellationRequested();
+
+        // BatchId 有唯一索引：含软删记录也不再插入，避免幂等补写撞唯一约束
+        var exists = await db.Queryable<FlLabelAlertTimerDbEntity>()
+            .AnyAsync(x => x.BatchId == bid);
+        if (exists)
+        {
+            return;
+        }
+
+        var task = (await db.Queryable<FlLabelPrintTaskDbEntity>()
+                .Where(x => x.BatchId == bid)
+                .OrderBy(x => x.CopyIndex)
+                .Take(1)
+                .ToListAsync(ct))
+            .FirstOrDefault();
+        if (task is null)
+        {
+            return;
+        }
+
+        var printedAt = task.PrintedAt ?? task.BaseTime ?? task.CreationTime;
+        if (!ReportsPrintLogExpiryHelper.TryResolveExpiryDateTime(
+                task.PrintInputJson,
+                task.RenderTemplateJson,
+                task.BaseTime,
+                printedAt,
+                out var expiresAt))
+        {
+            return;
+        }
+
+        var label = (await db.Queryable<FlLabelDbEntity>()
+                .Where(x => x.Id == task.LabelId)
+                .Select(x => new { x.LabelName, x.LabelCode })
+                .Take(1)
+                .ToListAsync(ct))
+            .FirstOrDefault();
+
+        var labelName = label?.LabelName?.Trim();
+        if (string.IsNullOrWhiteSpace(labelName))
+        {
+            labelName = FoodLabelingDisplayConsts.NotAvailable;
+        }
+
+        string? productName = null;
+        if (!string.IsNullOrWhiteSpace(task.ProductId))
+        {
+            productName = (await db.Queryable<FlProductDbEntity>()
+                    .Where(x => x.Id == task.ProductId && !x.IsDeleted)
+                    .Select(x => x.ProductName)
+                    .Take(1)
+                    .ToListAsync(ct))
+                .FirstOrDefault();
+        }
+
+        var durationSeconds = Math.Max(0, (int)(expiresAt - printedAt).TotalSeconds);
+        var title = BuildTitle(labelName, durationSeconds);
+        var subtitle = BuildSubtitle(durationSeconds, expiresAt);
+        var now = DateTime.Now;
+
+        var entity = new FlLabelAlertTimerDbEntity
+        {
+            Id = YitIdHelper.NextId().ToString(),
+            BatchId = bid,
+            PrintTaskId = task.Id,
+            LabelId = task.LabelId,
+            LabelCode = label?.LabelCode?.Trim(),
+            LabelName = labelName,
+            ProductId = task.ProductId,
+            ProductName = string.IsNullOrWhiteSpace(productName) ? null : productName.Trim(),
+            LocationId = task.LocationId?.Trim() ?? string.Empty,
+            PrintedAt = printedAt,
+            BaseTime = task.BaseTime,
+            ExpiresAt = expiresAt,
+            DurationSeconds = durationSeconds,
+            Title = title,
+            Subtitle = subtitle,
+            IsDeleted = false,
+            DeletionTime = null,
+            CreatedBy = createdBy,
+            CreationTime = now
+        };
+
+        await db.Insertable(entity).ExecuteCommandAsync();
+    }
+
+    private static string BuildTitle(string labelName, int durationSeconds)
+    {
+        var hoursText = FormatDurationHoursLabel(durationSeconds);
+        return string.IsNullOrWhiteSpace(hoursText) ? labelName : $"{labelName} ({hoursText})";
+    }
+
+    private static string BuildSubtitle(int durationSeconds, DateTime expiresAt)
+    {
+        var hoursText = FormatDurationHoursLabel(durationSeconds);
+        var timeText = expiresAt.ToString("h:mm tt", CultureInfo.CurrentCulture);
+        return string.IsNullOrWhiteSpace(hoursText)
+            ? $"Completes at {timeText}"
+            : $"{hoursText} Completes at {timeText}";
+    }
+
+    private static string FormatDurationHoursLabel(int durationSeconds)
+    {
+        if (durationSeconds <= 0)
+        {
+            return string.Empty;
+        }
+
+        var totalHours = durationSeconds / 3600.0;
+        if (totalHours >= 1)
+        {
+            var rounded = (int)Math.Round(totalHours, MidpointRounding.AwayFromZero);
+            rounded = Math.Max(1, rounded);
+            return rounded == 1 ? "1 hour" : $"{rounded} hours";
+        }
+
+        var minutes = Math.Max(1, (int)Math.Ceiling(durationSeconds / 60.0));
+        return minutes == 1 ? "1 minute" : $"{minutes} minutes";
+    }
+}
@@ -4,12 +4,37 @@ using SqlSugar;
 namespace FoodLabeling.Application.Helpers;
  
 /// <summary>
-/// 标签类型/分类/多选项列表：非平台管理员仅可见其绑定 Company 范围内数据。
+/// 标签类型/分类/多选项列表：按可见门店范围过滤。
+/// AvailabilityType=ALL 时传任意 Region/Location 筛选均命中。
 /// </summary>
 public static class LabelEntityListScopeHelper
 {
     /// <summary>
-    /// 标签类型列表：按 Company + Region/Location 范围过滤（Company Admin 不可见 All Companies 数据）。
+    /// 是否应用门店 Availability 过滤。
+    /// 仅传 <c>partnerId</c>（未传 groupId/locationId）时返回 false：只按 Company 维度筛，
+    /// 避免「多公司绑定」在第二家公司暂无门店或门店未落入关联表时被误杀。
+    /// </summary>
+    public static bool ShouldApplyLocationAvailabilityFilter(
+        string? partnerId,
+        string? groupId,
+        string? locationId)
+    {
+        if (!string.IsNullOrWhiteSpace(groupId) || !string.IsNullOrWhiteSpace(locationId))
+        {
+            return true;
+        }
+
+        // 仅 PartnerId：Company 过滤由 Apply*PartnerListFilter 负责
+        if (!string.IsNullOrWhiteSpace(partnerId))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// 标签类型列表：门店可用范围过滤（ALL 命中任意门店筛选）。
     /// </summary>
     public static ISugarQueryable<FlLabelTypeDbEntity> ApplyTypeLocationAvailabilityFilter(
         ISugarQueryable<FlLabelTypeDbEntity> query,
@@ -22,12 +47,12 @@ public static class LabelEntityListScopeHelper
  
         if (scopedLocationIds.Count == 0)
         {
-            return query.Where(_ => false);
+            // 无可见门店时仍保留 AvailabilityType=ALL（仅 Company 筛选时公司可能暂无门店）
+            return query.Where(t => t.AvailabilityType == AllScopeBindingHelper.ScopeAll);
         }
  
         return query.Where(t =>
-            (t.AvailabilityType == AllScopeBindingHelper.ScopeAll
-             && t.AppliedPartnerType == LabelEntityPartnerScopeHelper.ScopeSpecified)
+            t.AvailabilityType == AllScopeBindingHelper.ScopeAll
             || (t.AvailabilityType == AllScopeBindingHelper.ScopeSpecified
                 && SqlFunc.Subqueryable<FlLabelTypeLocationDbEntity>()
                     .Where(tl => tl.LabelTypeId == t.Id && scopedLocationIds.Contains(tl.LocationId))
@@ -35,7 +60,7 @@ public static class LabelEntityListScopeHelper
     }
  
     /// <summary>
-    /// 标签分类列表：按 Company + Region/Location 范围过滤。
+    /// 标签分类列表：门店可用范围过滤（ALL 命中任意门店筛选）。
     /// </summary>
     public static ISugarQueryable<FlLabelCategoryDbEntity> ApplyCategoryLocationAvailabilityFilter(
         ISugarQueryable<FlLabelCategoryDbEntity> query,
@@ -48,12 +73,11 @@ public static class LabelEntityListScopeHelper
  
         if (scopedLocationIds.Count == 0)
         {
-            return query.Where(_ => false);
+            return query.Where(c => c.AvailabilityType == AllScopeBindingHelper.ScopeAll);
         }
  
         return query.Where(c =>
-            (c.AvailabilityType == AllScopeBindingHelper.ScopeAll
-             && c.AppliedPartnerType == LabelEntityPartnerScopeHelper.ScopeSpecified)
+            c.AvailabilityType == AllScopeBindingHelper.ScopeAll
             || (c.AvailabilityType == AllScopeBindingHelper.ScopeSpecified
                 && SqlFunc.Subqueryable<FlLabelCategoryLocationDbEntity>()
                     .Where(cl => cl.CategoryId == c.Id && scopedLocationIds.Contains(cl.LocationId))
@@ -61,7 +85,7 @@ public static class LabelEntityListScopeHelper
     }
  
     /// <summary>
-    /// 标签多选项列表：按 Company + Region/Location 范围过滤。
+    /// 标签多选项列表：门店可用范围过滤（ALL 命中任意门店筛选）。
     /// </summary>
     public static ISugarQueryable<FlLabelMultipleOptionDbEntity> ApplyMultipleOptionLocationAvailabilityFilter(
         ISugarQueryable<FlLabelMultipleOptionDbEntity> query,
@@ -74,12 +98,11 @@ public static class LabelEntityListScopeHelper
  
         if (scopedLocationIds.Count == 0)
         {
-            return query.Where(_ => false);
+            return query.Where(o => o.AvailabilityType == AllScopeBindingHelper.ScopeAll);
         }
  
         return query.Where(o =>
-            (o.AvailabilityType == AllScopeBindingHelper.ScopeAll
-             && o.AppliedPartnerType == LabelEntityPartnerScopeHelper.ScopeSpecified)
+            o.AvailabilityType == AllScopeBindingHelper.ScopeAll
             || (o.AvailabilityType == AllScopeBindingHelper.ScopeSpecified
                 && SqlFunc.Subqueryable<FlLabelMultipleOptionLocationDbEntity>()
                     .Where(ol => ol.MultipleOptionId == o.Id && scopedLocationIds.Contains(ol.LocationId))
@@ -26,7 +26,10 @@ public static class LabelEntityPartnerScopeHelper
         Category,
  
         /// <summary>标签多选项 <c>fl_label_multiple_option</c></summary>
-        MultipleOption
+        MultipleOption,
+
+        /// <summary>产品分类 <c>fl_product_category</c></summary>
+        ProductCategory
     }
  
     public sealed class LabelEntityPartnerScopeSaveResult
@@ -60,6 +63,10 @@ public static class LabelEntityPartnerScopeHelper
         public bool HasCategoryPartnerTable { get; init; }
  
         public bool HasMultipleOptionPartnerTable { get; init; }
+
+        public bool HasProductCategoryPartnerColumn { get; init; }
+
+        public bool HasProductCategoryPartnerTable { get; init; }
     }
  
     /// <summary>
@@ -185,7 +192,7 @@ public static class LabelEntityPartnerScopeHelper
         if (needsPartnerRows && !hasTable)
         {
             throw new UserFriendlyException(
-                "Company 适用范围关联表尚未就绪，请联系管理员执行数据库迁移（fl_label_entity_partner_scope.sql）后重试");
+                "Company 适用范围关联表尚未就绪，请联系管理员执行数据库迁移（fl_label_entity_partner_scope.sql 或 fl_product_category_partner_scope.sql）后重试");
         }
  
         if (hasTable)
@@ -325,11 +332,30 @@ public static class LabelEntityPartnerScopeHelper
                 ? AllCompaniesDisplay
                 : BuildCompanyDisplay(pIds, partnerNameById);
  
+            List<string> displayPartnerIds;
+            if (string.Equals(partnerType, ScopeAll, StringComparison.OrdinalIgnoreCase))
+            {
+                displayPartnerIds = new List<string> { AllScopeBindingHelper.ScopeAll };
+            }
+            else
+            {
+                var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
+                    db,
+                    pIds,
+                    null,
+                    null,
+                    new ScopeAllEchoHelper.ScopeAllEchoOptions
+                    {
+                        AppliedPartnerType = partnerType
+                    });
+                displayPartnerIds = collapsed.PartnerIds;
+            }
+
             result[entityId] = new LabelEntityPartnerScopeDisplay
             {
                 Company = companyDisplay,
                 AppliedPartnerType = partnerType,
-                PartnerIds = pIds
+                PartnerIds = displayPartnerIds
             };
         }
  
@@ -383,11 +409,13 @@ public static class LabelEntityPartnerScopeHelper
             return query.Where(_ => false);
         }
  
+        // Company=ALL：传任意 partnerId 均命中；SPECIFIED：须与关联表有交集
         return query.Where(t =>
-            t.AppliedPartnerType == ScopeSpecified
-            && SqlFunc.Subqueryable<FlLabelTypePartnerDbEntity>()
-                .Where(p => p.LabelTypeId == t.Id && scopedPartnerIds.Contains(p.PartnerId))
-                .Any());
+            t.AppliedPartnerType == ScopeAll
+            || (t.AppliedPartnerType == ScopeSpecified
+                && SqlFunc.Subqueryable<FlLabelTypePartnerDbEntity>()
+                    .Where(p => p.LabelTypeId == t.Id && scopedPartnerIds.Contains(p.PartnerId))
+                    .Any()));
     }
  
     /// <summary>
@@ -415,10 +443,11 @@ public static class LabelEntityPartnerScopeHelper
         }
  
         return query.Where(c =>
-            c.AppliedPartnerType == ScopeSpecified
-            && SqlFunc.Subqueryable<FlLabelCategoryPartnerDbEntity>()
-                .Where(p => p.CategoryId == c.Id && scopedPartnerIds.Contains(p.PartnerId))
-                .Any());
+            c.AppliedPartnerType == ScopeAll
+            || (c.AppliedPartnerType == ScopeSpecified
+                && SqlFunc.Subqueryable<FlLabelCategoryPartnerDbEntity>()
+                    .Where(p => p.CategoryId == c.Id && scopedPartnerIds.Contains(p.PartnerId))
+                    .Any()));
     }
  
     /// <summary>
@@ -446,14 +475,48 @@ public static class LabelEntityPartnerScopeHelper
         }
  
         return query.Where(o =>
-            o.AppliedPartnerType == ScopeSpecified
-            && SqlFunc.Subqueryable<FlLabelMultipleOptionPartnerDbEntity>()
-                .Where(p => p.MultipleOptionId == o.Id && scopedPartnerIds.Contains(p.PartnerId))
-                .Any());
+            o.AppliedPartnerType == ScopeAll
+            || (o.AppliedPartnerType == ScopeSpecified
+                && SqlFunc.Subqueryable<FlLabelMultipleOptionPartnerDbEntity>()
+                    .Where(p => p.MultipleOptionId == o.Id && scopedPartnerIds.Contains(p.PartnerId))
+                    .Any()));
+    }
+
+    /// <summary>
+    /// 列表筛选：按可见 Company 过滤产品分类。
+    /// </summary>
+    public static async Task<ISugarQueryable<FlProductCategoryDbEntity>> ApplyProductCategoryPartnerListFilterAsync(
+        ISqlSugarClient db,
+        ISugarQueryable<FlProductCategoryDbEntity> query,
+        IReadOnlyList<string>? scopedPartnerIds)
+    {
+        if (scopedPartnerIds is null)
+        {
+            return query;
+        }
+
+        var schema = await GetSchemaStatusAsync(db);
+        if (!HasPartnerTableForKind(schema, LabelEntityPartnerKind.ProductCategory))
+        {
+            return query;
+        }
+
+        if (scopedPartnerIds.Count == 0)
+        {
+            return query.Where(_ => false);
+        }
+
+        return query.Where(c =>
+            c.AppliedPartnerType == ScopeAll
+            || (c.AppliedPartnerType == ScopeSpecified
+                && SqlFunc.Subqueryable<FlProductCategoryPartnerDbEntity>()
+                    .Where(p => p.CategoryId == c.Id && scopedPartnerIds.Contains(p.PartnerId))
+                    .Any()));
     }
  
     /// <summary>
     /// 由 Query <c>partnerId</c> 解析列表 Company 筛选 Id；未传则返回 <c>null</c>。
+    /// Id 统一为小写 Guid，避免与关联表大小写不一致导致 IN 匹配失败。
     /// </summary>
     public static async Task<List<string>?> ResolveScopedPartnerIdsForListAsync(
         ISqlSugarClient db,
@@ -467,7 +530,13 @@ public static class LabelEntityPartnerScopeHelper
  
         var exists = await db.Queryable<FlPartnerDbEntity>()
             .AnyAsync(x => !x.IsDeleted && x.Id == pid);
-        return exists ? new List<string> { pid } : new List<string>();
+        if (!exists)
+        {
+            return new List<string>();
+        }
+
+        var key = TeamMemberListScopeHelper.NormalizeScopeKey(pid);
+        return string.IsNullOrEmpty(key) ? new List<string> { pid } : new List<string> { key };
     }
  
     /// <summary>
@@ -514,6 +583,11 @@ public static class LabelEntityPartnerScopeHelper
                     .Where(x => x.MultipleOptionId == entityId)
                     .ExecuteCommandAsync();
                 break;
+            case LabelEntityPartnerKind.ProductCategory:
+                await db.Deleteable<FlProductCategoryPartnerDbEntity>()
+                    .Where(x => x.CategoryId == entityId)
+                    .ExecuteCommandAsync();
+                break;
         }
     }
  
@@ -564,7 +638,10 @@ public static class LabelEntityPartnerScopeHelper
                     db, "fl_label_multiple_option", "AppliedPartnerType"),
                 HasTypePartnerTable = await TableExistsAsync(db, "fl_label_type_partner"),
                 HasCategoryPartnerTable = await TableExistsAsync(db, "fl_label_category_partner"),
-                HasMultipleOptionPartnerTable = await TableExistsAsync(db, "fl_label_multiple_option_partner")
+                HasMultipleOptionPartnerTable = await TableExistsAsync(db, "fl_label_multiple_option_partner"),
+                HasProductCategoryPartnerColumn = await ColumnExistsAsync(
+                    db, "fl_product_category", "AppliedPartnerType"),
+                HasProductCategoryPartnerTable = await TableExistsAsync(db, "fl_product_category_partner")
             };
         }
         catch
@@ -581,6 +658,7 @@ public static class LabelEntityPartnerScopeHelper
             LabelEntityPartnerKind.Type => schema.HasTypePartnerTable,
             LabelEntityPartnerKind.Category => schema.HasCategoryPartnerTable,
             LabelEntityPartnerKind.MultipleOption => schema.HasMultipleOptionPartnerTable,
+            LabelEntityPartnerKind.ProductCategory => schema.HasProductCategoryPartnerTable,
             _ => false
         };
  
@@ -590,6 +668,7 @@ public static class LabelEntityPartnerScopeHelper
             LabelEntityPartnerKind.Type => schema.HasTypePartnerColumn,
             LabelEntityPartnerKind.Category => schema.HasCategoryPartnerColumn,
             LabelEntityPartnerKind.MultipleOption => schema.HasMultipleOptionPartnerColumn,
+            LabelEntityPartnerKind.ProductCategory => schema.HasProductCategoryPartnerColumn,
             _ => false
         };
  
@@ -637,6 +716,7 @@ public static class LabelEntityPartnerScopeHelper
             LabelEntityPartnerKind.Type => "fl_label_type",
             LabelEntityPartnerKind.Category => "fl_label_category",
             LabelEntityPartnerKind.MultipleOption => "fl_label_multiple_option",
+            LabelEntityPartnerKind.ProductCategory => "fl_product_category",
             _ => string.Empty
         };
  
@@ -666,6 +746,7 @@ public static class LabelEntityPartnerScopeHelper
             LabelEntityPartnerKind.Type => "fl_label_type",
             LabelEntityPartnerKind.Category => "fl_label_category",
             LabelEntityPartnerKind.MultipleOption => "fl_label_multiple_option",
+            LabelEntityPartnerKind.ProductCategory => "fl_product_category",
             _ => string.Empty
         };
  
@@ -709,6 +790,13 @@ public static class LabelEntityPartnerScopeHelper
                     .ToListAsync();
                 return rows.Select(x => (x.MultipleOptionId, x.PartnerId)).ToList();
             }
+            case LabelEntityPartnerKind.ProductCategory:
+            {
+                var rows = await db.Queryable<FlProductCategoryPartnerDbEntity>()
+                    .Where(x => entityIds.Contains(x.CategoryId))
+                    .ToListAsync();
+                return rows.Select(x => (x.CategoryId, x.PartnerId)).ToList();
+            }
             default:
                 return new List<(string EntityId, string PartnerId)>();
         }
@@ -764,6 +852,19 @@ public static class LabelEntityPartnerScopeHelper
                 await db.Insertable(rows).ExecuteCommandAsync();
                 break;
             }
+            case LabelEntityPartnerKind.ProductCategory:
+            {
+                var rows = partnerIds.Select(pid => new FlProductCategoryPartnerDbEntity
+                {
+                    Id = guidGenerator.Create().ToString(),
+                    CategoryId = entityId,
+                    PartnerId = pid,
+                    CreationTime = now,
+                    CreatorId = currentUserId
+                }).ToList();
+                await db.Insertable(rows).ExecuteCommandAsync();
+                break;
+            }
         }
     }
  
@@ -28,6 +28,7 @@ public static class LabelQueryHelper
             LabelName = x.LabelName,
             TemplateId = x.TemplateId,
             LocationId = x.LocationId,
+            PartnerId = x.PartnerId,
             LabelCategoryId = x.LabelCategoryId,
             LabelTypeId = x.LabelTypeId,
             LabelType = x.LabelType,
@@ -58,12 +58,40 @@ public static class LabelRegionScopeHelper
         IReadOnlyList<string>? regionIds,
         IReadOnlyList<string>? groupIds,
         string? locationId,
-        IReadOnlyList<string>? locationIds)
+        IReadOnlyList<string>? locationIds,
+        IReadOnlyList<string>? partnerIdsForContext = null)
     {
-        var mergedRegionIds = NormalizeRegionIds(regionIds, groupIds);
-        var explicitLocationIds = MergeExplicitLocationIds(locationId, locationIds);
+        var mergedRegionIdsRaw = NormalizeRegionIds(regionIds, groupIds);
+        var explicitLocationIdsRaw = MergeExplicitLocationIds(locationId, locationIds);
+        var regionHasAll = LocationScopeBindingHelper.ContainsAllScopeSentinel(mergedRegionIdsRaw);
+        var locationHasAll = LocationScopeBindingHelper.ContainsAllScopeSentinel(explicitLocationIdsRaw);
+        var mergedRegionIds = LocationScopeBindingHelper.FilterConcreteScopeIds(mergedRegionIdsRaw);
+        var explicitLocationIds = LocationScopeBindingHelper.FilterConcreteScopeIds(explicitLocationIdsRaw);
         var type = (appliedRegionType ?? AppliedRegionAll).Trim().ToUpperInvariant();
         var hasScopeArrays = regionIds is not null || groupIds is not null || locationIds is not null;
+        var partnerContext = LocationScopeBindingHelper.NormalizeIds(partnerIdsForContext);
+
+        // locationIds / regionIds 含 ALL 哨兵：不归档为 Guid 校验，按全选处理（Company 由 fl_label.PartnerId 落库）
+        if (locationHasAll || (regionHasAll && explicitLocationIds.Count == 0))
+        {
+            return new LabelRegionScopeSaveResult
+            {
+                AppliedRegionType = AppliedRegionAll,
+                RegionIds = new List<string>(),
+                LocationIds = new List<string>()
+            };
+        }
+
+        if (regionHasAll && explicitLocationIds.Count > 0)
+        {
+            await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(db, explicitLocationIds);
+            return new LabelRegionScopeSaveResult
+            {
+                AppliedRegionType = AppliedRegionAll,
+                RegionIds = new List<string>(),
+                LocationIds = explicitLocationIds
+            };
+        }
  
         if (mergedRegionIds.Count > 0)
         {
@@ -95,8 +123,10 @@ public static class LabelRegionScopeHelper
             await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(db, explicitLocationIds);
         }
  
-        var partnerContext = await ResolvePartnerContextAsync(db, mergedRegionIds, explicitLocationIds);
-        var allRegions = await AllScopeBindingHelper.ResolveAllRegionIdsAsync(db, partnerContext);
+        var resolvedPartnerContext = partnerContext.Count > 0
+            ? partnerContext
+            : await ResolvePartnerContextAsync(db, mergedRegionIds, explicitLocationIds);
+        var allRegions = await AllScopeBindingHelper.ResolveAllRegionIdsAsync(db, resolvedPartnerContext);
         var regionsFull = mergedRegionIds.Count > 0
             && AllScopeBindingHelper.IsFullIdSelection(mergedRegionIds, allRegions);
  
@@ -107,7 +137,7 @@ public static class LabelRegionScopeHelper
         if (declaredOrFullAll)
         {
             var allLocationsForPartner = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(
-                db, partnerContext, null);
+                db, resolvedPartnerContext, null);
             var locationsFullForPartner = explicitLocationIds.Count == 0
                 || (allLocationsForPartner.Count > 0
                     && AllScopeBindingHelper.IsFullIdSelection(explicitLocationIds, allLocationsForPartner));
@@ -135,7 +165,7 @@ public static class LabelRegionScopeHelper
         if (mergedRegionIds.Count == 0 && explicitLocationIds.Count > 0)
         {
             var allLocations = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(
-                db, partnerContext, null);
+                db, resolvedPartnerContext, null);
             if (allLocations.Count > 0
                 && AllScopeBindingHelper.IsFullIdSelection(explicitLocationIds, allLocations))
             {
@@ -157,7 +187,7 @@ public static class LabelRegionScopeHelper
  
         // 部分 Region：门店 Select All（空或覆盖该区域全集）→ 只落 Region，不写门店快照（新区店靠 Region 动态匹配）
         var allLocationsInRegions = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(
-            db, null, mergedRegionIds);
+            db, resolvedPartnerContext, mergedRegionIds);
         var locationsFullInRegions = explicitLocationIds.Count == 0
             || (allLocationsInRegions.Count > 0
                 && AllScopeBindingHelper.IsFullIdSelection(explicitLocationIds, allLocationsInRegions));
@@ -179,7 +209,7 @@ public static class LabelRegionScopeHelper
  
         // 部分 Region + 部分门店 → 校验门店属于所选 Region 后落快照
         var mergedLocations = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
-            db, (IReadOnlyList<string>?)null, mergedRegionIds, explicitLocationIds);
+            db, resolvedPartnerContext, mergedRegionIds, explicitLocationIds);
         if (mergedLocations.Count == 0)
         {
             throw new UserFriendlyException("指定 Region 下未匹配到有效门店，请检查 Region 或 locationIds");
@@ -405,8 +435,8 @@ public static class LabelRegionScopeHelper
             return new LabelRegionScopeDisplay
             {
                 Region = AllRegionsDisplay,
-                RegionIds = new List<string>(),
-                GroupIds = new List<string>()
+                RegionIds = new List<string> { AllScopeBindingHelper.ScopeAll },
+                GroupIds = new List<string> { AllScopeBindingHelper.ScopeAll }
             };
         }
  
@@ -435,11 +465,18 @@ public static class LabelRegionScopeHelper
             ? string.Join(", ", names.Where(n => !string.IsNullOrWhiteSpace(n)).Select(n => n!.Trim()).Distinct())
             : "?";
  
+        var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
+            db,
+            null,
+            regionIds,
+            locationIds,
+            ScopeAllEchoHelper.ForLabelRegionScope(appliedRegionType, locationIds));
+
         return new LabelRegionScopeDisplay
         {
             Region = regionText,
-            RegionIds = regionIds,
-            GroupIds = regionIds
+            RegionIds = collapsed.RegionIds,
+            GroupIds = collapsed.RegionIds
         };
     }
  
@@ -454,7 +491,7 @@ public static class LabelRegionScopeHelper
             return new LabelLocationScopeDisplay
             {
                 Location = AllLocationsDisplay,
-                LocationIds = new List<string>()
+                LocationIds = new List<string> { AllScopeBindingHelper.ScopeAll }
             };
         }
  
@@ -482,10 +519,17 @@ public static class LabelRegionScopeHelper
             ? string.Join(", ", names.Where(n => !string.IsNullOrWhiteSpace(n)).Select(n => n!.Trim()).Distinct())
             : "?";
  
+        var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
+            db,
+            null,
+            null,
+            locationIds,
+            ScopeAllEchoHelper.ForLabelRegionScope(appliedRegionType, locationIds));
+
         return new LabelLocationScopeDisplay
         {
             Location = locationText,
-            LocationIds = locationIds.ToList()
+            LocationIds = collapsed.LocationIds
         };
     }
  
@@ -593,7 +637,24 @@ public static class LabelRegionScopeHelper
             new { all = AppliedRegionAll, gid });
     }
  
-    /// <summary>? scoped ?????<c>fl_label_location</c> ???? <c>LocationId</c>??</summary>
+    /// <summary>
+    /// 无可见门店时：仅保留 <c>AppliedRegionType=ALL</c> 的标签（用于 PartnerId 筛选但该公司暂无门店）。
+    /// </summary>
+    public static ISugarQueryable<FlLabelDbEntity> ApplyLabelAllRegionOnlyFilter(
+        ISqlSugarClient db,
+        ISugarQueryable<FlLabelDbEntity> query,
+        LabelRegionSchemaHelper.LabelRegionSchemaStatus schema)
+    {
+        if (!schema.HasAppliedRegionTypeColumn)
+        {
+            // 未迁移列时无法识别 ALL，保守返回空
+            return query.Where(_ => false);
+        }
+
+        return query.Where("AppliedRegionType = @all", new { all = AppliedRegionAll });
+    }
+
+    /// <summary>按 scoped 门店过滤；AppliedRegionType=ALL 对任意门店筛选均命中。</summary>
     public static ISugarQueryable<FlLabelDbEntity> ApplyLabelLocationListFilter(
         ISqlSugarClient db,
         ISugarQueryable<FlLabelDbEntity> query,
@@ -602,7 +663,7 @@ public static class LabelRegionScopeHelper
     {
         if (scopedLocationIds.Count == 0)
         {
-            return query.Where(_ => false);
+            return ApplyLabelAllRegionOnlyFilter(db, query, schema);
         }
  
         return ApplyLabelLocationMatchFilter(query, scopedLocationIds, schema);
@@ -648,6 +709,14 @@ public static class LabelRegionScopeHelper
             var locationIds = await GetLocationIdsForLabelAsync(db, label.Id, label.LocationId);
             if (locationIds.Count == 0)
             {
+                // 指定 Company 的 ALL：仅该公司下门店可用
+                if (!string.IsNullOrWhiteSpace(label.PartnerId))
+                {
+                    var locPartners = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(
+                        db, new List<string> { locationId.Trim() });
+                    return locPartners.Contains(label.PartnerId.Trim(), StringComparer.OrdinalIgnoreCase);
+                }
+
                 return true;
             }
  
@@ -784,6 +853,26 @@ public static class LabelRegionScopeHelper
         List<string> scopedLocationIds,
         LabelRegionSchemaHelper.LabelRegionSchemaStatus schema)
     {
+        if (schema.HasAppliedRegionTypeColumn && schema.HasLabelLocationTable)
+        {
+            return query.Where(
+                """
+                (AppliedRegionType = @all
+                 OR LocationId IN (@locs)
+                 OR EXISTS (SELECT 1 FROM fl_label_location ll WHERE ll.LabelId = fl_label.Id AND ll.LocationId IN (@locs)))
+                """,
+                new { all = AppliedRegionAll, locs = scopedLocationIds });
+        }
+
+        if (schema.HasAppliedRegionTypeColumn)
+        {
+            return query.Where(
+                """
+                (AppliedRegionType = @all OR LocationId IN (@locs))
+                """,
+                new { all = AppliedRegionAll, locs = scopedLocationIds });
+        }
+
         if (schema.HasLabelLocationTable)
         {
             return query.Where(
@@ -829,17 +918,18 @@ public static class LabelRegionScopeHelper
  
     private static async Task ValidateRegionIdsExistAsync(ISqlSugarClient db, List<string> regionIds)
     {
-        if (regionIds.Count == 0)
+        var ids = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+        if (ids.Count == 0)
         {
             return;
         }
  
         var count = await db.Queryable<FlGroupDbEntity>()
-            .Where(g => !g.IsDeleted && regionIds.Contains(g.Id))
+            .Where(g => !g.IsDeleted && ids.Contains(g.Id))
             .CountAsync();
-        if (count != regionIds.Count)
+        if (count != ids.Count)
         {
-            throw new UserFriendlyException("????? Region Id???????");
+            throw new UserFriendlyException("存在无效的 Region Id，请刷新后重试");
         }
     }
 }
@@ -58,43 +58,73 @@ public static class LabelTemplateScopeHelper
  
     /// <summary>
     /// 解析新增/编辑入参中的 Company / Region / Location 范围。
+    /// Create/Update 共用；<c>regionIds</c>、<c>groupIds</c>、<c>locationIds</c>、<c>appliedLocationIds</c> 可传哨兵 <c>ALL</c>，
+    /// 即使 <c>appliedRegionType</c> / <c>appliedLocation</c> 为 <c>SPECIFIED</c> 也会归档为对应维度 <c>ALL</c> 且不写关联快照。
     /// </summary>
     public static async Task<LabelTemplateScopeSaveResult> ResolveScopeForSaveAsync(
         ISqlSugarClient db,
         LabelTemplateCreateInputVo input)
     {
-        var partnerIds = NormalizePartnerIds(input);
-        var regionIds = NormalizeRegionIds(input);
-        var locationIds = MergeExplicitLocationIds(input);
+        var mergedRegionIds = NormalizeRegionIds(input);
+        var mergedLocationIds = MergeExplicitLocationIds(input);
+        var hasRegionArray = input.RegionIds is not null || input.GroupIds is not null;
+        var hasLocationArray = input.LocationIds is not null || input.AppliedLocationIds is not null;
+
+        // Create/Update 共用：优先识别 ALL 哨兵，避免后续 Count>0 或 Guid 存在性校验误伤编辑回显的 ["ALL"]
+        var locationHasAll = AllScopeBindingHelper.HasAllScopeSentinelSelection(mergedLocationIds);
+        var regionHasAll = AllScopeBindingHelper.HasAllScopeSentinelSelection(mergedRegionIds);
+        var concreteLocations = LocationScopeBindingHelper.FilterConcreteScopeIds(mergedLocationIds);
  
         var (partnerType, partnerIdsForSave) = await AllScopeBindingHelper.NormalizePartnerScopeAsync(
             db,
             input.AppliedPartnerType,
-            partnerIds,
-            null,
+            input.PartnerIds,
+            input.CompanyIds,
             input.PartnerIds is not null || input.CompanyIds is not null);
-        partnerIds = partnerIdsForSave;
+        var partnerIds = partnerIdsForSave;
  
         var partnerContext = string.Equals(partnerType, ScopeSpecified, StringComparison.OrdinalIgnoreCase)
             ? partnerIds
             : null;
  
-        var (regionType, regionIdsForSave) = await AllScopeBindingHelper.NormalizeRegionScopeAsync(
-            db,
-            input.AppliedRegionType,
-            regionIds,
-            input.RegionIds is not null || input.GroupIds is not null,
-            partnerContext);
-        regionIds = regionIdsForSave;
+        string regionType;
+        List<string> regionIds;
+        if (regionHasAll && concreteLocations.Count == 0)
+        {
+            regionType = ScopeAll;
+            regionIds = new List<string>();
+        }
+        else
+        {
+            var regionResult = await AllScopeBindingHelper.NormalizeRegionScopeAsync(
+                db,
+                input.AppliedRegionType,
+                LocationScopeBindingHelper.FilterConcreteScopeIds(mergedRegionIds),
+                hasRegionArray,
+                partnerContext);
+            regionType = regionResult.Type;
+            regionIds = regionResult.Ids;
+        }
  
-        var (locationType, locationIdsForSave) = await AllScopeBindingHelper.NormalizeLocationScopeAsync(
-            db,
-            input.AppliedLocationType,
-            locationIds,
-            input.LocationIds is not null || input.AppliedLocationIds is not null,
-            partnerContext,
-            string.Equals(regionType, ScopeSpecified, StringComparison.OrdinalIgnoreCase) ? regionIds : null);
-        locationIds = locationIdsForSave;
+        string locationType;
+        List<string> locationIds;
+        if (locationHasAll)
+        {
+            locationType = ScopeAll;
+            locationIds = new List<string>();
+        }
+        else
+        {
+            var locationResult = await AllScopeBindingHelper.NormalizeLocationScopeAsync(
+                db,
+                input.AppliedLocationType,
+                concreteLocations,
+                hasLocationArray,
+                partnerContext,
+                string.Equals(regionType, ScopeSpecified, StringComparison.OrdinalIgnoreCase) ? regionIds : null);
+            locationType = locationResult.Type;
+            locationIds = locationResult.Ids;
+        }
  
         ValidateDimensionType("Company", partnerType);
         ValidateDimensionType("Region", regionType);
@@ -134,7 +164,9 @@ public static class LabelTemplateScopeHelper
                            || string.Equals(regionType, ScopeSpecified, StringComparison.OrdinalIgnoreCase)
                            || string.Equals(locationType, ScopeSpecified, StringComparison.OrdinalIgnoreCase);
  
-        if (anySpecified)
+        if (anySpecified
+            && (string.Equals(regionType, ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+                || string.Equals(locationType, ScopeSpecified, StringComparison.OrdinalIgnoreCase)))
         {
             var merged = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
                 db,
@@ -300,6 +332,8 @@ public static class LabelTemplateScopeHelper
             .Where(x => templateIds.Contains(x.TemplateId))
             .ToListAsync();
  
+        var storedScopeTypes = await LabelTemplateScopeSchemaHelper.GetAppliedScopeTypesMapAsync(db, templateIds);
+
         var partnerIdSet = partnerLinks.Select(x => x.PartnerId).Distinct(StringComparer.Ordinal).ToList();
         var regionIdSet = regionLinks.Select(x => x.GroupId).Distinct(StringComparer.Ordinal).ToList();
         var locationIdSet = locationLinks.Select(x => x.LocationId).Distinct(StringComparer.Ordinal).ToList();
@@ -360,9 +394,16 @@ public static class LabelTemplateScopeHelper
             var partnerType = pIds.Count > 0 ? ScopeSpecified : ScopeAll;
             var regionType = rIds.Count > 0 ? ScopeSpecified : ScopeAll;
  
+            if (storedScopeTypes.TryGetValue(template.Id, out var storedTypes))
+            {
+                partnerType = NormalizeScopeType(storedTypes.PartnerType, partnerType);
+                regionType = NormalizeScopeType(storedTypes.RegionType, regionType);
+            }
+
             if (hasExtendedScope
                 && pIds.Count == 0
-                && lIds.Count > 0)
+                && lIds.Count > 0
+                && !string.Equals(partnerType, ScopeSpecified, StringComparison.OrdinalIgnoreCase))
             {
                 pIds = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(db, lIds);
                 if (pIds.Count > 0)
@@ -373,7 +414,8 @@ public static class LabelTemplateScopeHelper
  
             if (hasExtendedScope
                 && rIds.Count == 0
-                && lIds.Count > 0)
+                && lIds.Count > 0
+                && !string.Equals(regionType, ScopeSpecified, StringComparison.OrdinalIgnoreCase))
             {
                 rIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(db, lIds);
                 if (rIds.Count > 0)
@@ -401,6 +443,13 @@ public static class LabelTemplateScopeHelper
                 ? AllLocationsDisplay
                 : FormatLocationNames(lIds, locById);
  
+            var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
+                db,
+                pIds,
+                rIds,
+                lIds,
+                ScopeAllEchoHelper.ForLabelTemplateDimensions(partnerType, regionType, locationType));
+
             result[template.Id] = new LabelTemplateScopeDisplay
             {
                 Company = companyDisplay,
@@ -409,9 +458,9 @@ public static class LabelTemplateScopeHelper
                 AppliedPartnerType = partnerType,
                 AppliedRegionType = regionType,
                 AppliedLocationType = locationType,
-                PartnerIds = pIds,
-                RegionIds = rIds,
-                LocationIds = lIds
+                PartnerIds = collapsed.PartnerIds,
+                RegionIds = collapsed.RegionIds,
+                LocationIds = collapsed.LocationIds
             };
         }
  
@@ -419,31 +468,58 @@ public static class LabelTemplateScopeHelper
     }
  
     /// <summary>
-    /// 列表权限：按当前用户可见门店筛选模板（各维度 AND）。
-    /// <paramref name="scopedLocationIds"/> 为 <c>null</c> 时不限制（管理员且未传 Query 筛选）；
-    /// 非空时仅返回与可见 Company/Region/Location 匹配的模板，不包含未绑定任何范围的「全局」模板。
+    /// 列表筛选：按当前用户可见范围筛选模板。
+    /// 仅传 <c>partnerId</c> 时只按 Company 维度过滤（多公司绑定不会被门店 AND 误杀）。
     /// </summary>
     public static async Task<ISugarQueryable<FlLabelTemplateDbEntity>> ApplyTemplateScopeFilterAsync(
         ISqlSugarClient db,
         ISugarQueryable<FlLabelTemplateDbEntity> query,
-        List<string>? scopedLocationIds)
+        List<string>? scopedLocationIds,
+        string? partnerId = null,
+        string? groupId = null,
+        string? locationId = null)
     {
+        var hasExtendedScope = await LabelTemplateScopeSchemaHelper.HasPartnerRegionScopeTablesAsync(db);
+        var schema = await LabelTemplateScopeSchemaHelper.GetStatusAsync(db);
+
+        // 仅 PartnerId：只返回 fl_label_template_partner 含该公司的模板。
+        // 不含 AppliedPartnerType=ALL（全公司模板在未传 PartnerId 时可见）；
+        // 也不把「无关联行」当成 ALL，避免其他公司数据漏出。
+        if (!LabelEntityListScopeHelper.ShouldApplyLocationAvailabilityFilter(partnerId, groupId, locationId)
+            && !string.IsNullOrWhiteSpace(partnerId))
+        {
+            var pid = partnerId.Trim();
+            if (!schema.HasPartnerScopeTable)
+            {
+                return query.Where(_ => false);
+            }
+
+            return query.Where(t =>
+                SqlFunc.Subqueryable<FlLabelTemplatePartnerDbEntity>()
+                    .Where(p => p.TemplateId == t.Id && p.PartnerId == pid)
+                    .Any());
+        }
+
         if (scopedLocationIds is null)
         {
             return query;
         }
  
-        var hasExtendedScope = await LabelTemplateScopeSchemaHelper.HasPartnerRegionScopeTablesAsync(db);
-
         if (scopedLocationIds.Count == 0)
         {
-            return query.Where(_ => false);
+            // 无可见门店：保留 Location=ALL（及无 location 关联）的模板
+            return query.Where(t =>
+                t.AppliedLocationType == ScopeAll
+                || !SqlFunc.Subqueryable<FlLabelTemplateLocationDbEntity>()
+                    .Where(l => l.TemplateId == t.Id)
+                    .Any());
         }
  
         if (!hasExtendedScope)
         {
             return query.Where(t =>
-                SqlFunc.Subqueryable<FlLabelTemplateLocationDbEntity>()
+                t.AppliedLocationType == ScopeAll
+                || SqlFunc.Subqueryable<FlLabelTemplateLocationDbEntity>()
                     .Where(l => l.TemplateId == t.Id && scopedLocationIds.Contains(l.LocationId))
                     .Any());
         }
@@ -453,6 +529,30 @@ public static class LabelTemplateScopeHelper
         var scopedGroupIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(
             db, scopedLocationIds);
  
+        // Company：AppliedPartnerType=ALL 或关联命中（不用「无行=ALL」）
+        if (schema.HasAppliedPartnerTypeColumn)
+        {
+            return query.Where(
+                """
+                (AppliedPartnerType = @all
+                 OR EXISTS (SELECT 1 FROM fl_label_template_partner p
+                            WHERE p.TemplateId = fl_label_template.Id AND p.PartnerId IN (@partnerIds)))
+                AND (NOT EXISTS (SELECT 1 FROM fl_label_template_region r WHERE r.TemplateId = fl_label_template.Id)
+                     OR EXISTS (SELECT 1 FROM fl_label_template_region r
+                                WHERE r.TemplateId = fl_label_template.Id AND r.GroupId IN (@groupIds)))
+                AND (AppliedLocationType = @all
+                     OR EXISTS (SELECT 1 FROM fl_label_template_location l
+                                WHERE l.TemplateId = fl_label_template.Id AND l.LocationId IN (@locs)))
+                """,
+                new
+                {
+                    all = ScopeAll,
+                    partnerIds = scopedPartnerIds,
+                    groupIds = scopedGroupIds.Count > 0 ? scopedGroupIds : new List<string> { "__none__" },
+                    locs = scopedLocationIds
+                });
+        }
+
         return query.Where(t =>
             SqlFunc.Subqueryable<FlLabelTemplatePartnerDbEntity>()
                 .Where(p => p.TemplateId == t.Id && scopedPartnerIds.Contains(p.PartnerId))
@@ -567,15 +667,16 @@ public static class LabelTemplateScopeHelper
  
     private static async Task ValidateRegionIdsExistAsync(ISqlSugarClient db, List<string> regionIds)
     {
-        if (regionIds.Count == 0)
+        var ids = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+        if (ids.Count == 0)
         {
             return;
         }
  
         var count = await db.Queryable<FlGroupDbEntity>()
-            .Where(x => !x.IsDeleted && regionIds.Contains(x.Id))
+            .Where(x => !x.IsDeleted && ids.Contains(x.Id))
             .CountAsync();
-        if (count != regionIds.Count)
+        if (count != ids.Count)
         {
             throw new UserFriendlyException("存在无效的 Region（regionIds/groupIds），请刷新后重试");
         }
@@ -315,6 +315,77 @@ public static class LabelTemplateScopeSchemaHelper
         return map.TryGetValue(templateId.Trim(), out var text) ? text : null;
     }
  
+    /// <summary>批量读取模板 Company/Region 维度 ALL/SPECIFIED；列不存在时返回空字典。</summary>
+    public static async Task<Dictionary<string, (string PartnerType, string RegionType)>> GetAppliedScopeTypesMapAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<string> templateIds)
+    {
+        var result = new Dictionary<string, (string PartnerType, string RegionType)>(StringComparer.Ordinal);
+        if (templateIds.Count == 0)
+        {
+            return result;
+        }
+
+        var status = await GetStatusAsync(db);
+        if (!status.HasAppliedPartnerTypeColumn && !status.HasAppliedRegionTypeColumn)
+        {
+            return result;
+        }
+
+        var ids = templateIds.Where(x => !string.IsNullOrWhiteSpace(x))
+            .Select(x => x.Trim())
+            .Distinct(StringComparer.Ordinal)
+            .ToArray();
+        if (ids.Length == 0)
+        {
+            return result;
+        }
+
+        var rows = await db.Ado.SqlQueryAsync<AppliedScopeTypesRow>(
+            """
+            SELECT Id, AppliedPartnerType, AppliedRegionType
+            FROM fl_label_template
+            WHERE Id IN (@ids)
+            """,
+            new { ids });
+
+        foreach (var row in rows)
+        {
+            if (string.IsNullOrWhiteSpace(row.Id))
+            {
+                continue;
+            }
+
+            var partnerType = status.HasAppliedPartnerTypeColumn
+                ? NormalizeScopeTypeValue(row.AppliedPartnerType)
+                : ScopeAll;
+            var regionType = status.HasAppliedRegionTypeColumn
+                ? NormalizeScopeTypeValue(row.AppliedRegionType)
+                : ScopeAll;
+            result[row.Id.Trim()] = (partnerType, regionType);
+        }
+
+        return result;
+    }
+
+    private static string NormalizeScopeTypeValue(string? type)
+    {
+        var normalized = (type ?? ScopeAll).Trim().ToUpperInvariant();
+        return normalized == ScopeSpecified ? ScopeSpecified : ScopeAll;
+    }
+
+    private const string ScopeAll = "ALL";
+    private const string ScopeSpecified = "SPECIFIED";
+
+    private sealed class AppliedScopeTypesRow
+    {
+        public string Id { get; init; } = string.Empty;
+
+        public string? AppliedPartnerType { get; init; }
+
+        public string? AppliedRegionType { get; init; }
+    }
+
     /// <summary>已迁移 <c>Contents</c> 列时写入（未迁移则 no-op）。</summary>
     public static async Task SetContentsAsync(ISqlSugarClient db, string templateId, string? contents)
     {
@@ -306,13 +306,14 @@ public static class LocationScopeBindingHelper
             merged.Add(id);
         }
  
-        var fromGroups = await ResolveLocationIdsFromGroupIdsAsync(db, groupIds);
+        var concreteGroupIds = FilterConcreteScopeIds(groupIds);
+        var fromGroups = await ResolveLocationIdsFromGroupIdsAsync(db, concreteGroupIds);
         foreach (var id in fromGroups)
         {
             merged.Add(id);
         }
  
-        foreach (var id in NormalizeIds(locationIds))
+        foreach (var id in FilterConcreteScopeIds(locationIds))
         {
             merged.Add(id);
         }
@@ -321,6 +322,113 @@ public static class LocationScopeBindingHelper
     }
  
     /// <summary>
+    /// 多选 Id 是否含 <c>ALL</c> 哨兵（大小写不敏感）。与具体 Guid 同传时以 ALL 为准（全选）。
+    /// </summary>
+    public static bool IsAllScopeSentinel(string? value) =>
+        string.Equals(value?.Trim(), AllScopeBindingHelper.ScopeAll, StringComparison.OrdinalIgnoreCase);
+
+    /// <summary>Id 列表是否含 <c>ALL</c> 哨兵。</summary>
+    public static bool ContainsAllScopeSentinel(IReadOnlyList<string>? ids) =>
+        ids?.Any(IsAllScopeSentinel) == true;
+
+    /// <summary>去掉 ALL 哨兵，仅保留具体 Id。</summary>
+    public static List<string> FilterConcreteScopeIds(IReadOnlyList<string>? ids) =>
+        NormalizeIds(ids).Where(x => !IsAllScopeSentinel(x)).ToList();
+
+    /// <summary>
+    /// Team Member 门店范围落库（不做 partner+region+location 并集）。
+    /// 优先级：
+    /// 1) <c>locationIds</c> 含 ALL → 公司全部门店；
+    /// 2) 有具体 <c>locationIds</c>，且 <c>regionIds</c> 为空或为 ALL → 只绑这些门店（UI 在 Region=ALL 下再收窄门店）；
+    /// 3) <c>regionIds</c> 含 ALL → 公司全部 Region 下门店；
+    /// 4) 具体 <c>regionIds</c> → 按 Region 展开（忽略同传 locationIds，保证多区域能落库）；
+    /// 5) 仅 <paramref name="partnerIds"/> → 公司全部门店。
+    /// </summary>
+    public static async Task<List<string>> ResolveTeamMemberLocationIdsForSaveAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<string>? partnerIds,
+        IReadOnlyList<string>? regionIds,
+        IReadOnlyList<string>? locationIds)
+    {
+        var normalizedPartners = NormalizeIds(partnerIds);
+        var locationHasAll = ContainsAllScopeSentinel(locationIds);
+        var concreteLocations = FilterConcreteScopeIds(locationIds);
+        var regionHasAll = ContainsAllScopeSentinel(regionIds);
+        var concreteRegions = FilterConcreteScopeIds(regionIds);
+
+        // 1. locationIds 含 ALL：有具体 Region 时展开该 Region；否则按 Company 全部门店
+        if (locationHasAll)
+        {
+            var expanded = await ExpandScopedAllLocationsForSaveAsync(
+                db,
+                normalizedPartners.Count > 0 ? normalizedPartners : null,
+                concreteRegions.Count > 0 ? concreteRegions : null);
+            if (expanded is not null)
+            {
+                return expanded;
+            }
+
+            throw new UserFriendlyException("选择全部门店时需指定 Company（partnerId / partnerIds）或 Region");
+        }
+
+        // 2. 具体门店 +（无区域 / 区域为 ALL）→ 只绑这些门店，避免 regionIds=ALL 盖掉单店
+        if (concreteLocations.Count > 0 && (regionHasAll || concreteRegions.Count == 0))
+        {
+            return concreteLocations;
+        }
+
+        // 3. regionIds 含 ALL（且无具体门店）→ 按 partner 展开全部 Region 下门店
+        if (regionHasAll)
+        {
+            if (normalizedPartners.Count == 0)
+            {
+                throw new UserFriendlyException("选择全部 Region 时需指定 Company（partnerId / partnerIds）");
+            }
+
+            return await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, normalizedPartners, null);
+        }
+
+        // 4. 具体 regionIds
+        if (concreteRegions.Count > 0)
+        {
+            var fromRegions = await ExpandScopedAllLocationsForSaveAsync(
+                db,
+                normalizedPartners.Count > 0 ? normalizedPartners : null,
+                concreteRegions);
+            var regionLocs = fromRegions ?? new List<string>();
+
+            // 同传具体门店：若已覆盖该区全集（前端 Location=ALL 常展开 Guid）→ 用区内全部门店；
+            // 否则保留子集（Region 具体 + 部分门店）
+            if (concreteLocations.Count > 0)
+            {
+                if (regionLocs.Count > 0
+                    && AllScopeBindingHelper.IsFullIdSelection(concreteLocations, regionLocs))
+                {
+                    return regionLocs;
+                }
+
+                return concreteLocations;
+            }
+
+            return regionLocs;
+        }
+
+        // 5. 仅有具体 locationIds → 只绑这些门店
+        if (concreteLocations.Count > 0)
+        {
+            return concreteLocations;
+        }
+
+        // 6. 仅有 partner → 绑该公司全部门店
+        if (normalizedPartners.Count > 0)
+        {
+            return await MergeToLocationIdsAsync(db, normalizedPartners, null, null);
+        }
+
+        return new List<string>();
+    }
+
+    /// <summary>
     /// 标签类型/分类/多选项门店范围落库：仅按 Region/Location 合并，不因 Company（partner）展开并集。
     /// </summary>
     public static async Task<List<string>> ResolveEntityLocationIdsForSaveAsync(
@@ -334,11 +442,28 @@ public static class LocationScopeBindingHelper
             return new List<string>();
         }
  
+        if (ContainsAllScopeSentinel(locationIds)
+            || (ContainsAllScopeSentinel(regionIds)
+                && FilterConcreteScopeIds(locationIds).Count == 0))
+        {
+            throw new UserFriendlyException("门店范围含 ALL 哨兵时应归档为 ALL，不应进入 SPECIFIED 落库校验");
+        }
+
+        var concreteRegions = FilterConcreteScopeIds(regionIds);
+        var concreteLocations = FilterConcreteScopeIds(locationIds);
+
+        // 有具体门店时以门店为准（不再与 Region 并集展开），避免「选 1 个 Location + 同传 Region」落成整 Region 再回显成 ALL
+        if (concreteLocations.Count > 0)
+        {
+            await ValidateLocationIdsExistAsync(db, concreteLocations);
+            return concreteLocations;
+        }
+
         var merged = await MergeToLocationIdsAsync(
             db,
             (IReadOnlyList<string>?)null,
-            regionIds,
-            locationIds);
+            concreteRegions,
+            concreteLocations);
         if (merged.Count == 0)
         {
             throw new UserFriendlyException("指定适用区域或门店时，至少需要匹配到一个有效门店");
@@ -349,6 +474,52 @@ public static class LocationScopeBindingHelper
     }
  
     /// <summary>
+    /// 将「范围内 ALL」展开为门店 Id：优先按具体 Region，其次按具体 Company；两者皆无则返回 null（调用方归档全局 ALL）。
+    /// </summary>
+    public static async Task<List<string>?> ExpandScopedAllLocationsForSaveAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<string>? partnerIds,
+        IReadOnlyList<string>? regionIds)
+    {
+        var concreteRegions = FilterConcreteScopeIds(regionIds);
+        if (concreteRegions.Count > 0)
+        {
+            var fromRegions = await ResolveLocationIdsFromGroupIdsAsync(db, concreteRegions);
+            var partners = NormalizeIds(partnerIds);
+            if (partners.Count > 0)
+            {
+                var partnerLocSet = new HashSet<string>(
+                    await ResolveLocationIdsFromPartnerIdsAsync(db, partners),
+                    StringComparer.OrdinalIgnoreCase);
+                fromRegions = fromRegions.Where(id => partnerLocSet.Contains(id)).ToList();
+            }
+
+            if (fromRegions.Count == 0)
+            {
+                throw new UserFriendlyException("指定 Region 下未匹配到有效门店");
+            }
+
+            await ValidateLocationIdsExistAsync(db, fromRegions);
+            return fromRegions;
+        }
+
+        var concretePartners = NormalizeIds(partnerIds);
+        if (concretePartners.Count > 0)
+        {
+            var fromPartners = await ResolveLocationIdsFromPartnerIdsAsync(db, concretePartners);
+            if (fromPartners.Count == 0)
+            {
+                throw new UserFriendlyException("指定 Company 下未匹配到有效门店");
+            }
+
+            await ValidateLocationIdsExistAsync(db, fromPartners);
+            return fromPartners;
+        }
+
+        return null;
+    }
+
+    /// <summary>
     /// 根据已绑定门店反推适用的 Company Id（<c>fl_partner.Id</c>）。
     /// </summary>
     public static async Task<List<string>> ResolvePartnerIdsFromLocationIdsAsync(
@@ -591,7 +762,7 @@ public static class LocationScopeBindingHelper
     /// </summary>
     public static async Task ValidateLocationIdsExistAsync(ISqlSugarClient db, IReadOnlyList<string> locationIds)
     {
-        var ids = NormalizeIds(locationIds);
+        var ids = FilterConcreteScopeIds(locationIds);
         if (ids.Count == 0)
         {
             return;
+using FoodLabeling.Application.Services.DbModels;
+
+namespace FoodLabeling.Application.Helpers;
+
+/// <summary>
+/// 平台端菜单判定（与 ThSaasMenuPermissionCatalog.IsPlatformOnlyMenu 一致，避免 Application 依赖 Th 程序集）
+/// </summary>
+public static class PlatformMenuHelper
+{
+    /// <summary>
+    /// 是否为仅平台端菜单（不可分配给公司）
+    /// </summary>
+    public static bool IsPlatformOnlyMenu(MenuDbEntity? menu)
+    {
+        if (menu == null)
+        {
+            return true;
+        }
+
+        var code = menu.PermissionCode?.Trim() ?? string.Empty;
+        if (code.StartsWith("menu.platform", StringComparison.OrdinalIgnoreCase))
+        {
+            return true;
+        }
+
+        var router = menu.Router?.Trim() ?? string.Empty;
+        return router.StartsWith("/platform", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// 从全量菜单中保留平台菜单及其祖先节点，以便组装菜单树
+    /// </summary>
+    public static List<MenuDbEntity> FilterPlatformMenusWithAncestors(IReadOnlyList<MenuDbEntity> allMenus)
+    {
+        if (allMenus.Count == 0)
+        {
+            return new List<MenuDbEntity>();
+        }
+
+        var byId = allMenus
+            .GroupBy(m => m.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
+
+        var keepIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var menu in allMenus.Where(IsPlatformOnlyMenu))
+        {
+            IncludeWithAncestors(menu.Id, byId, keepIds);
+        }
+
+        return allMenus.Where(m => keepIds.Contains(m.Id)).ToList();
+    }
+
+    private static void IncludeWithAncestors(
+        string menuId,
+        IReadOnlyDictionary<string, MenuDbEntity> byId,
+        HashSet<string> keepIds)
+    {
+        if (!byId.TryGetValue(menuId, out var current))
+        {
+            return;
+        }
+
+        if (!keepIds.Add(current.Id))
+        {
+            return;
+        }
+
+        var parentId = current.ParentId?.Trim() ?? "0";
+        if (parentId == "0" || parentId == Guid.Empty.ToString())
+        {
+            return;
+        }
+
+        IncludeWithAncestors(parentId, byId, keepIds);
+    }
+
+    /// <summary>
+    /// 仅保留公司已开通菜单及其祖先节点（租户业务库 menu 表可能含 Seed 全量菜单）。
+    /// </summary>
+    public static List<MenuDbEntity> FilterCompanyMenusWithAncestors(
+        IReadOnlyList<MenuDbEntity> allMenus,
+        IReadOnlySet<string> enabledMenuIds)
+    {
+        if (allMenus.Count == 0 || enabledMenuIds.Count == 0)
+        {
+            return new List<MenuDbEntity>();
+        }
+
+        var byId = allMenus
+            .Where(m => !m.IsDeleted && !IsPlatformOnlyMenu(m))
+            .GroupBy(m => m.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
+
+        var keepIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var menuId in enabledMenuIds)
+        {
+            IncludeWithAncestors(menuId?.Trim() ?? string.Empty, byId, keepIds);
+        }
+
+        return allMenus.Where(m => keepIds.Contains(m.Id)).ToList();
+    }
+}
@@ -67,6 +67,18 @@ public static class ReportsPrintLogExpiryHelper
     public static string ExtractFormattedExpiryText(string? printInputJson) =>
         ExtractFormattedExpiryText(printInputJson, null, null, null);
  
+    /// <summary>与 Print Log Expiration 同源：解析绝对过期时刻。</summary>
+    public static bool TryResolveExpiryDateTime(
+        string? printInputJson,
+        string? renderTemplateJson,
+        DateTime? baseTime,
+        DateTime? printedAt,
+        out DateTime expiresAt)
+    {
+        var reference = baseTime ?? printedAt ?? DateTime.Now;
+        return TryResolveExpiryDateTime(printInputJson, renderTemplateJson, reference, out expiresAt);
+    }
+
     private static bool TryResolveExpiryDateTime(
         string? printInputJson,
         string? renderTemplateJson,
+using SqlSugar;
 using Volo.Abp.Users;
 using Yi.Framework.Rbac.Domain.Shared.Consts;
  
@@ -66,4 +67,28 @@ public static class ReportsRoleHelper
  
         return false;
     }
+
+    /// <summary>
+    /// App JWT 未写入角色声明时，按业务库 UserRole/Role 判断是否管理员。
+    /// </summary>
+    public static async Task<bool> IsAdminRoleFromDbAsync(ISqlSugarClient db, Guid userId)
+    {
+        var rows = await db.Ado.SqlQueryAsync<AdminRoleCodeRow>(
+            """
+            SELECT r.RoleCode
+            FROM UserRole ur
+            INNER JOIN Role r ON ur.RoleId = r.Id
+            WHERE ur.UserId = @UserId AND r.IsDeleted = 0 AND r.State = 1
+            """,
+            new { UserId = userId });
+
+        return rows.Any(r =>
+            !string.IsNullOrWhiteSpace(r.RoleCode) &&
+            string.Equals(r.RoleCode.Trim(), UserConst.AdminRolesCode, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private sealed class AdminRoleCodeRow
+    {
+        public string? RoleCode { get; set; }
+    }
 }
+using SqlSugar;
+
+namespace FoodLabeling.Application.Helpers;
+
+/// <summary>
+/// 编辑/列表回显：库中可存展开 Guid；若绑定覆盖全集则将 Id 数组折叠为 <c>["ALL"]</c> 哨兵（对齐 Team Member）。
+/// </summary>
+public static class ScopeAllEchoHelper
+{
+    public sealed class ScopeAllEchoOptions
+    {
+        public bool IsPartnerAll { get; init; }
+
+        public bool IsRegionAll { get; init; }
+
+        public bool IsLocationAll { get; init; }
+
+        /// <summary>落库维度为 SPECIFIED 时禁止再按「恰好全选」折叠为 ALL 哨兵。</summary>
+        public string? AppliedPartnerType { get; init; }
+
+        public string? AppliedRegionType { get; init; }
+
+        public string? AppliedLocationType { get; init; }
+    }
+
+    /// <summary>
+    /// 将 partnerIds / regionIds / locationIds 折叠为 ALL 哨兵（编辑弹窗与列表 Id 数组回显）。
+    /// </summary>
+    public static async Task<(List<string> PartnerIds, List<string> RegionIds, List<string> LocationIds)>
+        CollapseScopeIdsToAllSentinelAsync(
+            ISqlSugarClient db,
+            IReadOnlyList<string>? partnerIds,
+            IReadOnlyList<string>? regionIds,
+            IReadOnlyList<string>? locationIds,
+            ScopeAllEchoOptions? options = null)
+    {
+        options ??= new ScopeAllEchoOptions();
+        var partners = LocationScopeBindingHelper.NormalizeIds(partnerIds);
+        var regions = LocationScopeBindingHelper.NormalizeIds(regionIds);
+        var locations = LocationScopeBindingHelper.NormalizeIds(locationIds);
+
+        if (options.IsPartnerAll)
+        {
+            partners = new List<string> { AllScopeBindingHelper.ScopeAll };
+        }
+        else if (!AllScopeBindingHelper.IsDeclaredSpecified(options.AppliedPartnerType) && partners.Count > 0)
+        {
+            var allPartners = await AllScopeBindingHelper.ResolveAllPartnerIdsAsync(db);
+            if (allPartners.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(partners, allPartners))
+            {
+                partners = new List<string> { AllScopeBindingHelper.ScopeAll };
+            }
+        }
+
+        if (options.IsRegionAll)
+        {
+            regions = new List<string> { AllScopeBindingHelper.ScopeAll };
+        }
+        else if (!AllScopeBindingHelper.IsDeclaredSpecified(options.AppliedRegionType) && regions.Count > 0)
+        {
+            regions = await CollapseRegionsIfFullAsync(db, partners, regions);
+        }
+
+        if (options.IsLocationAll)
+        {
+            locations = new List<string> { AllScopeBindingHelper.ScopeAll };
+        }
+        else if (!AllScopeBindingHelper.IsDeclaredSpecified(options.AppliedLocationType) && locations.Count > 0)
+        {
+            locations = await CollapseLocationsIfFullAsync(db, partners, regions, locations);
+        }
+
+        return (partners, regions, locations);
+    }
+
+    /// <summary>AvailabilityType=ALL 时 Region 与 Location 均为 ALL。</summary>
+    public static ScopeAllEchoOptions ForAvailabilityAll(bool isAll) =>
+        new() { IsRegionAll = isAll, IsLocationAll = isAll };
+
+    /// <summary>LabelTemplate 各维度独立 ALL 标记。</summary>
+    public static ScopeAllEchoOptions ForLabelTemplateDimensions(
+        string? appliedPartnerType,
+        string? appliedRegionType,
+        string? appliedLocationType) =>
+        new()
+        {
+            IsPartnerAll = AllScopeBindingHelper.IsDeclaredAll(appliedPartnerType),
+            IsRegionAll = AllScopeBindingHelper.IsDeclaredAll(appliedRegionType),
+            IsLocationAll = AllScopeBindingHelper.IsDeclaredAll(appliedLocationType),
+            AppliedPartnerType = appliedPartnerType,
+            AppliedRegionType = appliedRegionType,
+            AppliedLocationType = appliedLocationType
+        };
+
+    /// <summary>标签类型/分类/多选项：Company + Region + Location 可用范围。</summary>
+    public static ScopeAllEchoOptions ForLabelEntityScope(
+        string? appliedPartnerType,
+        string? appliedRegionType,
+        string? availabilityType) =>
+        new()
+        {
+            IsPartnerAll = AllScopeBindingHelper.IsDeclaredAll(appliedPartnerType),
+            IsRegionAll = AllScopeBindingHelper.IsDeclaredAll(appliedRegionType),
+            IsLocationAll = AllScopeBindingHelper.IsDeclaredAll(availabilityType),
+            AppliedPartnerType = appliedPartnerType,
+            AppliedRegionType = appliedRegionType,
+            AppliedLocationType = availabilityType
+        };
+
+    /// <summary>兼容旧调用：无 Region 类型时用 AvailabilityType 同时驱动 Region/Location。</summary>
+    public static ScopeAllEchoOptions ForLabelEntityScope(
+        string? appliedPartnerType,
+        string? availabilityType) =>
+        ForLabelEntityScope(appliedPartnerType, availabilityType, availabilityType);
+
+    /// <summary>Label：AppliedRegionType=ALL 且未落门店快照时 Region/Location 均为 ALL。</summary>
+    public static ScopeAllEchoOptions ForLabelRegionScope(
+        string? appliedRegionType,
+        IReadOnlyList<string> locationIds)
+    {
+        var isRegionAll = AllScopeBindingHelper.IsDeclaredAll(appliedRegionType);
+        var normalizedLocations = LocationScopeBindingHelper.NormalizeIds(locationIds);
+        var isLocationAll = isRegionAll && normalizedLocations.Count == 0;
+        return new ScopeAllEchoOptions
+        {
+            IsRegionAll = isRegionAll,
+            IsLocationAll = isLocationAll,
+            AppliedRegionType = appliedRegionType,
+            AppliedLocationType = isLocationAll
+                ? AllScopeBindingHelper.ScopeAll
+                : AllScopeBindingHelper.ScopeSpecified
+        };
+    }
+
+    private static async Task<List<string>> CollapseRegionsIfFullAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<string> partners,
+        IReadOnlyList<string> regions)
+    {
+        var partnerContext = ResolvePartnerContextForCollapse(partners);
+        var allRegionIds = partnerContext is { Count: > 0 }
+            ? await LocationScopeBindingHelper.ResolveGroupIdsFromPartnerIdsAsync(db, partnerContext)
+            : await AllScopeBindingHelper.ResolveAllRegionIdsAsync(db, null);
+
+        if (allRegionIds.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(regions, allRegionIds))
+        {
+            return new List<string> { AllScopeBindingHelper.ScopeAll };
+        }
+
+        return regions.ToList();
+    }
+
+    private static async Task<List<string>> CollapseLocationsIfFullAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<string> partners,
+        IReadOnlyList<string> regions,
+        IReadOnlyList<string> locations)
+    {
+        var partnerContext = ResolvePartnerContextForCollapse(partners);
+        List<string> allLocationIds;
+
+        if (regions.Count == 1 && AllScopeBindingHelper.IsDeclaredAll(regions[0]))
+        {
+            allLocationIds = partnerContext is { Count: > 0 }
+                ? await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partnerContext)
+                : await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, null, null);
+        }
+        else if (regions.Count > 0 && !regions.Any(r => AllScopeBindingHelper.IsDeclaredAll(r)))
+        {
+            allLocationIds = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, partnerContext, regions);
+        }
+        else if (partnerContext is { Count: > 0 })
+        {
+            allLocationIds = await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partnerContext);
+        }
+        else
+        {
+            allLocationIds = await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, null, null);
+        }
+
+        if (allLocationIds.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(locations, allLocationIds))
+        {
+            // 具体 Region：覆盖该区全部门店时一律回显 ["ALL"]（含区内仅 1 店；前端 ALL 常展开为具体 Guid）
+            var hasConcreteRegions = regions.Count > 0
+                                     && !regions.Any(AllScopeBindingHelper.IsDeclaredAll);
+            if (hasConcreteRegions)
+            {
+                return new List<string> { AllScopeBindingHelper.ScopeAll };
+            }
+
+            // Region=ALL（或无具体 Region）时：仅多店才折叠，避免「Region=ALL + 选 1 店」误成 Location ALL
+            if (locations.Count > 1 || allLocationIds.Count > 1)
+            {
+                return new List<string> { AllScopeBindingHelper.ScopeAll };
+            }
+        }
+
+        return locations.ToList();
+    }
+
+    private static List<string>? ResolvePartnerContextForCollapse(IReadOnlyList<string> partners)
+    {
+        if (partners.Count == 0 || AllScopeBindingHelper.IsDeclaredAll(partners[0]))
+        {
+            return null;
+        }
+
+        return partners.ToList();
+    }
+}
@@ -26,7 +26,8 @@ public static class TeamMemberScopeDisplayHelper
         Guid? roleId,
         IReadOnlyList<string> partnerIds,
         IReadOnlyList<string> regionIds,
-        IReadOnlyList<TeamMemberAssignedLocationDto> assigned)
+        IReadOnlyList<TeamMemberAssignedLocationDto> assigned,
+        string? appliedLocationType = null)
     {
         var assignedIds = assigned
             .Select(x => x.Id)
@@ -35,30 +36,43 @@ public static class TeamMemberScopeDisplayHelper
             .Distinct(StringComparer.Ordinal)
             .ToList();
  
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedLocationType))
+        {
+            if (partnerIds.Count > 0)
+            {
+                var concreteRegions = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+                var universe = concreteRegions.Count > 0
+                    ? await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, partnerIds, concreteRegions)
+                    : await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partnerIds);
+                if (universe.Count > 0
+                    && !AllScopeBindingHelper.IsFullIdSelection(assignedIds, universe))
+                {
+                    return assigned.ToList();
+                }
+            }
+
+            return AllLocationDisplay;
+        }
+
         if (assignedIds.Count == 0)
         {
             return assigned.ToList();
         }
  
-        if (await TeamMemberRoleHelper.IsCompanyAdminRoleAsync(db, roleId) && partnerIds.Count > 0)
+        if (partnerIds.Count > 0)
         {
-            var allPartnerLocationIds = await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(
-                db, partnerIds);
-            if (allPartnerLocationIds.Count > 0 &&
-                AllScopeBindingHelper.IsFullIdSelection(assignedIds, allPartnerLocationIds))
+            // 有具体 Region 时按 Region 范围内全选判断；否则按 Company 全部门店
+            var concreteRegions = LocationScopeBindingHelper.FilterConcreteScopeIds(regionIds);
+            var universe = concreteRegions.Count > 0
+                ? await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, partnerIds, concreteRegions)
+                : await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partnerIds);
+            if (universe.Count > 0 &&
+                AllScopeBindingHelper.IsFullIdSelection(assignedIds, universe))
             {
                 return AllLocationDisplay;
             }
         }
  
-        var universeLocationIds = await LocationScopeBindingHelper.MergeToLocationIdsAsync(
-            db, partnerIds, regionIds, null);
-        if (universeLocationIds.Count > 0 &&
-            AllScopeBindingHelper.IsFullIdSelection(assignedIds, universeLocationIds))
-        {
-            return AllLocationDisplay;
-        }
-
         return assigned.ToList();
     }
  
@@ -69,8 +83,15 @@ public static class TeamMemberScopeDisplayHelper
         ISqlSugarClient db,
         IReadOnlyList<string> partnerIds,
         IReadOnlyList<string> regionIds,
-        IReadOnlyDictionary<string, string> regionNameMap)
+        IReadOnlyDictionary<string, string> regionNameMap,
+        string? appliedRegionType = null)
     {
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedRegionType)
+            || (regionIds.Count == 1 && AllScopeBindingHelper.IsDeclaredAll(regionIds[0])))
+        {
+            return FoodLabelingDisplayConsts.AllRegion;
+        }
+
         if (regionIds.Count == 0)
         {
             return FoodLabelingDisplayConsts.NotAvailable;
@@ -92,6 +113,118 @@ public static class TeamMemberScopeDisplayHelper
                     : id));
     }
  
+    /// <summary>
+    /// 编辑回显：库中存展开后的 Guid；结合 AppliedRegionType/AppliedLocationType 折叠为 <c>["ALL"]</c>。
+    /// </summary>
+    public static async Task<(List<string> RegionIds, List<string> LocationIds, List<TeamMemberAssignedLocationDto> Assigned)>
+        CollapseScopeIdsToAllSentinelForEditAsync(
+            ISqlSugarClient db,
+            IReadOnlyList<string> partnerIds,
+            IReadOnlyList<string> regionIds,
+            IReadOnlyList<string> locationIds,
+            IReadOnlyList<TeamMemberAssignedLocationDto> assigned,
+            string? appliedRegionType = null,
+            string? appliedLocationType = null)
+    {
+        var partners = LocationScopeBindingHelper.NormalizeIds(partnerIds);
+        var regions = LocationScopeBindingHelper.NormalizeIds(regionIds);
+        var locations = LocationScopeBindingHelper.NormalizeIds(locationIds);
+        var assignedList = assigned?.ToList() ?? new List<TeamMemberAssignedLocationDto>();
+
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedRegionType))
+        {
+            regions = new List<string> { AllScopeBindingHelper.ScopeAll };
+        }
+
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedLocationType))
+        {
+            // 误标 ALL 但库中仅为部分门店时，回显具体 Id（与新增传参对称）
+            if (locations.Count > 0 && partners.Count > 0)
+            {
+                var scopedRegions = LocationScopeBindingHelper.FilterConcreteScopeIds(regions);
+                var universe = scopedRegions.Count > 0
+                    ? await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, partners, scopedRegions)
+                    : await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partners);
+                if (!AllScopeBindingHelper.IsFullIdSelection(locations, universe))
+                {
+                    return (regions, locations, assignedList);
+                }
+            }
+
+            locations = new List<string> { AllScopeBindingHelper.ScopeAll };
+            assignedList = AllLocationDisplay;
+            return (regions, locations, assignedList);
+        }
+
+        // 落库为 SPECIFIED（显式选店）：禁止再按「区内恰好全选」折叠成 ALL
+        if (AllScopeBindingHelper.IsDeclaredSpecified(appliedLocationType))
+        {
+            if (partners.Count == 0)
+            {
+                return (regions, locations, assignedList);
+            }
+
+            if (!AllScopeBindingHelper.IsDeclaredAll(appliedRegionType))
+            {
+                var allRegionIds = await LocationScopeBindingHelper.ResolveGroupIdsFromPartnerIdsAsync(db, partners);
+                if (allRegionIds.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(regions, allRegionIds))
+                {
+                    regions = new List<string> { AllScopeBindingHelper.ScopeAll };
+                }
+            }
+
+            return (regions, locations, assignedList);
+        }
+
+        if (partners.Count == 0)
+        {
+            return (regions, locations, assignedList);
+        }
+
+        if (!AllScopeBindingHelper.IsDeclaredAll(appliedRegionType))
+        {
+            var allRegionIds = await LocationScopeBindingHelper.ResolveGroupIdsFromPartnerIdsAsync(db, partners);
+            if (allRegionIds.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(regions, allRegionIds))
+            {
+                regions = new List<string> { AllScopeBindingHelper.ScopeAll };
+            }
+        }
+
+        // Region=ALL + 具体门店：禁止再按「派生单 Region 区内全选」把 Location 折成 ALL
+        if (AllScopeBindingHelper.IsDeclaredAll(appliedRegionType)
+            || (regions.Count == 1 && AllScopeBindingHelper.IsDeclaredAll(regions[0])))
+        {
+            var partnerUniverse = await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(
+                db, partners);
+            if (partnerUniverse.Count > 1
+                && locations.Count > 1
+                && AllScopeBindingHelper.IsFullIdSelection(locations, partnerUniverse))
+            {
+                locations = new List<string> { AllScopeBindingHelper.ScopeAll };
+                assignedList = AllLocationDisplay;
+            }
+
+            return (regions, locations, assignedList);
+        }
+
+        // 具体 Region：按区内门店全集判断是否折叠 locationIds
+        var concreteRegions = LocationScopeBindingHelper.FilterConcreteScopeIds(regions);
+        var allLocationIds = concreteRegions.Count > 0
+            ? await AllScopeBindingHelper.ResolveAllLocationIdsAsync(db, partners, concreteRegions)
+            : await LocationScopeBindingHelper.ResolveLocationIdsFromPartnerIdsAsync(db, partners);
+        if (allLocationIds.Count > 0 && AllScopeBindingHelper.IsFullIdSelection(locations, allLocationIds))
+        {
+            var hasConcreteRegions = concreteRegions.Count > 0;
+            if (hasConcreteRegions || locations.Count > 1 || allLocationIds.Count > 1)
+            {
+                locations = new List<string> { AllScopeBindingHelper.ScopeAll };
+                assignedList = AllLocationDisplay;
+            }
+        }
+
+        return (regions, locations, assignedList);
+    }
+
     public static string FormatLocationTextForList(IReadOnlyList<TeamMemberAssignedLocationDto> assigned)
     {
         if (assigned.Count == 0)
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using Microsoft.AspNetCore.Http;
+using Volo.Abp.MultiTenancy;
+using Volo.Abp.Security.Claims;
+using Yi.Framework.Rbac.Domain.Shared.Consts;
+using Yi.Framework.SqlSugarCore.Abstractions;
+
+namespace FoodLabeling.Application.Helpers;
+
+/// <summary>
+/// SaaS 业务租户上下文判定（平台主库 / Default 租户不走公司菜单子集过滤）。
+/// </summary>
+public static class TenantBusinessContextHelper
+{
+    private static readonly Guid ProtectedDefaultTenantId = Guid.Parse("11111111-1111-1111-1111-111111111111");
+
+    /// <summary>
+    /// 解析当前请求的业务租户 Id：优先 <see cref="ICurrentTenant"/>，其次 JWT / Authorization Claim。
+    /// </summary>
+    public static Guid? ResolveBusinessTenantId(ICurrentTenant? currentTenant, HttpContext? httpContext)
+    {
+        if (currentTenant?.Id is { } fromContext
+            && fromContext != Guid.Empty
+            && fromContext != ProtectedDefaultTenantId)
+        {
+            return fromContext;
+        }
+
+        var fromJwt = TryGetTenantIdFromHttpContext(httpContext);
+        if (fromJwt.HasValue
+            && fromJwt.Value != Guid.Empty
+            && fromJwt.Value != ProtectedDefaultTenantId)
+        {
+            return fromJwt;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// 当前请求是否处于真实公司业务租户上下文（须按 fl_th_tenant_menu_permission 限定可分配菜单）。
+    /// </summary>
+    public static bool ShouldScopeMenusByCompany(
+        DbConnOptions options,
+        ICurrentTenant? currentTenant,
+        HttpContext? httpContext)
+    {
+        return ShouldScopeMenusByCompany(options, ResolveBusinessTenantId(currentTenant, httpContext));
+    }
+
+    /// <summary>
+    /// 当前请求是否处于真实公司业务租户上下文（须按 fl_th_tenant_menu_permission 限定可分配菜单）。
+    /// </summary>
+    public static bool ShouldScopeMenusByCompany(DbConnOptions options, Guid? tenantId)
+    {
+        return options.EnabledSaasMultiTenancy
+               && tenantId.HasValue
+               && tenantId.Value != Guid.Empty
+               && tenantId.Value != ProtectedDefaultTenantId;
+    }
+
+    /// <summary>
+    /// 从 HttpContext Principal 或 Authorization Bearer JWT 读取 TenantId Claim 原始值。
+    /// </summary>
+    public static string? TryGetTenantIdClaimValue(HttpContext? httpContext)
+    {
+        if (httpContext is null)
+        {
+            return null;
+        }
+
+        return TryGetTenantIdFromPrincipal(httpContext.User)
+               ?? TryGetTenantIdFromAuthorizationHeader(httpContext.Request.Headers.Authorization.ToString());
+    }
+
+    private static Guid? TryGetTenantIdFromHttpContext(HttpContext? httpContext)
+    {
+        var tenantClaim = TryGetTenantIdClaimValue(httpContext);
+        if (string.IsNullOrWhiteSpace(tenantClaim)
+            || !Guid.TryParse(tenantClaim, out var tenantGuid)
+            || tenantGuid == Guid.Empty)
+        {
+            return null;
+        }
+
+        return tenantGuid;
+    }
+
+    private static string? TryGetTenantIdFromPrincipal(ClaimsPrincipal? user)
+    {
+        if (user?.Identity?.IsAuthenticated != true)
+        {
+            return null;
+        }
+
+        return user.FindFirst(TokenTypeConst.TenantId)?.Value
+               ?? user.FindFirst(AbpClaimTypes.TenantId)?.Value
+               ?? user.Claims.FirstOrDefault(c =>
+                   c.Type.EndsWith("tenantId", StringComparison.OrdinalIgnoreCase)
+                   || c.Type.Equals("tenantid", StringComparison.OrdinalIgnoreCase))?.Value;
+    }
+
+    /// <summary>
+    /// 多租户中间件可能早于 JWT Principal 就绪；直接从 Authorization 解析 TenantId Claim。
+    /// </summary>
+    private static string? TryGetTenantIdFromAuthorizationHeader(string? authorization)
+    {
+        if (string.IsNullOrWhiteSpace(authorization))
+        {
+            return null;
+        }
+
+        const string bearerPrefix = "Bearer ";
+        if (!authorization.StartsWith(bearerPrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            return null;
+        }
+
+        var jwt = authorization[bearerPrefix.Length..].Trim();
+        if (string.IsNullOrWhiteSpace(jwt))
+        {
+            return null;
+        }
+
+        try
+        {
+            var token = new JwtSecurityTokenHandler().ReadJwtToken(jwt);
+            return token.Claims.FirstOrDefault(c =>
+                       c.Type == TokenTypeConst.TenantId
+                       || c.Type == AbpClaimTypes.TenantId
+                       || c.Type.EndsWith("tenantId", StringComparison.OrdinalIgnoreCase))
+                   ?.Value;
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+}
 using Volo.Abp;
 using Volo.Abp.MultiTenancy;
+using Yi.Framework.SqlSugarCore.Abstractions;
  
 namespace FoodLabeling.Application.Helpers;
  
@@ -8,9 +9,15 @@ namespace FoodLabeling.Application.Helpers;
 /// </summary>
 public static class TenantContextGuard
 {
+    /// <summary>
+    /// 平台主库登录（JWT/__tenant 均无业务租户）时访问 fl_* 等业务表的友好提示。
+    /// </summary>
+    public const string PlatformCannotAccessBusinessDataMessage =
+        "当前为平台主库登录，无法访问公司业务数据（标签/产品/成员等）。请选择具体公司登录，或使用平台「公司管理」相关接口。";
+
     public static void EnsureTenantResolved(ICurrentTenant currentTenant, string? operation = null)
     {
-        if (currentTenant.Id.HasValue)
+        if (currentTenant.Id.HasValue && currentTenant.Id.Value != Guid.Empty)
         {
             return;
         }
@@ -19,6 +26,78 @@ public static class TenantContextGuard
             ? "未识别租户上下文"
             : $"{operation}：未识别租户上下文";
         throw new UserFriendlyException(
-            $"{hint}。请使用泰额登录接口（th-web-auth / th-app-auth）或请求头 __tenant 携带租户 Id。");
+            $"{hint}。请使用泰额登录接口（th-web-auth / th-app-auth）选择具体公司登录，或请求头 __tenant 携带租户 Id。");
+    }
+
+    /// <summary>
+    /// 泰额 SaaS 多租户开启时，业务表（fl_* / location 等）必须走租户库，禁止落到 host。
+    /// </summary>
+    public static void EnsureBusinessTenantIfSaas(
+        ICurrentTenant currentTenant,
+        DbConnOptions? dbConnOptions,
+        string? operation = null)
+    {
+        if (dbConnOptions is null || !dbConnOptions.EnabledSaasMultiTenancy)
+        {
+            return;
+        }
+
+        EnsureTenantResolved(currentTenant, operation);
+    }
+
+    /// <summary>
+    /// 判断当前 DbContext 是否连到平台主库（antis-foodlabeling-host）。
+    /// </summary>
+    public static bool IsConnectedToHostDatabase(ISqlSugarDbContext dbContext, DbConnOptions dbConnOptions)
+    {
+        var dbName = dbContext.SqlSugarClient.Ado.Connection.Database;
+        var hostDbName = TryExtractDatabaseName(dbConnOptions.Url);
+        return !string.IsNullOrWhiteSpace(hostDbName)
+               && string.Equals(dbName, hostDbName, StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// SaaS 模式下校验 DbContext 未落到 host 主库（双保险，避免缺表 500）。
+    /// </summary>
+    public static void EnsureNotHostDatabaseIfSaas(
+        ISqlSugarDbContext dbContext,
+        DbConnOptions dbConnOptions,
+        string? operation = null)
+    {
+        if (!dbConnOptions.EnabledSaasMultiTenancy)
+        {
+            return;
+        }
+
+        if (!IsConnectedToHostDatabase(dbContext, dbConnOptions))
+        {
+            return;
+        }
+
+        var hint = string.IsNullOrWhiteSpace(operation)
+            ? PlatformCannotAccessBusinessDataMessage
+            : $"{operation}：{PlatformCannotAccessBusinessDataMessage}";
+        throw new UserFriendlyException(hint);
+    }
+
+    private static string? TryExtractDatabaseName(string? connectionString)
+    {
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            return null;
+        }
+
+        foreach (var part in connectionString.Split(';', StringSplitOptions.RemoveEmptyEntries))
+        {
+            var kv = part.Split('=', 2, StringSplitOptions.TrimEntries);
+            if (kv.Length == 2
+                && (kv[0].Equals("database", StringComparison.OrdinalIgnoreCase)
+                    || kv[0].Equals("Database", StringComparison.OrdinalIgnoreCase)))
+            {
+                return kv[1].Trim();
+            }
+        }
+
+        return null;
     }
 }
+using FoodLabeling.Application.Services.DbModels;
+using FoodLabeling.Domain.Shared.Helpers;
+using SqlSugar;
+using Volo.Abp;
+
+namespace FoodLabeling.Application.Helpers;
+
+/// <summary>
+/// 培训文件适用范围：Company / Region / Location 三维度独立 ALL/SPECIFIED。
+/// </summary>
+public static class TrainingFileScopeHelper
+{
+    public sealed class TrainingFileScopeSaveResult
+    {
+        public string AppliedPartnerType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public List<string> PartnerIds { get; init; } = new();
+
+        public string AppliedRegionType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public List<string> RegionIds { get; init; } = new();
+
+        public string AvailabilityType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public List<string> LocationIds { get; init; } = new();
+    }
+
+    public sealed class TrainingFileScopeDisplay
+    {
+        public string AppliedPartnerType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public string Company { get; init; } = LabelEntityPartnerScopeHelper.AllCompaniesDisplay;
+
+        public List<string> PartnerIds { get; init; } = new();
+
+        public string AppliedRegionType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public string Region { get; init; } = FoodLabelingDisplayConsts.AllRegion;
+
+        public List<string> RegionIds { get; init; } = new();
+
+        public string AvailabilityType { get; init; } = AllScopeBindingHelper.ScopeAll;
+
+        public string Location { get; init; } = FoodLabelingDisplayConsts.AllLocation;
+
+        public List<string> LocationIds { get; init; } = new();
+    }
+
+    public sealed class LocationScopeContext
+    {
+        public string LocationId { get; init; } = string.Empty;
+
+        public string? PartnerId { get; init; }
+
+        public string? GroupId { get; init; }
+    }
+
+    /// <summary>
+    /// 解析保存入参中的三维度范围。
+    /// </summary>
+    public static async Task<TrainingFileScopeSaveResult> ResolveScopeForSaveAsync(
+        ISqlSugarClient db,
+        string? appliedPartnerType,
+        IReadOnlyList<string>? partnerIds,
+        IReadOnlyList<string>? companyIds,
+        string? appliedRegionType,
+        IReadOnlyList<string>? regionIds,
+        IReadOnlyList<string>? groupIds,
+        string? availabilityType,
+        IReadOnlyList<string>? locationIds)
+    {
+        var partnerScope = await LabelEntityPartnerScopeHelper.ResolvePartnerScopeForSaveAsync(
+            db,
+            appliedPartnerType,
+            partnerIds,
+            companyIds);
+
+        var partnerContext = string.Equals(
+            partnerScope.AppliedPartnerType,
+            AllScopeBindingHelper.ScopeSpecified,
+            StringComparison.OrdinalIgnoreCase)
+            ? partnerScope.PartnerIds
+            : null;
+
+        var mergedRegionIds = NormalizeRegionIds(regionIds, groupIds);
+        var hasRegionArray = regionIds is not null || groupIds is not null;
+        var (regionType, regionIdsForSave) = await AllScopeBindingHelper.NormalizeRegionScopeAsync(
+            db,
+            appliedRegionType,
+            mergedRegionIds,
+            hasRegionArray,
+            partnerContext);
+
+        if (string.Equals(regionType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+            && regionIdsForSave.Count > 0)
+        {
+            await ValidateGroupIdsExistAsync(db, regionIdsForSave);
+        }
+
+        var hasLocationArray = locationIds is not null;
+        var (locationType, locationIdsForSave) = await AllScopeBindingHelper.NormalizeLocationScopeAsync(
+            db,
+            availabilityType,
+            locationIds ?? new List<string>(),
+            hasLocationArray,
+            partnerContext,
+            regionIdsForSave);
+
+        if (string.Equals(locationType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+            && locationIdsForSave.Count > 0)
+        {
+            await LocationScopeBindingHelper.ValidateLocationIdsExistAsync(db, locationIdsForSave);
+        }
+
+        return new TrainingFileScopeSaveResult
+        {
+            AppliedPartnerType = partnerScope.AppliedPartnerType,
+            PartnerIds = partnerScope.PartnerIds,
+            AppliedRegionType = regionType,
+            RegionIds = regionIdsForSave,
+            AvailabilityType = locationType,
+            LocationIds = locationIdsForSave
+        };
+    }
+
+    /// <summary>
+    /// 保存培训文件三维度范围关联。
+    /// </summary>
+    public static async Task SaveScopeAsync(
+        ISqlSugarClient db,
+        string trainingFileId,
+        TrainingFileScopeSaveResult scope,
+        string? currentUserId,
+        DateTime now)
+    {
+        await db.Deleteable<FlTrainingFilePartnerDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+        await db.Deleteable<FlTrainingFileRegionDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+        await db.Deleteable<FlTrainingFileLocationDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+
+        if (string.Equals(scope.AppliedPartnerType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+            && scope.PartnerIds.Count > 0)
+        {
+            var rows = scope.PartnerIds.Select(pid => new FlTrainingFilePartnerDbEntity
+            {
+                Id = YitIdHelper.NextId().ToString(),
+                TrainingFileId = trainingFileId,
+                PartnerId = pid,
+                CreationTime = now,
+                CreatorId = currentUserId
+            }).ToList();
+            await db.Insertable(rows).ExecuteCommandAsync();
+        }
+
+        if (string.Equals(scope.AppliedRegionType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+            && scope.RegionIds.Count > 0)
+        {
+            var rows = scope.RegionIds.Select(gid => new FlTrainingFileRegionDbEntity
+            {
+                Id = YitIdHelper.NextId().ToString(),
+                TrainingFileId = trainingFileId,
+                GroupId = gid,
+                CreationTime = now,
+                CreatorId = currentUserId
+            }).ToList();
+            await db.Insertable(rows).ExecuteCommandAsync();
+        }
+
+        if (string.Equals(scope.AvailabilityType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase)
+            && scope.LocationIds.Count > 0)
+        {
+            var rows = scope.LocationIds.Select(lid => new FlTrainingFileLocationDbEntity
+            {
+                Id = YitIdHelper.NextId().ToString(),
+                TrainingFileId = trainingFileId,
+                LocationId = lid,
+                CreationTime = now,
+                CreatorId = currentUserId
+            }).ToList();
+            await db.Insertable(rows).ExecuteCommandAsync();
+        }
+    }
+
+    /// <summary>
+    /// 构建多个培训文件的适用范围回显（列表/树批量用）。
+    /// </summary>
+    public static async Task<Dictionary<string, TrainingFileScopeDisplay>> BuildScopeDisplayMapAsync(
+        ISqlSugarClient db,
+        IReadOnlyList<FlTrainingFileDbEntity> files)
+    {
+        if (files.Count == 0)
+        {
+            return new Dictionary<string, TrainingFileScopeDisplay>(StringComparer.Ordinal);
+        }
+
+        var tasks = files.Select(async file =>
+            (file.Id, Display: await BuildScopeDisplayAsync(db, file)));
+        var results = await Task.WhenAll(tasks);
+        return results.ToDictionary(x => x.Id, x => x.Display, StringComparer.Ordinal);
+    }
+
+    /// <summary>
+    /// 删除培训文件全部范围关联。
+    /// </summary>
+    public static async Task DeleteScopeRowsAsync(ISqlSugarClient db, string trainingFileId)
+    {
+        await db.Deleteable<FlTrainingFilePartnerDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+        await db.Deleteable<FlTrainingFileRegionDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+        await db.Deleteable<FlTrainingFileLocationDbEntity>()
+            .Where(x => x.TrainingFileId == trainingFileId)
+            .ExecuteCommandAsync();
+    }
+
+    /// <summary>
+    /// 构建详情/编辑回显用的范围数据。
+    /// </summary>
+    public static async Task<TrainingFileScopeDisplay> BuildScopeDisplayAsync(
+        ISqlSugarClient db,
+        FlTrainingFileDbEntity file)
+    {
+        var partnerIds = string.Equals(
+            file.AppliedPartnerType,
+            AllScopeBindingHelper.ScopeSpecified,
+            StringComparison.OrdinalIgnoreCase)
+            ? await db.Queryable<FlTrainingFilePartnerDbEntity>()
+                .Where(x => x.TrainingFileId == file.Id)
+                .Select(x => x.PartnerId)
+                .ToListAsync()
+            : new List<string>();
+
+        var regionIds = string.Equals(
+            file.AppliedRegionType,
+            AllScopeBindingHelper.ScopeSpecified,
+            StringComparison.OrdinalIgnoreCase)
+            ? await db.Queryable<FlTrainingFileRegionDbEntity>()
+                .Where(x => x.TrainingFileId == file.Id)
+                .Select(x => x.GroupId)
+                .ToListAsync()
+            : new List<string>();
+
+        var locationIds = string.Equals(
+            file.AvailabilityType,
+            AllScopeBindingHelper.ScopeSpecified,
+            StringComparison.OrdinalIgnoreCase)
+            ? await db.Queryable<FlTrainingFileLocationDbEntity>()
+                .Where(x => x.TrainingFileId == file.Id)
+                .Select(x => x.LocationId)
+                .ToListAsync()
+            : new List<string>();
+
+        partnerIds = LocationScopeBindingHelper.NormalizeIds(partnerIds);
+        regionIds = LocationScopeBindingHelper.NormalizeIds(regionIds);
+        locationIds = LocationScopeBindingHelper.NormalizeIds(locationIds);
+
+        var collapsed = await ScopeAllEchoHelper.CollapseScopeIdsToAllSentinelAsync(
+            db,
+            partnerIds,
+            regionIds,
+            locationIds,
+            ScopeAllEchoHelper.ForLabelTemplateDimensions(
+                file.AppliedPartnerType,
+                file.AppliedRegionType,
+                file.AvailabilityType));
+
+        return new TrainingFileScopeDisplay
+        {
+            AppliedPartnerType = file.AppliedPartnerType,
+            Company = await BuildPartnerDisplayAsync(db, file.AppliedPartnerType, collapsed.PartnerIds),
+            PartnerIds = collapsed.PartnerIds,
+            AppliedRegionType = file.AppliedRegionType,
+            Region = await BuildRegionDisplayAsync(db, file.AppliedRegionType, collapsed.RegionIds),
+            RegionIds = collapsed.RegionIds,
+            AvailabilityType = file.AvailabilityType,
+            Location = await BuildLocationDisplayAsync(db, file.AvailabilityType, collapsed.LocationIds),
+            LocationIds = collapsed.LocationIds
+        };
+    }
+
+    /// <summary>
+    /// 按门店上下文过滤可见文件（Company + Region + Location 三维度 AND）。
+    /// </summary>
+    public static ISugarQueryable<FlTrainingFileDbEntity> ApplyLocationVisibilityFilter(
+        ISugarQueryable<FlTrainingFileDbEntity> query,
+        LocationScopeContext? context)
+    {
+        if (context is null || string.IsNullOrWhiteSpace(context.LocationId))
+        {
+            return query;
+        }
+
+        var locationId = context.LocationId.Trim();
+        var partnerId = context.PartnerId?.Trim();
+        var groupId = context.GroupId?.Trim();
+
+        return query.Where(f =>
+            f.AppliedPartnerType == AllScopeBindingHelper.ScopeAll
+            || (partnerId != null
+                && SqlFunc.Subqueryable<FlTrainingFilePartnerDbEntity>()
+                    .Where(p => p.TrainingFileId == f.Id && p.PartnerId == partnerId)
+                    .Any()))
+            .Where(f =>
+                f.AppliedRegionType == AllScopeBindingHelper.ScopeAll
+                || (groupId != null
+                    && SqlFunc.Subqueryable<FlTrainingFileRegionDbEntity>()
+                        .Where(r => r.TrainingFileId == f.Id && r.GroupId == groupId)
+                        .Any()))
+            .Where(f =>
+                f.AvailabilityType == AllScopeBindingHelper.ScopeAll
+                || SqlFunc.Subqueryable<FlTrainingFileLocationDbEntity>()
+                    .Where(l => l.TrainingFileId == f.Id && l.LocationId == locationId)
+                    .Any());
+    }
+
+    /// <summary>
+    /// 解析门店对应的 Company / Region 上下文。
+    /// </summary>
+    public static async Task<LocationScopeContext?> ResolveLocationScopeContextAsync(
+        ISqlSugarClient db,
+        string locationId)
+    {
+        if (string.IsNullOrWhiteSpace(locationId))
+        {
+            return null;
+        }
+
+        var normalized = locationId.Trim();
+        var partnerIds = await LocationScopeBindingHelper.ResolvePartnerIdsFromLocationIdsAsync(db, new[] { normalized });
+        var groupIds = await LocationScopeBindingHelper.ResolveGroupIdsFromLocationIdsAsync(db, new[] { normalized });
+
+        return new LocationScopeContext
+        {
+            LocationId = normalized,
+            PartnerId = partnerIds.FirstOrDefault(),
+            GroupId = groupIds.FirstOrDefault()
+        };
+    }
+
+    private static List<string> NormalizeRegionIds(
+        IReadOnlyList<string>? regionIds,
+        IReadOnlyList<string>? groupIds)
+    {
+        var merged = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var id in LocationScopeBindingHelper.NormalizeIds(regionIds))
+        {
+            merged.Add(id);
+        }
+
+        foreach (var id in LocationScopeBindingHelper.NormalizeIds(groupIds))
+        {
+            merged.Add(id);
+        }
+
+        return merged.OrderBy(x => x, StringComparer.Ordinal).ToList();
+    }
+
+    private static async Task ValidateGroupIdsExistAsync(ISqlSugarClient db, List<string> groupIds)
+    {
+        if (groupIds.Count == 0)
+        {
+            return;
+        }
+
+        var existing = await db.Queryable<FlGroupDbEntity>()
+            .Where(x => !x.IsDeleted && groupIds.Contains(x.Id))
+            .Select(x => x.Id)
+            .ToListAsync();
+        var existingSet = new HashSet<string>(existing, StringComparer.OrdinalIgnoreCase);
+        var missing = groupIds.Where(id => !existingSet.Contains(id)).ToList();
+        if (missing.Count > 0)
+        {
+            throw new UserFriendlyException("存在无效的 Region Id");
+        }
+    }
+
+    private static async Task<string> BuildPartnerDisplayAsync(
+        ISqlSugarClient db,
+        string appliedPartnerType,
+        IReadOnlyList<string> partnerIds)
+    {
+        if (!string.Equals(appliedPartnerType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase))
+        {
+            return LabelEntityPartnerScopeHelper.AllCompaniesDisplay;
+        }
+
+        if (LocationScopeBindingHelper.ContainsAllScopeSentinel(partnerIds))
+        {
+            return LabelEntityPartnerScopeHelper.AllCompaniesDisplay;
+        }
+
+        if (partnerIds.Count == 0)
+        {
+            return FoodLabelingDisplayConsts.NotAvailable;
+        }
+
+        var rows = await db.Queryable<FlPartnerDbEntity>()
+            .Where(x => !x.IsDeleted && partnerIds.Contains(x.Id))
+            .Select(x => x.PartnerName)
+            .ToListAsync();
+        var names = rows.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x!.Trim()).Distinct().OrderBy(x => x).ToList();
+        return names.Count > 0 ? string.Join(", ", names) : FoodLabelingDisplayConsts.NotAvailable;
+    }
+
+    private static async Task<string> BuildRegionDisplayAsync(
+        ISqlSugarClient db,
+        string appliedRegionType,
+        IReadOnlyList<string> regionIds)
+    {
+        if (!string.Equals(appliedRegionType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase))
+        {
+            return FoodLabelingDisplayConsts.AllRegion;
+        }
+
+        if (LocationScopeBindingHelper.ContainsAllScopeSentinel(regionIds) || regionIds.Count == 0)
+        {
+            return regionIds.Count == 0
+                ? FoodLabelingDisplayConsts.NotAvailable
+                : FoodLabelingDisplayConsts.AllRegion;
+        }
+
+        var rows = await db.Queryable<FlGroupDbEntity>()
+            .Where(x => !x.IsDeleted && regionIds.Contains(x.Id))
+            .Select(x => x.GroupName)
+            .ToListAsync();
+        var names = rows.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x!.Trim()).Distinct().OrderBy(x => x).ToList();
+        return names.Count > 0 ? string.Join(", ", names) : FoodLabelingDisplayConsts.NotAvailable;
+    }
+
+    private static async Task<string> BuildLocationDisplayAsync(
+        ISqlSugarClient db,
+        string availabilityType,
+        IReadOnlyList<string> locationIds)
+    {
+        if (!string.Equals(availabilityType, AllScopeBindingHelper.ScopeSpecified, StringComparison.OrdinalIgnoreCase))
+        {
+            return FoodLabelingDisplayConsts.AllLocation;
+        }
+
+        if (LocationScopeBindingHelper.ContainsAllScopeSentinel(locationIds) || locationIds.Count == 0)
+        {
+            return locationIds.Count == 0
+                ? FoodLabelingDisplayConsts.NotAvailable
+                : FoodLabelingDisplayConsts.AllLocation;
+        }
+
+        var guidList = locationIds.Where(x => Guid.TryParse(x, out _)).Select(Guid.Parse).ToList();
+        if (guidList.Count == 0)
+        {
+            return FoodLabelingDisplayConsts.NotAvailable;
+        }
+
+        var rows = await db.Queryable<FoodLabeling.Domain.Entities.LocationAggregateRoot>()
+            .Where(x => !x.IsDeleted && guidList.Contains(x.Id))
+            .Select(x => x.LocationName)
+            .ToListAsync();
+        var names = rows.Where(x => !string.IsNullOrWhiteSpace(x)).Select(x => x!.Trim()).Distinct().OrderBy(x => x).ToList();
+        return names.Count > 0 ? string.Join(", ", names) : FoodLabelingDisplayConsts.NotAvailable;
+    }
+}
@@ -27,7 +27,10 @@ public static class UsAppAuthScopeHelper
         }
  
         var kind = currentUser.FindClaim(UsAppJwtClaims.ClientKind)?.Value;
-        if (!string.Equals(kind, UsAppJwtClaims.ClientKindUsApp, StringComparison.Ordinal))
+        // 美国版 us-app；泰额版 us-app-auth 转发 th-app-auth 后签发 th_app
+        var isAppToken = string.Equals(kind, UsAppJwtClaims.ClientKindUsApp, StringComparison.Ordinal)
+            || string.Equals(kind, UsAppJwtClaims.ClientKindThApp, StringComparison.Ordinal);
+        if (!isAppToken)
         {
             throw new UserFriendlyException("请使用 App 登录令牌调用该接口");
         }
@@ -53,7 +56,13 @@ public static class UsAppAuthScopeHelper
             return true;
         }
  
-        return await TeamMemberRoleHelper.IsCompanyAdminUserAsync(db, currentUser);
+        if (await TeamMemberRoleHelper.IsCompanyAdminUserAsync(db, currentUser))
+        {
+            return true;
+        }
+
+        // App JWT 可能未写 role claim：回退查库 RoleCode=admin
+        return await ReportsRoleHelper.IsAdminRoleFromDbAsync(db, currentUser.Id.Value);
     }
  
     public static async Task<List<AuthScopeCompanyOptionDto>> ListCompaniesAsync(ISqlSugarClient db)
+using System.Reflection;
+
+namespace FoodLabeling.Application.MultiTenancy;
+
+/// <summary>
+/// 从程序集嵌入资源读取租户初始化 SQL 脚本。
+/// </summary>
+public static class EmbeddedTenantSqlScripts
+{
+    /// <summary>
+    /// 读取指定嵌入资源中的 SQL 文本。
+    /// </summary>
+    /// <param name="assembly">包含 EmbeddedResource 的程序集</param>
+    /// <param name="resourceName">LogicalName 或完整资源名</param>
+    public static string Read(Assembly assembly, string resourceName)
+    {
+        var stream = assembly.GetManifestResourceStream(resourceName);
+        if (stream == null)
+        {
+            var available = string.Join(", ", assembly.GetManifestResourceNames());
+            throw new InvalidOperationException(
+                $"未找到嵌入 SQL 资源「{resourceName}」。可用资源：{available}");
+        }
+
+        using (stream)
+        using (var reader = new StreamReader(stream))
+        {
+            return reader.ReadToEnd();
+        }
+    }
+}
+namespace FoodLabeling.Application.MultiTenancy;
+
+/// <summary>
+/// 泰额版新租户业务库初始化时自动执行的嵌入 SQL 资源名（顺序即执行顺序）。
+/// </summary>
+public static class FoodLabelingTenantMigrationScriptNames
+{
+    public const string AppliedRegionType = "FoodLabeling.TenantMigrations.fl_entity_applied_region_type.sql";
+
+    public const string LabelPartnerId = "FoodLabeling.TenantMigrations.fl_label_partner_id.sql";
+
+    public const string ProductCategoryPartnerScope =
+        "FoodLabeling.TenantMigrations.fl_product_category_partner_scope.sql";
+
+    public const string UserLocation = "FoodLabeling.TenantMigrations.fl_userlocation.sql";
+
+    public const string TeamMemberScope = "FoodLabeling.TenantMigrations.fl_team_member_scope.sql";
+
+    public const string Training = "FoodLabeling.TenantMigrations.fl_training.sql";
+
+    public const string LabelAlertTimer = "FoodLabeling.TenantMigrations.fl_label_alert_timer.sql";
+
+    /// <summary>CodeFirst 之后按序执行的脚本资源名。</summary>
+    public static readonly IReadOnlyList<string> TenantInitializationOrder =
+    [
+        AppliedRegionType,
+        LabelPartnerId,
+        ProductCategoryPartnerScope,
+        UserLocation,
+        TeamMemberScope,
+        Training,
+        LabelAlertTimer
+    ];
+}
+using FoodLabeling.Application.Helpers;
 using Microsoft.AspNetCore.Http;
 using Volo.Abp.MultiTenancy;
-using Volo.Abp.Security.Claims;
-using Yi.Framework.Rbac.Domain.Shared.Consts;
  
 namespace FoodLabeling.Application.MultiTenancy;
  
 /// <summary>
-/// 从 JWT Claim <see cref="TokenTypeConst.TenantId"/> 解析当前租户（泰额版登录写入）
+/// 从 JWT Claim TenantId 解析当前租户（泰额版登录写入）
 /// </summary>
 public class JwtClaimTenantResolveContributor : TenantResolveContributorBase
 {
@@ -16,16 +15,17 @@ public class JwtClaimTenantResolveContributor : TenantResolveContributorBase
  
     public override Task ResolveAsync(ITenantResolveContext context)
     {
-        var httpContext = context.ServiceProvider.GetService(typeof(IHttpContextAccessor)) as IHttpContextAccessor;
-        var user = httpContext?.HttpContext?.User;
-        if (user?.Identity?.IsAuthenticated != true)
+        var httpContext = (context.ServiceProvider.GetService(typeof(IHttpContextAccessor)) as IHttpContextAccessor)
+            ?.HttpContext;
+        if (httpContext is null)
         {
             return Task.CompletedTask;
         }
  
-        var tenantClaim = user.FindFirst(TokenTypeConst.TenantId)?.Value
-                          ?? user.FindFirst(AbpClaimTypes.TenantId)?.Value;
-        if (!string.IsNullOrWhiteSpace(tenantClaim))
+        var tenantClaim = TenantBusinessContextHelper.TryGetTenantIdClaimValue(httpContext);
+        if (!string.IsNullOrWhiteSpace(tenantClaim)
+            && Guid.TryParse(tenantClaim, out var tenantGuid)
+            && tenantGuid != Guid.Empty)
         {
             context.TenantIdOrName = tenantClaim;
         }
+using System.Text;
+using System.Text.RegularExpressions;
+using MySqlConnector;
+using SqlSugar;
+
+namespace FoodLabeling.Application.MultiTenancy;
+
+/// <summary>
+/// 在 MySQL 租户库上执行幂等 DDL/DML 脚本（支持 PREPARE / 用户变量等多语句批次）。
+/// </summary>
+public static class TenantSqlScriptExecutor
+{
+    private static readonly Regex PrepareBlockEndRegex =
+        new(@"DEALLOCATE\s+PREPARE\s+\w+\s*;\s*$", RegexOptions.IgnoreCase | RegexOptions.Multiline);
+
+    private static readonly Regex CreateTableEndRegex =
+        new(@"\)\s*ENGINE\s*=.+;\s*$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    /// <summary>
+    /// 执行完整 SQL 脚本；仅支持 MySQL。
+    /// </summary>
+    public static async Task ExecuteMySqlScriptAsync(
+        string connectionString,
+        string script,
+        CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(script))
+        {
+            return;
+        }
+
+        var normalizedConnectionString = EnsureMySqlScriptConnectionOptions(connectionString);
+        await using var connection = new MySqlConnection(normalizedConnectionString);
+        await connection.OpenAsync(cancellationToken);
+
+        foreach (var batch in SplitIntoBatches(script))
+        {
+            await using var command = new MySqlCommand(batch, connection);
+            await command.ExecuteNonQueryAsync(cancellationToken);
+        }
+    }
+
+    /// <summary>
+    /// 非 MySQL 租户库跳过脚本（当前脚本均为 MySQL 方言）。
+    /// </summary>
+    public static bool Supports(DbType dbType) => dbType == DbType.MySql;
+
+    /// <summary>
+    /// 将脚本拆成可独立提交的批次：PREPARE 块、CREATE TABLE、UPDATE 等。
+    /// </summary>
+    internal static IReadOnlyList<string> SplitIntoBatches(string script)
+    {
+        var lines = script.Replace("\r\n", "\n").Split('\n');
+        var batches = new List<string>();
+        var current = new StringBuilder();
+
+        foreach (var rawLine in lines)
+        {
+            var line = rawLine.TrimEnd();
+            if (string.IsNullOrWhiteSpace(line) || line.TrimStart().StartsWith("--", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            current.AppendLine(line);
+
+            var trimmed = line.Trim();
+            if (PrepareBlockEndRegex.IsMatch(trimmed)
+                || CreateTableEndRegex.IsMatch(trimmed)
+                || (trimmed.StartsWith("UPDATE ", StringComparison.OrdinalIgnoreCase) && trimmed.EndsWith(';')))
+            {
+                var batch = current.ToString().Trim();
+                if (!string.IsNullOrEmpty(batch))
+                {
+                    batches.Add(batch);
+                }
+
+                current.Clear();
+            }
+        }
+
+        var tail = current.ToString().Trim();
+        if (!string.IsNullOrEmpty(tail))
+        {
+            batches.Add(tail);
+        }
+
+        return batches;
+    }
+
+    private static string EnsureMySqlScriptConnectionOptions(string connectionString)
+    {
+        var builder = new MySqlConnectionStringBuilder(connectionString)
+        {
+            AllowUserVariables = true
+        };
+
+        return builder.ConnectionString;
+    }
+}
@@ -3,6 +3,7 @@ using FoodLabeling.Application.Contracts.Dtos.AuthSession;
 using FoodLabeling.Application.Contracts.IServices;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using Volo.Abp;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Caching;
@@ -24,24 +25,28 @@ public class AuthSessionAppService : ApplicationService, IAuthSessionAppService
     private readonly IDistributedCache<SystemEditStampCacheItem, SystemEditStampCacheKey> _systemEditStampCache;
     private readonly ISqlSugarDbContext _dbContext;
     private readonly ISqlSugarRepository<UserAggregateRoot, Guid> _userRepository;
+    private readonly DbConnOptions _dbConnOptions;
  
     public AuthSessionAppService(
         ISqlSugarDbContext dbContext,
         ISqlSugarRepository<UserAggregateRoot, Guid> userRepository,
         IDistributedCache<UserInfoCacheItem, UserInfoCacheKey> userCache,
-        IDistributedCache<SystemEditStampCacheItem, SystemEditStampCacheKey> systemEditStampCache)
+        IDistributedCache<SystemEditStampCacheItem, SystemEditStampCacheKey> systemEditStampCache,
+        IOptions<DbConnOptions> dbConnOptions)
     {
         _dbContext = dbContext;
         _userRepository = userRepository;
         _userCache = userCache;
         _systemEditStampCache = systemEditStampCache;
+        _dbConnOptions = dbConnOptions.Value;
     }
  
     /// <inheritdoc />
     public virtual async Task<CurrentUserMenuPermissionsOutputDto> GetMyMenusAsync()
     {
-        // 平台 Token（JWT 无 TenantId）读主库；公司 Token 须已解析租户上下文
-        if (CurrentTenant.Id.HasValue)
+        // 平台 Token（JWT 无 TenantId，或前端误传 __tenant=全 0）读主库；
+        // 仅真实业务租户 Id 才要求已解析租户上下文
+        if (CurrentTenant.Id.HasValue && CurrentTenant.Id.Value != Guid.Empty)
         {
             TenantContextGuard.EnsureTenantResolved(CurrentTenant, "获取菜单权限");
         }
@@ -66,35 +71,33 @@ public class AuthSessionAppService : ApplicationService, IAuthSessionAppService
             .ToListAsync();
         var distinctUserRoleIds = userRoleIds.Distinct().ToList();
  
+        var isAdmin = UserConst.Admin.Equals(user.UserName);
+        var isSaasEnabled = _dbConnOptions.EnabledSaasMultiTenancy;
+        var isPlatformLogin = !CurrentTenant.Id.HasValue || CurrentTenant.Id.Value == Guid.Empty;
+
         List<MenuDbEntity> menus;
-        if (UserConst.Admin.Equals(user.UserName))
+        // 非 SaaS：admin 返回全部；SaaS 公司业务租户：一律走 RoleMenu（含公司 admin）
+        // SaaS 平台登录：下方再统一过滤为仅平台菜单
+        if (isAdmin && !isSaasEnabled)
+        {
+            menus = await _dbContext.SqlSugarClient.Queryable<MenuDbEntity>()
+                .Where(x => x.IsDeleted == false)
+                .ToListAsync();
+        }
+        else if (isAdmin && isSaasEnabled && isPlatformLogin)
         {
-            // MenuAggregateRoot(ParentId 为 Guid) 无法兼容 menu.ParentId=0/字符串：这里统一用 MenuDbEntity
             menus = await _dbContext.SqlSugarClient.Queryable<MenuDbEntity>()
                 .Where(x => x.IsDeleted == false)
                 .ToListAsync();
         }
         else
         {
-            var roleIdStrs = distinctUserRoleIds.Select(x => x.ToString()).Distinct().ToList();
-            if (roleIdStrs.Count == 0)
-            {
-                menus = new List<MenuDbEntity>();
-            }
-            else
-            {
-                var menuIds = await _dbContext.SqlSugarClient.Queryable<RoleMenuDbEntity>()
-                    .Where(x => roleIdStrs.Contains(x.RoleId))
-                    .Select(x => x.MenuId)
-                    .Distinct()
-                    .ToListAsync();
-
-                menus = menuIds.Count == 0
-                    ? new List<MenuDbEntity>()
-                    : await _dbContext.SqlSugarClient.Queryable<MenuDbEntity>()
-                        .Where(x => x.IsDeleted == false && menuIds.Contains(x.Id))
-                        .ToListAsync();
-            }
+            menus = await LoadMenusByRoleIdsAsync(distinctUserRoleIds);
+        }
+
+        if (isSaasEnabled && isPlatformLogin)
+        {
+            menus = PlatformMenuHelper.FilterPlatformMenusWithAncestors(menus);
         }
  
         var menuNodes = menus
@@ -126,6 +129,7 @@ public class AuthSessionAppService : ApplicationService, IAuthSessionAppService
  
         return new CurrentUserMenuPermissionsOutputDto
         {
+            UserId = user.Id,
             User = new CurrentUserBriefDto
             {
                 Id = user.Id,
@@ -145,6 +149,30 @@ public class AuthSessionAppService : ApplicationService, IAuthSessionAppService
     }
  
     /// <summary>
+    /// 按用户角色关联 RoleMenu 查询可见菜单（SaaS 公司业务租户 admin 与普通用户相同路径）
+    /// </summary>
+    private async Task<List<MenuDbEntity>> LoadMenusByRoleIdsAsync(IReadOnlyList<Guid> userRoleIds)
+    {
+        var roleIdStrs = userRoleIds.Select(x => x.ToString()).Distinct().ToList();
+        if (roleIdStrs.Count == 0)
+        {
+            return new List<MenuDbEntity>();
+        }
+
+        var menuIds = await _dbContext.SqlSugarClient.Queryable<RoleMenuDbEntity>()
+            .Where(x => roleIdStrs.Contains(x.RoleId))
+            .Select(x => x.MenuId)
+            .Distinct()
+            .ToListAsync();
+
+        return menuIds.Count == 0
+            ? new List<MenuDbEntity>()
+            : await _dbContext.SqlSugarClient.Queryable<MenuDbEntity>()
+                .Where(x => x.IsDeleted == false && menuIds.Contains(x.Id))
+                .ToListAsync();
+    }
+
+    /// <summary>
     /// 缓存未命中时，取主要业务表最近修改时间，避免 Last Updated 长期停在用户资料时间。
     /// </summary>
     private async Task<DateTime?> ResolveRecentBusinessEditTimeAsync()
-using System.Globalization;
+using System.Globalization;
 using System.Text.Json;
 using FoodLabeling.Application.Contracts.Dtos.Dashboard;
 using FoodLabeling.Application.Contracts.IServices;
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+/// <summary>
+/// 标签告警计时器（对应表：fl_label_alert_timer）
+/// </summary>
+[SugarTable("fl_label_alert_timer")]
+public class FlLabelAlertTimerDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string BatchId { get; set; } = string.Empty;
+
+    public string PrintTaskId { get; set; } = string.Empty;
+
+    public string LabelId { get; set; } = string.Empty;
+
+    public string? LabelCode { get; set; }
+
+    public string LabelName { get; set; } = string.Empty;
+
+    public string? ProductId { get; set; }
+
+    public string? ProductName { get; set; }
+
+    public string LocationId { get; set; } = string.Empty;
+
+    public DateTime PrintedAt { get; set; }
+
+    public DateTime? BaseTime { get; set; }
+
+    public DateTime ExpiresAt { get; set; }
+
+    public int DurationSeconds { get; set; }
+
+    public string Title { get; set; } = string.Empty;
+
+    public string Subtitle { get; set; } = string.Empty;
+
+    public bool IsDeleted { get; set; }
+
+    public DateTime? DeletionTime { get; set; }
+
+    public string? CreatedBy { get; set; }
+
+    public DateTime CreationTime { get; set; }
+}
@@ -49,6 +49,11 @@ public class FlLabelCategoryDbEntity
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
+    /// 适用 Region 范围：ALL / SPECIFIED（ALL 时可同时 SPECIFIED 门店快照，表示全区下指定门店）
+    /// </summary>
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    /// <summary>
     /// 适用 Company 范围：ALL / SPECIFIED
     /// </summary>
     public string AppliedPartnerType { get; set; } = "ALL";
@@ -28,6 +28,11 @@ public class FlLabelDbEntity
  
     public string? LocationId { get; set; }
  
+    /// <summary>
+    /// 适用 Company（<c>fl_partner.Id</c>，单选）；Region/Location 为 ALL 时用于回显与范围校验。
+    /// </summary>
+    public string? PartnerId { get; set; }
+
     public string? LabelCategoryId { get; set; }
  
     public string? LabelTypeId { get; set; }
@@ -36,6 +36,11 @@ public class FlLabelMultipleOptionDbEntity
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
+    /// 适用 Region 范围：ALL / SPECIFIED
+    /// </summary>
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    /// <summary>
     /// 适用 Company 范围：ALL / SPECIFIED
     /// </summary>
     public string AppliedPartnerType { get; set; } = "ALL";
@@ -34,6 +34,11 @@ public class FlLabelTypeDbEntity
     public string AvailabilityType { get; set; } = "ALL";
  
     /// <summary>
+    /// 适用 Region 范围：ALL / SPECIFIED
+    /// </summary>
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    /// <summary>
     /// 适用 Company 范围：ALL / SPECIFIED
     /// </summary>
     public string AppliedPartnerType { get; set; } = "ALL";
@@ -46,6 +46,16 @@ public class FlProductCategoryDbEntity
     /// </summary>
     public string AvailabilityType { get; set; } = "ALL";
  
+    /// <summary>
+    /// 适用 Region 范围：ALL / SPECIFIED（ALL 时可同时 SPECIFIED 门店快照）
+    /// </summary>
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    /// <summary>
+    /// 适用 Company 范围：ALL / SPECIFIED
+    /// </summary>
+    public string AppliedPartnerType { get; set; } = "ALL";
+
     public int OrderNum { get; set; }
 }
  
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_product_category_partner")]
+public class FlProductCategoryPartnerDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryId { get; set; } = string.Empty;
+
+    public string PartnerId { get; set; } = string.Empty;
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+}
@@ -36,4 +36,9 @@ public class FlProductDbEntity
     /// 适用门店：ALL / SPECIFIED（ALL 时动态包含后续新增门店）
     /// </summary>
     public string AvailabilityType { get; set; } = "SPECIFIED";
+
+    /// <summary>
+    /// 适用 Region：ALL / SPECIFIED（支持 Region=ALL + 指定门店）
+    /// </summary>
+    public string AppliedRegionType { get; set; } = "ALL";
 }
+using SqlSugar;
+using Yi.Framework.SqlSugarCore.Abstractions;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+/// <summary>
+/// Team Member 适用范围维度（Region/Location 的 ALL/SPECIFIED），与 userlocation 快照配合回显。
+/// </summary>
+[IgnoreCodeFirst]
+[SugarTable("fl_team_member_scope")]
+public class FlTeamMemberScopeDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true, Length = 36)]
+    public string UserId { get; set; } = string.Empty;
+
+    /// <summary>适用 Region：ALL / SPECIFIED</summary>
+    [SugarColumn(Length = 20)]
+    public string AppliedRegionType { get; set; } = "SPECIFIED";
+
+    /// <summary>适用 Location：ALL / SPECIFIED</summary>
+    [SugarColumn(Length = 20)]
+    public string AppliedLocationType { get; set; } = "SPECIFIED";
+
+    public DateTime? CreationTime { get; set; }
+
+    public DateTime? LastModificationTime { get; set; }
+}
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_training_category")]
+public class FlTrainingCategoryDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryName { get; set; } = string.Empty;
+
+    public string? ParentId { get; set; }
+
+    public int OrderNum { get; set; }
+
+    public bool IsDeleted { get; set; }
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+
+    public DateTime? LastModificationTime { get; set; }
+
+    public string? LastModifierId { get; set; }
+
+    public string ConcurrencyStamp { get; set; } = string.Empty;
+}
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_training_file")]
+public class FlTrainingFileDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string CategoryId { get; set; } = string.Empty;
+
+    public string FileName { get; set; } = string.Empty;
+
+    public string FileUrl { get; set; } = string.Empty;
+
+    /// <summary>image / doc / other</summary>
+    public string FileType { get; set; } = "other";
+
+    public long FileSize { get; set; }
+
+    public int OrderNum { get; set; }
+
+    public string AppliedPartnerType { get; set; } = "ALL";
+
+    public string AppliedRegionType { get; set; } = "ALL";
+
+    public string AvailabilityType { get; set; } = "ALL";
+
+    public bool IsDeleted { get; set; }
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+
+    public DateTime? LastModificationTime { get; set; }
+
+    public string? LastModifierId { get; set; }
+
+    public string ConcurrencyStamp { get; set; } = string.Empty;
+}
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_training_file_location")]
+public class FlTrainingFileLocationDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string TrainingFileId { get; set; } = string.Empty;
+
+    public string LocationId { get; set; } = string.Empty;
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+}
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_training_file_partner")]
+public class FlTrainingFilePartnerDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string TrainingFileId { get; set; } = string.Empty;
+
+    public string PartnerId { get; set; } = string.Empty;
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+}
+using SqlSugar;
+
+namespace FoodLabeling.Application.Services.DbModels;
+
+[SugarTable("fl_training_file_region")]
+public class FlTrainingFileRegionDbEntity
+{
+    [SugarColumn(IsPrimaryKey = true)]
+    public string Id { get; set; } = string.Empty;
+
+    public string TrainingFileId { get; set; } = string.Empty;
+
+    public string GroupId { get; set; } = string.Empty;
+
+    public DateTime CreationTime { get; set; }
+
+    public string? CreatorId { get; set; }
+}
@@ -4,6 +4,7 @@ using FoodLabeling.Application.Contracts.Dtos.Group;
 using FoodLabeling.Application.Contracts.IServices;
 using FoodLabeling.Application.Services.DbModels;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -25,16 +26,22 @@ public class GroupAppService : ApplicationService, IGroupAppService
  
     private readonly ISqlSugarDbContext _dbContext;
     private readonly IGuidGenerator _guidGenerator;
+    private readonly DbConnOptions _dbConnOptions;
  
-    public GroupAppService(ISqlSugarDbContext dbContext, IGuidGenerator guidGenerator)
+    public GroupAppService(
+        ISqlSugarDbContext dbContext,
+        IGuidGenerator guidGenerator,
+        IOptions<DbConnOptions> dbConnOptions)
     {
         _dbContext = dbContext;
         _guidGenerator = guidGenerator;
+        _dbConnOptions = dbConnOptions.Value;
     }
  
     /// <inheritdoc />
     public async Task<PagedResultWithPageDto<GroupGetListOutputDto>> GetListAsync(GroupGetListInputVo input)
     {
+        TenantContextGuard.EnsureBusinessTenantIfSaas(CurrentTenant, _dbConnOptions, "查询 Region");
         RefAsync<int> total = 0;
         var query = await BuildGroupJoinedQueryAsync(input);
         var projected = query.Select((g, p) => new GroupGetListOutputDto
+using FoodLabeling.Application.Contracts.Dtos.Common;
+using FoodLabeling.Application.Contracts.Dtos.LabelAlertTimer;
+using FoodLabeling.Application.Contracts.IServices;
+using FoodLabeling.Application.Helpers;
+using FoodLabeling.Application.Services.DbModels;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Caching.Distributed;
+using SqlSugar;
+using Volo.Abp;
+using Volo.Abp.Application.Services;
+using Yi.Framework.SqlSugarCore.Abstractions;
+
+namespace FoodLabeling.Application.Services;
+
+/// <summary>
+/// 标签告警计时器（App）：跟踪已打印标签的过期倒计时；与可否打印无关。
+/// </summary>
+public class LabelAlertTimerAppService : ApplicationService, ILabelAlertTimerAppService
+{
+    private const string StatusRunning = "running";
+    private const string StatusExpired = "expired";
+
+    private readonly ISqlSugarDbContext _dbContext;
+    private readonly IDistributedCache _distributedCache;
+
+    public LabelAlertTimerAppService(ISqlSugarDbContext dbContext, IDistributedCache distributedCache)
+    {
+        _dbContext = dbContext;
+        _distributedCache = distributedCache;
+    }
+
+    /// <summary>
+    /// 分页查询当前门店告警计时器列表（含倒计时）
+    /// </summary>
+    /// <remarks>
+    /// 仅展示已打印标签的过期倒计时，<b>不</b>用于判断能否打印。
+    /// 过期时刻与 Print Log「Expiration」列同源（<c>ReportsPrintLogExpiryHelper</c>）。
+    /// 同一打印批次（<c>BatchId</c>）无论打印多少张标签，仅一条计时器（取 CopyIndex 最小任务）。
+    ///
+    /// 示例请求：
+    /// ```json
+    /// {
+    ///   "locationId": "11111111-1111-1111-1111-111111111111",
+    ///   "skipCount": 1,
+    ///   "maxResultCount": 20,
+    ///   "dateDay": "2026-08-07"
+    /// }
+    /// ```
+    ///
+    /// 参数说明：
+    /// - locationId: 当前门店 Id（必填，须已绑定）
+    /// - skipCount: 页码（从 1 开始）
+    /// - maxResultCount: 每页条数
+    /// - dateDay: 可选，按 PrintedAt 自然日筛选（yyyy-MM-dd）
+    /// </remarks>
+    /// <param name="input">分页查询入参</param>
+    /// <returns>分页计时器列表（含 remainingTime 倒计时秒数）</returns>
+    /// <response code="200">成功返回分页列表</response>
+    /// <response code="400">参数错误或未登录/无门店权限</response>
+    /// <response code="500">服务器错误</response>
+    [Authorize]
+    [HttpPost("label-alert-timer/list")]
+    public virtual async Task<PagedResultWithPageDto<LabelAlertTimerListItemDto>> GetListAsync(
+        LabelAlertTimerGetListInputVo input)
+    {
+        if (input is null)
+        {
+            throw new UserFriendlyException("入参不能为空");
+        }
+
+        if (!CurrentUser.Id.HasValue)
+        {
+            throw new UserFriendlyException("用户未登录");
+        }
+
+        var locationId = input.LocationId?.Trim();
+        if (string.IsNullOrWhiteSpace(locationId))
+        {
+            throw new UserFriendlyException("门店Id不能为空");
+        }
+
+        return await QueryListByLocationAsync(locationId, input);
+    }
+
+    /// <summary>
+    /// App：当前账号当前门店告警列表（含倒计时）
+    /// </summary>
+    /// <remarks>
+    /// 供 App 警告页使用：按当前登录账号可访问的门店查询已打印标签的告警倒计时。
+    /// <c>locationId</c> 可省略，省略时使用管理员已选门店缓存（<c>select-admin-scope-location</c>）；
+    /// 仍无门店时返回友好错误。过期状态仅用于展示，与可否打印无关。
+    ///
+    /// 示例请求：
+    /// ```json
+    /// {
+    ///   "locationId": "11111111-1111-1111-1111-111111111111",
+    ///   "skipCount": 1,
+    ///   "maxResultCount": 50
+    /// }
+    /// ```
+    ///
+    /// 参数说明：
+    /// - locationId: 当前门店 Id（可选；空则取已选门店缓存）
+    /// - skipCount: 页码（从 1 开始）
+    /// - maxResultCount: 每页条数
+    /// - dateDay: 可选，按 PrintedAt 自然日筛选（yyyy-MM-dd）
+    ///
+    /// 出参倒计时字段：
+    /// - remainingTime: 剩余秒数，App 可直接做倒计时
+    /// - totalTime: 总时长（秒）
+    /// - status: running / expired
+    /// - expiresAt: 过期时刻
+    /// </remarks>
+    /// <param name="input">分页查询入参</param>
+    /// <returns>分页告警列表（含倒计时）</returns>
+    /// <response code="200">成功返回分页列表</response>
+    /// <response code="400">未登录、无门店或无权限</response>
+    /// <response code="500">服务器错误</response>
+    [Authorize]
+    [HttpPost("label-alert-timer/app-list")]
+    public virtual async Task<PagedResultWithPageDto<LabelAlertTimerListItemDto>> GetAppListAsync(
+        LabelAlertTimerGetListInputVo input)
+    {
+        if (input is null)
+        {
+            throw new UserFriendlyException("入参不能为空");
+        }
+
+        if (!CurrentUser.Id.HasValue)
+        {
+            throw new UserFriendlyException("用户未登录");
+        }
+
+        var locationId = input.LocationId?.Trim();
+        if (string.IsNullOrWhiteSpace(locationId))
+        {
+            var cache = await UsAppAuthScopeHelper.GetAdminScopeCacheAsync(
+                _distributedCache,
+                CurrentUser.Id.Value);
+            locationId = cache?.Location?.Id?.Trim();
+        }
+
+        if (string.IsNullOrWhiteSpace(locationId))
+        {
+            throw new UserFriendlyException("请先选择门店或传入 locationId");
+        }
+
+        return await QueryListByLocationAsync(locationId, input);
+    }
+
+    /// <summary>
+    /// 软删除告警计时器
+    /// </summary>
+    /// <remarks>
+    /// 删除前校验当前用户可访问该计时器所属门店。
+    /// </remarks>
+    /// <param name="id">计时器 Id</param>
+    /// <response code="200">删除成功</response>
+    /// <response code="400">记录不存在或无门店权限</response>
+    /// <response code="500">服务器错误</response>
+    [Authorize]
+    [HttpDelete("label-alert-timer/{id}")]
+    public virtual async Task DeleteAsync(string id)
+    {
+        var timerId = id?.Trim();
+        if (string.IsNullOrWhiteSpace(timerId))
+        {
+            throw new UserFriendlyException("计时器Id不能为空");
+        }
+
+        if (!CurrentUser.Id.HasValue)
+        {
+            throw new UserFriendlyException("用户未登录");
+        }
+
+        var db = _dbContext.SqlSugarClient;
+        var row = (await db.Queryable<FlLabelAlertTimerDbEntity>()
+                .Where(x => x.Id == timerId && !x.IsDeleted)
+                .Take(1)
+                .ToListAsync())
+            .FirstOrDefault();
+        if (row is null)
+        {
+            throw new UserFriendlyException("计时器不存在或已删除");
+        }
+
+        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
+            CurrentUser, db, row.LocationId);
+
+        var now = DateTime.Now;
+        await db.Updateable<FlLabelAlertTimerDbEntity>()
+            .SetColumns(x => x.IsDeleted == true)
+            .SetColumns(x => x.DeletionTime == now)
+            .Where(x => x.Id == timerId && !x.IsDeleted)
+            .ExecuteCommandAsync();
+    }
+
+    /// <summary>
+    /// 查询已打印标签告警的过期/倒计时状态（不拦截打印）
+    /// </summary>
+    /// <remarks>
+    /// 至少提供 <c>timerId</c>、<c>batchId</c>、<c>printTaskId</c> 之一。
+    /// 本接口仅返回已打印批次的过期状态与剩余秒数，供展示倒计时；
+    /// <b>绝不</b>用于判断「能不能打印」——打印流程不得依赖本接口结果做拦截。
+    ///
+    /// 示例请求：
+    /// ```json
+    /// {
+    ///   "batchId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+    /// }
+    /// ```
+    ///
+    /// 参数说明：
+    /// - timerId: 计时器 Id
+    /// - batchId: 打印批次 Id
+    /// - printTaskId: 打印任务 Id（同批次任意任务均可）
+    /// </remarks>
+    /// <param name="input">查询入参</param>
+    /// <returns>过期/倒计时状态（展示用）</returns>
+    /// <response code="200">成功（含未找到记录的情况）</response>
+    /// <response code="400">未提供任何标识</response>
+    /// <response code="500">服务器错误</response>
+    [Authorize]
+    [HttpPost("label-alert-timer/check-expired")]
+    public virtual async Task<LabelAlertTimerCheckExpiredOutputDto> CheckExpiredAsync(
+        LabelAlertTimerCheckExpiredInputVo input)
+    {
+        if (input is null)
+        {
+            throw new UserFriendlyException("入参不能为空");
+        }
+
+        var timerId = input.TimerId?.Trim();
+        var batchId = input.BatchId?.Trim();
+        var printTaskId = input.PrintTaskId?.Trim();
+        if (string.IsNullOrWhiteSpace(timerId) &&
+            string.IsNullOrWhiteSpace(batchId) &&
+            string.IsNullOrWhiteSpace(printTaskId))
+        {
+            throw new UserFriendlyException("请至少提供 timerId、batchId 或 printTaskId 之一");
+        }
+
+        var db = _dbContext.SqlSugarClient;
+        FlLabelAlertTimerDbEntity? row = null;
+
+        if (!string.IsNullOrWhiteSpace(timerId))
+        {
+            row = (await db.Queryable<FlLabelAlertTimerDbEntity>()
+                    .Where(x => x.Id == timerId && !x.IsDeleted)
+                    .Take(1)
+                    .ToListAsync())
+                .FirstOrDefault();
+        }
+        else if (!string.IsNullOrWhiteSpace(batchId))
+        {
+            row = (await db.Queryable<FlLabelAlertTimerDbEntity>()
+                    .Where(x => x.BatchId == batchId && !x.IsDeleted)
+                    .Take(1)
+                    .ToListAsync())
+                .FirstOrDefault();
+        }
+        else if (!string.IsNullOrWhiteSpace(printTaskId))
+        {
+            var task = (await db.Queryable<FlLabelPrintTaskDbEntity>()
+                    .Where(x => x.Id == printTaskId)
+                    .Take(1)
+                    .ToListAsync())
+                .FirstOrDefault();
+            if (task is not null && !string.IsNullOrWhiteSpace(task.BatchId))
+            {
+                row = (await db.Queryable<FlLabelAlertTimerDbEntity>()
+                        .Where(x => x.BatchId == task.BatchId && !x.IsDeleted)
+                        .Take(1)
+                        .ToListAsync())
+                    .FirstOrDefault();
+            }
+        }
+
+        if (row is null)
+        {
+            return new LabelAlertTimerCheckExpiredOutputDto
+            {
+                Found = false,
+                IsExpired = false,
+                RemainingSeconds = 0
+            };
+        }
+
+        if (!CurrentUser.Id.HasValue)
+        {
+            throw new UserFriendlyException("用户未登录");
+        }
+
+        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
+            CurrentUser, db, row.LocationId);
+
+        var now = DateTime.Now;
+        var remaining = Math.Max(0, (int)(row.ExpiresAt - now).TotalSeconds);
+        var isExpired = row.ExpiresAt <= now;
+
+        return new LabelAlertTimerCheckExpiredOutputDto
+        {
+            Found = true,
+            IsExpired = isExpired,
+            ExpiresAt = row.ExpiresAt,
+            RemainingSeconds = remaining,
+            Status = isExpired ? StatusExpired : StatusRunning,
+            Title = row.Title,
+            Subtitle = row.Subtitle,
+            TimerId = row.Id,
+            BatchId = row.BatchId
+        };
+    }
+
+    private async Task<PagedResultWithPageDto<LabelAlertTimerListItemDto>> QueryListByLocationAsync(
+        string locationId,
+        LabelAlertTimerGetListInputVo input)
+    {
+        await UsAppPrintLogScopeHelper.EnsureUserCanAccessLocationAsync(
+            CurrentUser, _dbContext.SqlSugarClient, locationId);
+
+        var db = _dbContext.SqlSugarClient;
+        RefAsync<int> total = 0;
+        var query = db.Queryable<FlLabelAlertTimerDbEntity>()
+            .Where(x => !x.IsDeleted && x.LocationId == locationId);
+
+        var (dayStart, dayEndExcl) = ResolveDateDayFilter(input.DateDay);
+        if (dayStart.HasValue && dayEndExcl.HasValue)
+        {
+            var start = dayStart.Value;
+            var endExcl = dayEndExcl.Value;
+            query = query.Where(x => x.PrintedAt >= start && x.PrintedAt < endExcl);
+        }
+
+        var pageRows = await query
+            .OrderBy(x => x.ExpiresAt, OrderByType.Desc)
+            .OrderBy(x => x.PrintedAt, OrderByType.Desc)
+            .ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
+
+        var now = DateTime.Now;
+        var items = pageRows.Select(x => MapListItem(x, now)).ToList();
+
+        var pageSize = input.MaxResultCount <= 0 ? items.Count : input.MaxResultCount;
+        var pageIndex = pageSize <= 0 ? 1 : PagedQueryConvention.PageIndexFromSkipCount(input.SkipCount);
+        var totalCount = (long)total;
+        var totalPages = pageSize <= 0 ? 0 : (int)Math.Ceiling(totalCount / (double)pageSize);
+
+        return new PagedResultWithPageDto<LabelAlertTimerListItemDto>
+        {
+            PageIndex = pageIndex,
+            PageSize = pageSize,
+            TotalCount = totalCount,
+            TotalPages = totalPages,
+            Items = items
+        };
+    }
+
+    private static LabelAlertTimerListItemDto MapListItem(FlLabelAlertTimerDbEntity row, DateTime now)
+    {
+        var remaining = Math.Max(0, (int)(row.ExpiresAt - now).TotalSeconds);
+        var isExpired = row.ExpiresAt <= now;
+
+        return new LabelAlertTimerListItemDto
+        {
+            Id = row.Id,
+            BatchId = row.BatchId,
+            PrintTaskId = row.PrintTaskId,
+            LabelId = row.LabelId,
+            LabelCode = row.LabelCode,
+            Title = row.Title,
+            Subtitle = row.Subtitle,
+            TotalTime = row.DurationSeconds,
+            RemainingTime = remaining,
+            Status = isExpired ? StatusExpired : StatusRunning,
+            ExpiresAt = row.ExpiresAt,
+            PrintedAt = row.PrintedAt,
+            LocationId = row.LocationId,
+            ProductName = row.ProductName
+        };
+    }
+
+    private static (DateTime? DayStart, DateTime? DayEndExcl) ResolveDateDayFilter(string? dateDay)
+    {
+        if (string.IsNullOrWhiteSpace(dateDay))
+        {
+            return (null, null);
+        }
+
+        if (DateTime.TryParse(dateDay.Trim(), out var parsedDay))
+        {
+            var day = parsedDay.Date;
+            return (day, day.AddDays(1));
+        }
+
+        return (null, null);
+    }
+}