王明 / Food-Labeling-Management-Platform

  using System;
  using System.Collections.Generic;
  using System.Globalization;
  using System.Linq;
  using System.Text.Json;
  using System.Threading.Tasks;

  using FoodLabeling.Application.Contracts.Dtos.Common;

  using FoodLabeling.Application.Contracts.Dtos.Label;

  using FoodLabeling.Application.Contracts.Dtos.LabelTemplate;

  using FoodLabeling.Application.Contracts.Dtos.Reports;

  using FoodLabeling.Application.Contracts.Dtos.UsAppLabeling;
  using FoodLabeling.Application.Contracts.IServices;

  using FoodLabeling.Application.Helpers;

  using FoodLabeling.Application.Services.DbModels;

  using FoodLabeling.Domain.Entities;

  using Microsoft.AspNetCore.Authorization;

  using Microsoft.AspNetCore.Mvc;

  using SqlSugar;
  using Volo.Abp;
  using Volo.Abp.Application.Services;
  using Volo.Abp.Guids;
  using Volo.Abp.Uow;

  using Yi.Framework.Rbac.Domain.Entities;

  using Yi.Framework.SqlSugarCore.Abstractions;
  
  namespace FoodLabeling.Application.Services;
  
  /// <summary>
  /// App Labeling：四级列表（标签分类 → 产品分类 → 产品 → 标签种类）
  /// </summary>
  public class UsAppLabelingAppService : ApplicationService, IUsAppLabelingAppService
  {
      private readonly ISqlSugarDbContext _dbContext;
      private readonly ILabelAppService _labelAppService;
      private readonly IGuidGenerator _guidGenerator;

      private readonly ISqlSugarRepository<UserAggregateRoot, Guid> _userRepository;

      public UsAppLabelingAppService(
          ISqlSugarDbContext dbContext,
          ILabelAppService labelAppService,
          IGuidGenerator guidGenerator,
          ISqlSugarRepository<UserAggregateRoot, Guid> userRepository)

      {
          _dbContext = dbContext;
          _labelAppService = labelAppService;
          _guidGenerator = guidGenerator;

          _userRepository = userRepository;

      }
  
      /// <summary>
      /// 获取当前门店下四级嵌套数据
      /// </summary>
      /// <remarks>

      /// L1 标签分类 fl_label_category（含 buttonAppearance；COLOR/IMAGE 展示值在 categoryPhotoUrl）；仅对当前门店可用：ALL 或 SPECIFIED 且在 fl_label_category_location；
      /// L2 产品分类 fl_product.CategoryId join fl_product_category（同上，展示值在 categoryPhotoUrl）；

      /// L3 产品卡片：按「产品 + 标签模板」拆分（同一 productId、不同 fl_label.TemplateId 为多张卡）；L4 为该卡下与门店、标签分类、该产品、该模板关联的标签实例（fl_label + fl_label_type）。

      /// L2 产品分类展示名来自 fl_product_category；产品范围已由 fl_location_product 限定当前门店，
      /// 不再因产品分类 SPECIFIED 未配 fl_product_category_location 而整行过滤（避免 App 全店空数据）。

      /// 未归类或分类行未关联到 fl_product_category 时仍归入「无」节点。

      /// </remarks>
      [Authorize]
      public virtual async Task<List<UsAppLabelCategoryTreeNodeDto>> GetLabelingTreeAsync(UsAppLabelingTreeInputVo input)
      {
          if (string.IsNullOrWhiteSpace(input.LocationId))
          {
              throw new UserFriendlyException("门店Id不能为空");
          }
  
          var locationId = input.LocationId.Trim();
          var keyword = input.Keyword?.Trim();
          var filterCategoryId = input.LabelCategoryId?.Trim();
  

          await UsAppPrintLogScopeHelper.EnsureUserBoundToLocationAsync(
              CurrentUser, _dbContext.SqlSugarClient, locationId);
  

          var productIds = await _dbContext.SqlSugarClient.Queryable<FlLocationProductDbEntity>()
              .Where(x => x.LocationId == locationId)
              .Select(x => x.ProductId)
              .ToListAsync();
  
          if (productIds.Count == 0)
          {
              return new List<UsAppLabelCategoryTreeNodeDto>();
          }
  
          var query = BuildLabelingJoinQuery(locationId, productIds, filterCategoryId, keyword);
  
          var raw = await query
              .Select((lp, l, p, c, t, tpl, pc) => new LabelingTreeRow
              {
                  LabelCategoryId = c.Id,
                  LabelCategoryName = c.CategoryName,
                  LabelCategoryPhotoUrl = c.CategoryPhotoUrl,

                  LabelCategoryButtonAppearance = c.ButtonAppearance,

                  LabelCategoryOrderNum = c.OrderNum,
                  ProductCategoryId = p.CategoryId,
                  ProductCategoryName = pc.CategoryName,
                  ProductCategoryPhotoUrl = pc.CategoryPhotoUrl,

                  ProductCategoryDisplayText = pc.DisplayText,
                  ProductCategoryButtonAppearance = pc.ButtonAppearance,
                  ProductCategoryAvailabilityType = pc.AvailabilityType,
                  ProductCategoryOrderNum = pc.OrderNum,

                  ProductId = p.Id,
                  ProductName = p.ProductName,
                  ProductCode = p.ProductCode,
                  ProductImageUrl = p.ProductImageUrl,
                  LabelTypeId = t.Id,
                  TypeName = t.TypeName,
                  TypeOrderNum = t.OrderNum,

                  LabelCode = l.LabelCode ?? string.Empty,
                  TemplateId = tpl.Id,

                  TemplateCode = tpl.TemplateCode,
                  TemplateWidth = tpl.Width,
                  TemplateHeight = tpl.Height,
                  TemplateUnit = tpl.Unit
              })
              .ToListAsync();
  
          if (raw.Count == 0)
          {
              return new List<UsAppLabelCategoryTreeNodeDto>();
          }
  
          var byL1 = raw.GroupBy(x => new
          {
              x.LabelCategoryId,
              x.LabelCategoryName,
              x.LabelCategoryPhotoUrl,

              x.LabelCategoryButtonAppearance,

              x.LabelCategoryOrderNum
          }).OrderBy(g => g.Key.LabelCategoryOrderNum).ThenBy(g => g.Key.LabelCategoryName);
  
          var result = new List<UsAppLabelCategoryTreeNodeDto>();
          foreach (var g1 in byL1)
          {

              var l1Appearance = string.IsNullOrWhiteSpace(g1.Key.LabelCategoryButtonAppearance)
                  ? "TEXT"

                  : g1.Key.LabelCategoryButtonAppearance.Trim();

              var l1 = new UsAppLabelCategoryTreeNodeDto
              {
                  Id = g1.Key.LabelCategoryId,
                  CategoryName = g1.Key.LabelCategoryName ?? string.Empty,
                  CategoryPhotoUrl = g1.Key.LabelCategoryPhotoUrl,

                  ButtonAppearance = l1Appearance,

                  OrderNum = g1.Key.LabelCategoryOrderNum,
                  ProductCategories = new List<UsAppProductCategoryNodeDto>()
              };
  
              var byL2 = g1.GroupBy(x =>
                  {
                      var categoryId = NormalizeNullableId(x.ProductCategoryId);
                      if (categoryId is null)
                      {
                          return new
                          {
                              CategoryId = (string?)null,
                              CategoryName = "无",

                              CategoryPhotoUrl = (string?)null,
                              DisplayText = (string?)null,
                              ButtonAppearance = (string?)null,
                              AvailabilityType = (string?)null,
                              CategoryOrderNum = int.MaxValue

                          };
                      }
  
                      var categoryName = NormalizeCategoryName(x.ProductCategoryName);
                      var categoryPhotoUrl = NormalizeNullableUrl(x.ProductCategoryPhotoUrl);
                      return new
                      {
                          CategoryId = (string?)categoryId,
                          CategoryName = categoryName,

                          CategoryPhotoUrl = categoryPhotoUrl,
                          DisplayText = NormalizeNullableUrl(x.ProductCategoryDisplayText),
                          ButtonAppearance = NormalizeNullableId(x.ProductCategoryButtonAppearance),
                          AvailabilityType = NormalizeNullableId(x.ProductCategoryAvailabilityType),
                          CategoryOrderNum = x.ProductCategoryOrderNum

                      };
                  })

                  .OrderBy(g => g.Key.CategoryOrderNum)
                  .ThenBy(g => g.Key.CategoryName);

  
              foreach (var g2 in byL2)
              {

                  var productsGrouped = g2
                      .GroupBy(x => new { x.ProductId, x.TemplateId })
                      .OrderBy(pg => pg.First().ProductName)
                      .ThenBy(pg => pg.Key.TemplateId);

                  var appearance = string.IsNullOrWhiteSpace(g2.Key.ButtonAppearance)
                      ? "TEXT"

                      : g2.Key.ButtonAppearance.Trim();

                  var availability = string.IsNullOrWhiteSpace(g2.Key.AvailabilityType)
                      ? "ALL"
                      : g2.Key.AvailabilityType.Trim().ToUpperInvariant();

                  var l2 = new UsAppProductCategoryNodeDto
                  {
                      CategoryId = g2.Key.CategoryId,
                      CategoryPhotoUrl = g2.Key.CategoryPhotoUrl,
                      Name = g2.Key.CategoryName,

                      DisplayText = g2.Key.DisplayText,
                      ButtonAppearance = appearance,
                      AvailabilityType = availability,
                      OrderNum = g2.Key.CategoryOrderNum == int.MaxValue ? 0 : g2.Key.CategoryOrderNum,

                      ItemCount = productsGrouped.Count(),
                      Products = new List<UsAppLabelingProductNodeDto>()
                  };
  
                  foreach (var g3 in productsGrouped)
                  {
                      var first = g3.First();
                      var typeNodes = g3
                          .GroupBy(r => r.LabelCode)
                          .Select(gr => BuildLabelTypeNode(gr.First()))
                          .OrderBy(t => t.OrderNum)
                          .ThenBy(t => t.TypeName)
                          .ToList();
  
                      var subtitle = string.IsNullOrWhiteSpace(first.ProductCode?.Trim())
                          ? "无"
                          : first.ProductCode!.Trim();

                      var templateLabelSizeText = FormatLabelSize(
                          first.TemplateWidth,
                          first.TemplateHeight,
                          first.TemplateUnit);

  
                      l2.Products.Add(new UsAppLabelingProductNodeDto
                      {
                          ProductId = first.ProductId,

                          TemplateId = first.TemplateId,
                          TemplateCode = first.TemplateCode,
                          TemplateLabelSizeText = templateLabelSizeText,

                          ProductName = first.ProductName ?? string.Empty,
                          ProductCode = first.ProductCode ?? string.Empty,
                          ProductImageUrl = first.ProductImageUrl,
                          Subtitle = subtitle,
                          LabelTypeCount = typeNodes.Count,
                          LabelTypes = typeNodes
                      });
                  }
  
                  l1.ProductCategories.Add(l2);
              }
  
              result.Add(l1);
          }
  
          return result;
      }
  
      /// <summary>
      /// App 打印预览：按标签编码解析模板并返回顶部展示字段 + 预览模板结构
      /// </summary>
      /// <remarks>
      /// 示例请求：
      /// ```json
      /// {
      ///   "locationId": "LOC001",
      ///   "labelCode": "LBL0001",
      ///   "productId": "PROD001",
      ///   "baseTime": "2026-03-26T10:30:00",
      ///   "printInputJson": {
      ///     "price": "12.99"
      ///   }
      /// }
      /// ```
      /// </remarks>
      /// <param name="input">预览入参</param>
      /// <returns>顶部字段 + 预览模板结构</returns>
      /// <response code="200">成功</response>
      /// <response code="400">参数错误/数据不存在</response>
      /// <response code="500">服务器错误</response>
      [Authorize]
      public virtual async Task<UsAppLabelPreviewDto> PreviewAsync(UsAppLabelPreviewInputVo input)
      {
          if (input is null)
          {
              throw new UserFriendlyException("入参不能为空");
          }
  
          var locationId = input.LocationId?.Trim();
          if (string.IsNullOrWhiteSpace(locationId))
          {
              throw new UserFriendlyException("门店Id不能为空");
          }
  
          var labelCode = input.LabelCode?.Trim();
          if (string.IsNullOrWhiteSpace(labelCode))
          {
              throw new UserFriendlyException("labelCode不能为空");
          }
  
          var labelRow = await _dbContext.SqlSugarClient
              .Queryable<FlLabelDbEntity, FlLabelCategoryDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity>(
                  (l, c, t, tpl) => l.LabelCategoryId == c.Id && l.LabelTypeId == t.Id && l.TemplateId == tpl.Id)
              .Where((l, c, t, tpl) => !l.IsDeleted && l.State)
              .Where((l, c, t, tpl) => !c.IsDeleted && c.State)
              .Where((l, c, t, tpl) => !t.IsDeleted && t.State)
              .Where((l, c, t, tpl) => !tpl.IsDeleted)
              .Where((l, c, t, tpl) => l.LabelCode == labelCode)
              .Select((l, c, t, tpl) => new
              {

                  l.Id,

                  l.LabelCode,
                  l.LocationId,

                  l.LabelTypeId,
                  l.TemplateId,
                  l.LastModificationTime,
                  l.CreationTime,

                  LabelCategoryName = c.CategoryName,
                  TypeName = t.TypeName,
                  TemplateCode = tpl.TemplateCode,
                  TemplateWidth = tpl.Width,
                  TemplateHeight = tpl.Height,
                  TemplateUnit = tpl.Unit
              })
              .FirstAsync();
  
          if (labelRow is null)
          {
              throw new UserFriendlyException("标签不存在或不可用");
          }
  
          if (!string.Equals(labelRow.LocationId?.Trim(), locationId, StringComparison.OrdinalIgnoreCase))
          {
              throw new UserFriendlyException("该标签不属于当前门店");
          }
  

          var previewProductId = await ResolvePreviewProductIdAsync(labelRow.Id, input.ProductId);
  

          var template = await _labelAppService.PreviewAsync(new LabelPreviewResolveInputVo
          {
              LabelCode = labelCode,

              ProductId = previewProductId,

              BaseTime = input.BaseTime,
              PrintInputJson = input.PrintInputJson?.ToDictionary(x => x.Key, x => (object?)x.Value)
          });
  

          Dictionary<string, object?>? templateProductDefaultValues = null;
          if (!string.IsNullOrWhiteSpace(previewProductId))
          {
              var productDefault = await _dbContext.SqlSugarClient.Queryable<FlLabelTemplateProductDefaultDbEntity>()
                  .Where(x => x.TemplateId == labelRow.TemplateId)
                  .Where(x => x.ProductId == previewProductId)
                  .Where(x => x.LabelTypeId == labelRow.LabelTypeId)
                  .OrderBy(x => x.OrderNum)
                  .FirstAsync();
  
              if (!string.IsNullOrWhiteSpace(productDefault?.DefaultValuesJson))
              {
                  try
                  {
                      templateProductDefaultValues =
                          JsonSerializer.Deserialize<Dictionary<string, object?>>(productDefault.DefaultValuesJson!);
                  }
                  catch
                  {
                      templateProductDefaultValues = null;
                  }
              }
          }
  

          var productName = string.Empty;
          var productCategoryName = "无";

          if (!string.IsNullOrWhiteSpace(previewProductId))

          {

              var p = await _dbContext.SqlSugarClient.Queryable<FlProductDbEntity>()

                  .FirstAsync(x => !x.IsDeleted && x.State && x.Id == previewProductId);

              if (p is not null)
              {
                  productName = p.ProductName ?? string.Empty;
                  if (!string.IsNullOrWhiteSpace(p.CategoryId))
                  {
                      var pc = await _dbContext.SqlSugarClient.Queryable<FlProductCategoryDbEntity>()
                          .FirstAsync(x => !x.IsDeleted && x.State && x.Id == p.CategoryId);
                      productCategoryName = NormalizeCategoryName(pc?.CategoryName);
                  }
              }
          }
  
          return new UsAppLabelPreviewDto
          {

              LabelId = labelRow.Id,

              LocationId = locationId,
              LabelCode = labelCode,
              TemplateCode = labelRow.TemplateCode,
              LabelSizeText = FormatLabelSize(labelRow.TemplateWidth, labelRow.TemplateHeight, labelRow.TemplateUnit),
              TypeName = labelRow.TypeName,
              ProductName = string.IsNullOrWhiteSpace(productName) ? null : productName,
              ProductCategoryName = productCategoryName,
              LabelCategoryName = labelRow.LabelCategoryName,

              LabelLastEdited = labelRow.LastModificationTime ?? labelRow.CreationTime,

              PreviewImageBase64Png = null,

              Template = template,
              TemplateProductDefaultValues = templateProductDefaultValues

          };
      }
  
      /// <summary>
      /// App 打印：创建打印任务并落库打印明细（fl_label_print_task / fl_label_print_data）
      /// </summary>
      /// <param name="input">打印入参</param>
      /// <returns>任务Id</returns>
      [Authorize]
      [UnitOfWork]
      public virtual async Task<UsAppLabelPrintOutputDto> PrintAsync(UsAppLabelPrintInputVo input)
      {
          if (input is null)
          {
              throw new UserFriendlyException("入参不能为空");
          }
  
          var locationId = input.LocationId?.Trim();
          if (string.IsNullOrWhiteSpace(locationId))
          {
              throw new UserFriendlyException("门店Id不能为空");
          }
  
          var labelCode = input.LabelCode?.Trim();
          if (string.IsNullOrWhiteSpace(labelCode))
          {
              throw new UserFriendlyException("labelCode不能为空");
          }
  
          var quantity = input.PrintQuantity <= 0 ? 1 : input.PrintQuantity;

          var clientRequestId = input.ClientRequestId?.Trim();
          if (!string.IsNullOrWhiteSpace(clientRequestId))
          {
              // 幂等：同一个 clientRequestId 重复调用，直接返回首次创建的任务集合
              var existed = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
                  .Where(x => x.ClientRequestId == clientRequestId)
                  .OrderBy(x => x.CopyIndex)
                  .ToListAsync();
  
              if (existed is not null && existed.Count > 0)
              {
                  var existedBatchId = existed.First().BatchId;
                  var existedTaskIds = existed.Select(x => x.Id).ToList();
                  return new UsAppLabelPrintOutputDto
                  {
                      TaskId = existedTaskIds.FirstOrDefault() ?? string.Empty,
                      PrintQuantity = existedTaskIds.Count,
                      BatchId = existedBatchId,
                      TaskIds = existedTaskIds
                  };
              }
          }

  
          // 校验 label + location，并补齐一些顶部字段用于任务表落库
          var labelRow = await _dbContext.SqlSugarClient
              .Queryable<FlLabelDbEntity, FlLabelTypeDbEntity, FlLabelTemplateDbEntity>(
                  (l, t, tpl) => l.LabelTypeId == t.Id && l.TemplateId == tpl.Id)
              .Where((l, t, tpl) => !l.IsDeleted && l.State)
              .Where((l, t, tpl) => !t.IsDeleted && t.State)
              .Where((l, t, tpl) => !tpl.IsDeleted)
              .Where((l, t, tpl) => l.LabelCode == labelCode)
              .Select((l, t, tpl) => new
              {

                  l.Id,

                  l.LocationId,
                  l.LabelTypeId,

                  l.TemplateId

              })
              .FirstAsync();
  
          if (labelRow is null)
          {
              throw new UserFriendlyException("标签不存在或不可用");
          }
  
          if (!string.Equals(labelRow.LocationId?.Trim(), locationId, StringComparison.OrdinalIgnoreCase))
          {
              throw new UserFriendlyException("该标签不属于当前门店");
          }
  

          var previewProductId = await ResolvePreviewProductIdAsync(labelRow.Id, input.ProductId);

          var normalizedPrintInput = ParsePrintInputJsonToDictionary(input.PrintInputJson);

          // 解析模板 elements（与预览一致的渲染数据）
          var resolvedTemplate = await _labelAppService.PreviewAsync(new LabelPreviewResolveInputVo

          {

              LabelCode = labelCode,
              ProductId = previewProductId,
              BaseTime = input.BaseTime,
              PrintInputJson = normalizedPrintInput
          });

          var templateProductDefaultValuesJson = await ResolveTemplateProductDefaultValuesJsonAsync(
              labelRow.TemplateId,
              previewProductId,
              labelRow.LabelTypeId);

          var printInputJsonStr = input.PrintInputJson is null
              ? null
              : JsonSerializer.Serialize(input.PrintInputJson);

          var renderTemplateJsonStr = JsonSerializer.Serialize(resolvedTemplate);

  
          var now = DateTime.Now;
          var currentUserId = CurrentUser?.Id?.ToString();

          var batchId = _guidGenerator.Create().ToString();
          var taskIds = new List<string>();

          for (var i = 1; i <= quantity; i++)

          {

              var taskId = _guidGenerator.Create().ToString();
              taskIds.Add(taskId);

              var task = new FlLabelPrintTaskDbEntity

              {

                  Id = taskId,
                  BatchId = batchId,
                  CopyIndex = i,
                  ClientRequestId = string.IsNullOrWhiteSpace(clientRequestId) ? null : clientRequestId,
                  LabelId = labelRow.Id,
                  TemplateId = labelRow.TemplateId,
                  LabelTypeId = labelRow.LabelTypeId,
                  ProductId = previewProductId,
                  LocationId = locationId,

                  BaseTime = input.BaseTime,

                  PrintInputJson = printInputJsonStr,
                  TemplateProductDefaultValuesJson = templateProductDefaultValuesJson,
                  RenderTemplateJson = renderTemplateJsonStr,
                  PrinterId = input.PrinterId?.Trim(),
                  PrinterMac = input.PrinterMac?.Trim(),
                  PrinterAddress = input.PrinterAddress?.Trim(),
                  Status = "CREATED",
                  PrintedAt = null,
                  ErrorMessage = null,
                  CreatedBy = currentUserId,
                  CreationTime = now
              };

              await _dbContext.SqlSugarClient.Insertable(task).ExecuteCommandAsync();

              var rows = resolvedTemplate.Elements.Select(e =>
              {
                  var cfgJson = e.ConfigJson is null ? null : JsonSerializer.Serialize(e.ConfigJson);
                  string? renderValue = null;
                  if (e.ConfigJson is JsonElement je && je.ValueKind == JsonValueKind.Object && je.TryGetProperty("text", out var tv))
                  {
                      renderValue = tv.ValueKind == JsonValueKind.String ? tv.GetString() : tv.ToString();
                  }
                  else if (e.ConfigJson is Dictionary<string, object?> dict && dict.TryGetValue("text", out var v))
                  {
                      renderValue = v?.ToString();
                  }

                  return new FlLabelPrintDataDbEntity
                  {
                      Id = _guidGenerator.Create().ToString(),
                      PrintTaskId = taskId,
                      ElementId = e.Id?.Trim() ?? string.Empty,
                      ElementName = e.ElementName?.Trim(),
                      RenderValue = renderValue,
                      RenderConfigJson = cfgJson
                  };
              }).Where(x => !string.IsNullOrWhiteSpace(x.ElementId)).ToList();

              if (rows.Count > 0)
              {
                  await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();
              }
          }

  
          return new UsAppLabelPrintOutputDto
          {

              TaskId = taskIds.FirstOrDefault() ?? string.Empty,

              PrintQuantity = quantity,

              BatchId = batchId,
              TaskIds = taskIds

          };
      }
  
      /// <summary>

      /// App 重新打印：根据历史任务Id重打（创建新任务与明细）

      /// </summary>
      [Authorize]

      [UnitOfWork]
      public virtual async Task<UsAppLabelPrintOutputDto> ReprintAsync(UsAppLabelReprintInputVo input)

      {

          if (input is null)

          {
              throw new UserFriendlyException("入参不能为空");
          }
  
          var locationId = input.LocationId?.Trim();
          if (string.IsNullOrWhiteSpace(locationId))
          {
              throw new UserFriendlyException("门店Id不能为空");
          }
  

          var taskId = input.TaskId?.Trim();
          if (string.IsNullOrWhiteSpace(taskId))

          {

              throw new UserFriendlyException("taskId不能为空");

          }
  

          var quantity = input.PrintQuantity <= 0 ? 1 : input.PrintQuantity;
          var clientRequestId = input.ClientRequestId?.Trim();
          if (!string.IsNullOrWhiteSpace(clientRequestId))

          {

              var existed = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
                  .Where(x => x.ClientRequestId == clientRequestId)
                  .OrderBy(x => x.CopyIndex)

                  .ToListAsync();

              if (existed is not null && existed.Count > 0)

              {

                  var existedBatchId = existed.First().BatchId;
                  var existedTaskIds = existed.Select(x => x.Id).ToList();
                  return new UsAppLabelPrintOutputDto

                  {

                      TaskId = existedTaskIds.FirstOrDefault() ?? string.Empty,
                      PrintQuantity = existedTaskIds.Count,
                      BatchId = existedBatchId,
                      TaskIds = existedTaskIds
                  };

              }

          }

          var currentUserId = CurrentUser?.Id?.ToString();
          if (string.IsNullOrWhiteSpace(currentUserId))

          {

              throw new UserFriendlyException("未登录");
          }

          var old = await _dbContext.SqlSugarClient.Queryable<FlLabelPrintTaskDbEntity>()
              .FirstAsync(x => x.Id == taskId);
          if (old is null)

          {

              throw new UserFriendlyException("打印任务不存在");

          }
  

          // 管理员 / Partner 角色：可重打当前门店任意用户任务；其它角色仅本人
          var canViewAll = await UsAppPrintLogScopeHelper.CanViewAllPrintsAtLocationAsync(
              CurrentUser, _dbContext.SqlSugarClient);
          if (!canViewAll && !string.Equals(old.CreatedBy?.Trim(), currentUserId, StringComparison.OrdinalIgnoreCase))

          {

              throw new UserFriendlyException("无权限重打该任务");

          }

          if (!string.Equals(old.LocationId?.Trim(), locationId, StringComparison.OrdinalIgnoreCase))

          {

              throw new UserFriendlyException("该任务不属于当前门店");

          }
  

          LabelTemplatePreviewDto? resolvedTemplate = null;

          try
          {

              resolvedTemplate = JsonSerializer.Deserialize<LabelTemplatePreviewDto>(old.RenderTemplateJson);

          }
          catch
          {

              resolvedTemplate = null;

          }
  

          if (resolvedTemplate is null)
          {
              throw new UserFriendlyException("历史任务渲染快照解析失败，无法重打");
          }

          var now = DateTime.Now;
          var batchId = _guidGenerator.Create().ToString();
          var taskIds = new List<string>();
  
          for (var i = 1; i <= quantity; i++)

          {

              var newTaskId = _guidGenerator.Create().ToString();
              taskIds.Add(newTaskId);
  
              var newTask = new FlLabelPrintTaskDbEntity
              {
                  Id = newTaskId,
                  BatchId = batchId,
                  CopyIndex = i,
                  ClientRequestId = string.IsNullOrWhiteSpace(clientRequestId) ? null : clientRequestId,
                  LabelId = old.LabelId,
                  TemplateId = old.TemplateId,
                  LabelTypeId = old.LabelTypeId,
                  ProductId = old.ProductId,
                  LocationId = old.LocationId,
                  BaseTime = old.BaseTime,
                  PrintInputJson = old.PrintInputJson,
                  TemplateProductDefaultValuesJson = old.TemplateProductDefaultValuesJson,
                  RenderTemplateJson = old.RenderTemplateJson,
                  PrinterId = string.IsNullOrWhiteSpace(input.PrinterId) ? old.PrinterId : input.PrinterId.Trim(),
                  PrinterMac = string.IsNullOrWhiteSpace(input.PrinterMac) ? old.PrinterMac : input.PrinterMac.Trim(),
                  PrinterAddress = string.IsNullOrWhiteSpace(input.PrinterAddress) ? old.PrinterAddress : input.PrinterAddress.Trim(),
                  Status = "CREATED",
                  PrintedAt = null,
                  ErrorMessage = null,
                  CreatedBy = currentUserId,
                  CreationTime = now
              };
  
              await _dbContext.SqlSugarClient.Insertable(newTask).ExecuteCommandAsync();
  
              var rows = resolvedTemplate.Elements.Select(e =>

              {

                  var cfgJson = e.ConfigJson is null ? null : JsonSerializer.Serialize(e.ConfigJson);
                  string? renderValue = null;
                  if (e.ConfigJson is JsonElement je && je.ValueKind == JsonValueKind.Object && je.TryGetProperty("text", out var tv))

                  {

                      renderValue = tv.ValueKind == JsonValueKind.String ? tv.GetString() : tv.ToString();
                  }
                  else if (e.ConfigJson is Dictionary<string, object?> dict && dict.TryGetValue("text", out var v))
                  {
                      renderValue = v?.ToString();

                  }

  
                  return new FlLabelPrintDataDbEntity
                  {
                      Id = _guidGenerator.Create().ToString(),
                      PrintTaskId = newTaskId,
                      ElementId = e.Id?.Trim() ?? string.Empty,
                      ElementName = e.ElementName?.Trim(),
                      RenderValue = renderValue,
                      RenderConfigJson = cfgJson
                  };
              }).Where(x => !string.IsNullOrWhiteSpace(x.ElementId)).ToList();
  
              if (rows.Count > 0)
              {
                  await _dbContext.SqlSugarClient.Insertable(rows).ExecuteCommandAsync();

              }
          }

          return new UsAppLabelPrintOutputDto
          {
              TaskId = taskIds.FirstOrDefault() ?? string.Empty,
              PrintQuantity = quantity,
              BatchId = batchId,
              TaskIds = taskIds
          };

      }
  
      /// <summary>

      /// App 打印日志：当前门店打印记录（分页，时间倒序）

      /// </summary>

      /// <remarks>

      /// 数据范围（须已绑定 <c>input.locationId</c>）：
      /// <list type="bullet">
      /// <item><b>管理员</b>（<see cref="ReportsRoleHelper.IsAdminRole"/>）或角色码/名含 <c>partner</c>：该门店 <b>全部</b> 打印任务；</item>
      /// <item>其它角色：仅 <c>CreatedBy == CurrentUser.Id</c>。</item>
      /// </list>

      ///
      /// 示例请求：
      /// ```json
      /// {
      ///   "locationId": "11111111-1111-1111-1111-111111111111",
      ///   "skipCount": 1,
      ///   "maxResultCount": 20
      /// }
      /// ```
      ///
      /// 参数说明：
      /// - locationId: 当前门店 Id（必填）
      /// - skipCount: 页码（从 1 开始，遵循本项目约定）
      /// - maxResultCount: 每页条数
      /// </remarks>
      /// <param name="input">分页查询入参</param>
      /// <returns>分页打印日志</returns>
      /// <response code="200">成功</response>
      /// <response code="400">参数错误/未登录</response>
      /// <response code="500">服务器错误</response>

      [Authorize]

      [HttpPost]

      public virtual async Task<PagedResultWithPageDto<PrintLogItemDto>> GetPrintLogListAsync(PrintLogGetListInputVo 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不能为空");
          }
  

          var currentUserIdStr = CurrentUser.Id.Value.ToString();

          await UsAppPrintLogScopeHelper.EnsureUserBoundToLocationAsync(
              CurrentUser, _dbContext.SqlSugarClient, locationId);

          var canViewAll = await UsAppPrintLogScopeHelper.CanViewAllPrintsAtLocationAsync(
              CurrentUser, _dbContext.SqlSugarClient);
          var restrictToCreator = !canViewAll;

          var locationName = "无";
          if (Guid.TryParse(locationId, out var locationGuid))

          {

              var loc = await _dbContext.SqlSugarClient.Queryable<LocationAggregateRoot>()
                  .Where(x => !x.IsDeleted && x.Id == locationGuid)
                  .Select(x => new { x.LocationCode, x.LocationName })
                  .FirstAsync();
              if (loc is not null)
              {
                  var name = loc.LocationName?.Trim();
                  if (!string.IsNullOrWhiteSpace(name))
                  {
                      locationName = name;
                  }
              }

          }
  

          RefAsync<int> total = 0;

          var query = UsAppPrintLogScopeHelper.BuildLocationPrintTaskQuery(
                  _dbContext.SqlSugarClient, locationId, restrictToCreator, currentUserIdStr)

              .OrderBy((t, l, p, lt, tpl) => SqlFunc.IsNull(t.PrintedAt, t.CreationTime), OrderByType.Desc)
              .OrderBy((t, l, p, lt, tpl) => t.CreationTime, OrderByType.Desc)
              .Select((t, l, p, lt, tpl) => new
              {
                  t.Id,
                  t.BatchId,
                  t.CopyIndex,
                  t.LabelId,
                  LabelCode = l.LabelCode,
                  t.ProductId,
                  ProductName = p.ProductName,
                  TypeName = lt.TypeName,
                  TemplateWidth = tpl.Width,
                  TemplateHeight = tpl.Height,
                  TemplateUnit = tpl.Unit,