antissoft / lvqianmeiye_ERP

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  using Mapster;
  using Microsoft.AspNetCore.Mvc;
  using Microsoft.Extensions.Logging;
  using NCC.ClayObject;
  using NCC.Common.Configuration;
  using NCC.Common.Core.Manager;

  using NCC.Common.Enum;
  using NCC.Common.Extension;
  using NCC.Common.Filter;

  using NCC.Common.Helper;
  using NCC.Common.Model.NPOI;
  using NCC.DataEncryption;

  using NCC.Dependency;
  using NCC.DynamicApiController;

  using NCC.Extend.Entitys.Dto.LqPersonTimesRecord;

  using NCC.Extend.Entitys.Dto.LqXhHyhk;

  using NCC.Extend.Entitys.Dto.LqXhJksyj;
  using NCC.Extend.Entitys.Dto.LqXhKjbsyj;
  using NCC.Extend.Entitys.Dto.LqXhPxmx;

  using NCC.Extend.Entitys.Dto.LqYyjl;

  using NCC.Extend.Entitys.Enum;

  using NCC.Extend.Entitys.lq_kd_kdjlb;
  using NCC.Extend.Entitys.lq_kd_pxmx;
  using NCC.Extend.Entitys.lq_khxx;

  using NCC.Extend.Entitys.lq_person_times_record;

  using NCC.Extend.Entitys.lq_xh_hyhk;
  using NCC.Extend.Entitys.lq_xh_jksyj;
  using NCC.Extend.Entitys.lq_xh_kjbsyj;
  using NCC.Extend.Entitys.lq_xh_pxmx;

  using NCC.Extend.Entitys.lq_xmzl;

  using NCC.Extend.Entitys.lq_mdxx;

  using NCC.Extend.Interfaces.LqXhHyhk;
  using NCC.FriendlyException;

  using NCC.JsonSerialization;

  using SqlSugar;
  using Yitter.IdGenerator;

  
  namespace NCC.Extend.LqXhHyhk
  {
      /// <summary>

      /// 耗卡记录表服务

      /// </summary>

      [ApiDescriptionSettings(Tag = "绿纤耗卡记录表服务", Name = "LqXhHyhk", Order = 200, Groups = new[] { "Default" })]

      [Route("api/Extend/[controller]")]
      public class LqXhHyhkService : ILqXhHyhkService, IDynamicApiController, ITransient
      {
          private readonly ISqlSugarRepository<LqXhHyhkEntity> _lqXhHyhkRepository;
          private readonly ISqlSugarRepository<LqXhJksyjEntity> _lqXhJksyjRepository;
          private readonly ISqlSugarRepository<LqXhKjbsyjEntity> _lqXhKjbsyjRepository;
          private readonly ISqlSugarRepository<LqXhPxmxEntity> _lqXhPxmxRepository;
          private readonly SqlSugarScope _db;
          private readonly IUserManager _userManager;

          private readonly ILogger<LqXhHyhkService> _logger;

  
          /// <summary>
          /// 初始化一个<see cref="LqXhHyhkService"/>类型的新实例
          /// </summary>
          public LqXhHyhkService(
              ISqlSugarRepository<LqXhHyhkEntity> lqXhHyhkRepository,
              ISqlSugarRepository<LqXhJksyjEntity> lqXhJksyjRepository,
              ISqlSugarRepository<LqXhKjbsyjEntity> lqXhKjbsyjRepository,
              ISqlSugarRepository<LqXhPxmxEntity> lqXhPxmxRepository,

              IUserManager userManager,

              ILogger<LqXhHyhkService> logger
          )

          {

              _lqXhHyhkRepository = lqXhHyhkRepository;

              _db = _lqXhHyhkRepository.Context;
              _lqXhJksyjRepository = lqXhJksyjRepository;
              _lqXhKjbsyjRepository = lqXhKjbsyjRepository;
              _lqXhPxmxRepository = lqXhPxmxRepository;
              _userManager = userManager;

              _logger = logger;

          }
  

          #region 获取会员耗卡

          /// <summary>
          /// 获取会员耗卡
          /// </summary>

          /// <remarks>
          /// 获取耗卡记录及其关联的品项明细、健康师业绩、科技部老师业绩信息
          /// 按照耗卡的完整格式返回数据，不包含汇总信息

          ///

          /// 返回数据结构：
          /// - 主表信息：耗卡基础信息、门店信息、会员信息等
          /// - 品项明细列表：每个品项包含完整的项目信息（项目次数、是否有效、来源类型等）
          /// - 健康师业绩列表：按品项关联的健康师业绩信息
          /// - 科技部老师业绩列表：按品项关联的科技部老师业绩信息
          /// </remarks>
          /// <param name="id">耗卡记录主键ID</param>
          /// <returns>耗卡记录完整信息</returns>
          /// <response code="200">查询成功</response>
          /// <response code="404">耗卡记录不存在</response>
          /// <response code="500">服务器内部错误</response>

          [HttpGet("{id}")]
          public async Task<dynamic> GetInfo(string id)
          {

              try
              {
                  // 1. 查询主表信息
                  var entity = await _db.Queryable<LqXhHyhkEntity>().FirstAsync(p => p.Id == id);
                  if (entity == null)
                  {
                      throw NCCException.Oh(ErrorCode.COM1005, "耗卡记录不存在");
                  }
  
                  var output = entity.Adapt<LqXhHyhkInfoOutput>();

                  //获取会员信息
                  var MemberInfo = await _db.Queryable<LqKhxxEntity>().FirstAsync(p => p.Id == entity.Hy);
                  output.hymc = MemberInfo.Khmc;
                  output.memberPhone = MemberInfo.Sjh;

  
                  // 2. 查询品项明细列表

                  var lqXhPxmxList = await _db.Queryable<LqXhPxmxEntity>().Where(w => w.ConsumeInfoId == entity.Id).ToListAsync();

                  // 3. 查询健康师业绩列表

                  var lqXhJksyjList = await _db.Queryable<LqXhJksyjEntity>().Where(w => w.Glkdbh == entity.Id).ToListAsync();

                  // 4. 查询科技部老师业绩列表

                  var lqXhKjbsyjList = await _db.Queryable<LqXhKjbsyjEntity>().Where(w => w.Glkdbh == entity.Id).ToListAsync();

                  // 获取人次记录列表
                  var personTimesRecordList = await _db.Queryable<LqPersonTimesRecordEntity>().Where(x => x.BusinessId == entity.Id && x.IsEffective == StatusEnum.有效.GetHashCode()).ToListAsync();

                  // 5. 构建品项明细输出，每个品项关联对应的业绩信息
                  var pxmxOutputList = new List<LqXhPxmxInfoOutput>();
                  foreach (var pxmx in lqXhPxmxList)
                  {
                      var pxmxOutput = new LqXhPxmxInfoOutput
                      {
                          id = pxmx.Id,

                          consumeInfoId = pxmx.ConsumeInfoId,
                          billingItemId = pxmx.BillingItemId,

                          px = pxmx.Px,
                          pxmc = pxmx.Pxmc,
                          pxjg = pxmx.Pxjg,

                          memberId = pxmx.MemberId,
                          createTime = pxmx.CreateTIme,
                          projectNumber = pxmx.ProjectNumber,

                          sourceType = pxmx.SourceType,

                          totalPrice = pxmx.TotalPrice,

                          isEffective = pxmx.IsEffective,

                          originalProjectNumber = pxmx.OriginalProjectNumber,
                          overtimeProjectNumber = pxmx.OvertimeProjectNumber

                      };
  
                      // 关联该品项的健康师业绩
                      var jksyjForPx = lqXhJksyjList.Where(j => j.Kdpxid == pxmx.Id).ToList();
                      pxmxOutput.lqXhJksyjList = jksyjForPx.Adapt<List<LqXhJksyjInfoOutput>>();
  
                      // 关联该品项的科技部老师业绩
                      var kjbsyjForPx = lqXhKjbsyjList.Where(k => k.Hkpxid == pxmx.Id).ToList();
                      pxmxOutput.lqXhKjbsyjList = kjbsyjForPx.Adapt<List<LqXhKjbsyjInfoOutput>>();
  
                      pxmxOutputList.Add(pxmxOutput);
                  }

                  // 6. 设置输出结果
                  output.lqXhPxmxList = pxmxOutputList;

                  // 7. 设置全局业绩列表（用于兼容性，但主要使用品项关联的业绩）
                  output.lqXhJksyjList = lqXhJksyjList.Adapt<List<LqXhJksyjInfoOutput>>();
                  output.lqXhKjbsyjList = lqXhKjbsyjList.Adapt<List<LqXhKjbsyjInfoOutput>>();

                  return output;
              }
              catch (Exception ex)
              {
                  _logger.LogError(ex, "获取耗卡记录失败，ID：{Id}", id);
                  throw NCCException.Oh(ErrorCode.COM1000, "获取耗卡记录失败");
              }

          }

          #endregion

          #region 获取会员耗卡列表

          /// <summary>

          /// 获取会员耗卡列表
          /// </summary>

          /// <remarks>
          /// 根据多种条件查询会员耗卡记录列表，支持分页、排序、筛选等功能
          /// 
          /// 示例请求：
          /// GET /api/Extend/LqXhHyhk/GetList?currentPage=1&amp;pageSize=10&amp;jksId=健康师ID&amp;startTime=2025-01-01&amp;endTime=2025-01-31
          /// 
          /// 传入参数说明：
          /// - currentPage: 当前页码（必填，默认1）
          /// - pageSize: 每页数量（必填，默认10）
          /// - sidx: 排序字段（可选，默认"id"）
          /// - sort: 排序方式（可选，ASC/DESC，默认DESC）
          /// - keyword: 关键字搜索（可选，搜索会员名称、账号、手机号）
          /// - id: 耗卡编号（可选，模糊匹配）
          /// - md: 门店ID（可选，精确匹配）
          /// - mdbh: 门店编号（可选，模糊匹配）
          /// - mdmc: 门店名称（可选，模糊匹配）
          /// - hy: 会员ID（可选，精确匹配）
          /// - hyzh: 会员账号（可选，模糊匹配）
          /// - hymc: 会员名称（可选，模糊匹配）
          /// - gklx: 顾客类型（可选，精确匹配）
          /// - sfykjb: 是否有科技部（可选，精确匹配）
          /// - hksj: 耗卡时间（可选，格式：开始时间,结束时间，如：2025-01-01,2025-01-31）
          /// - czry: 操作人员ID（可选，精确匹配）
          /// - isEffective: 是否有效（可选，0=全部，1=有效，2=无效，默认0）
          /// - jksId: 健康师ID（可选，传入后只返回该健康师参与的耗卡记录）
          /// - kjblsId: 科技部老师ID（可选，传入后只返回该老师参与的耗卡记录）
          /// 
          /// 返回结果说明：
          /// - code: 响应状态码（200=成功）
          /// - msg: 响应消息
          /// - data: 分页数据对象
          ///   - list: 耗卡记录列表，每个记录包含：
          ///     - id: 耗卡编号
          ///     - md: 门店ID
          ///     - mdbh: 门店编号
          ///     - mdmc: 门店名称
          ///     - hy: 会员ID
          ///     - hyzh: 会员账号
          ///     - hymc: 会员名称
          ///     - memberPhone: 会员手机号
          ///     - gklx: 顾客类型
          ///     - xfje: 消费金额
          ///     - sgfy: 手工费用
          ///     - sfykjb: 是否有科技部
          ///     - hksj: 耗卡时间
          ///     - czry: 操作人员ID
          ///     - isEffective: 是否有效
          ///     - signatureFile: 签名文件
          ///     - overtimeCoefficient: 加班系数（NULL或0表示非加班单，大于0表示加班单）
          ///     - originalSgfy: 原始手工费（用户输入的原始值）
          ///     - overtimeSgfy: 加班手工费（加班计算后的增量值）
          ///     - ConsumeDetails: 耗卡明细列表（品项明细），每个明细包含：
          ///       - id: 明细编号
          ///       - consumeInfoId: 耗卡记录ID
          ///       - billingItemId: 开单品项明细表ID
          ///       - px: 品项编号
          ///       - pxmc: 品项名称
          ///       - pxjg: 品项价格
          ///       - memberId: 会员ID
          ///       - createTime: 创建时间
          ///       - projectNumber: 项目次数
          ///       - originalProjectNumber: 原始项目次数
          ///       - overtimeProjectNumber: 加班项目次数
          ///       - sourceType: 来源类型（开卡/赠送/其他）
          ///       - totalPrice: 合计金额（品项价格 × 项目次数）
          ///       - isEffective: 是否有效
          ///     - lqXhJksyjList: 健康师业绩列表，每个业绩包含：
          ///       - id: 业绩编号
          ///       - glkdbh: 关联耗卡编号
          ///       - jks: 健康师ID
          ///       - jksxm: 健康师姓名
          ///       - jkszh: 健康师账号
          ///       - jksyj: 健康师业绩
          ///       - yjsj: 业绩时间
          ///       - jsjId: 金三角ID
          ///       - kdpxid: 耗卡品项ID
          ///       - laborCost: 手工费
          ///       - kdpxNumber: 耗卡品项次数
          ///       - originalKdpxNumber: 原始耗卡品项次数
          ///       - overtimeKdpxNumber: 加班耗卡品项次数
          ///       - originalLaborCost: 原始手工费
          ///       - overtimeLaborCost: 加班手工费
          ///       - isAccompanied: 是否陪同（0=否，1=是）
          ///       - accompaniedProjectNumber: 陪同项目数
          ///       - memberId: 会员ID
          ///       - memberName: 会员名称
          ///     - lqXhKjbsyjList: 科技部老师业绩列表，每个业绩包含：
          ///       - id: 业绩编号
          ///       - glkdbh: 关联耗卡编号
          ///       - kjbls: 科技部老师ID
          ///       - kjblsxm: 科技部老师姓名
          ///       - kjblszh: 科技部老师账号
          ///       - kjblsyj: 科技部老师业绩
          ///       - yjsj: 业绩时间
          ///       - hkpxid: 耗卡品项ID
          ///       - laborCost: 手工费
          ///       - hdpxNumber: 耗卡品项次数
          ///       - originalHdpxNumber: 原始耗卡品项次数
          ///       - overtimeHdpxNumber: 加班耗卡品项次数
          ///       - originalLaborCost: 原始手工费
          ///       - overtimeLaborCost: 加班手工费
          ///   - pagination: 分页信息
          ///     - total: 总记录数
          ///     - pageSize: 每页数量
          ///     - currentPage: 当前页码
          ///     - totalPages: 总页数
          /// </remarks>
          /// <param name="input">查询参数</param>
          /// <returns>分页的耗卡记录列表，包含耗卡基本信息、耗卡明细、健康师业绩、科技部老师业绩</returns>
          /// <response code="200">成功返回耗卡列表</response>
          /// <response code="400">参数错误</response>
          /// <response code="500">服务器内部错误</response>

          [HttpGet("")]
          public async Task<dynamic> GetList([FromQuery] LqXhHyhkListQueryInput input)
          {
              var sidx = input.sidx == null ? "id" : input.sidx;

              var sort = string.IsNullOrEmpty(input.sort) ? "DESC" : input.sort;
              List<string> queryHksj = input.hksj != null ? input.hksj.Split(',').ToObeject<List<string>>() : null;
              DateTime? startHksj = queryHksj != null ? Ext.GetDateTime(queryHksj.First()) : null;
              DateTime? endHksj = queryHksj != null ? Ext.GetDateTime(queryHksj.Last()) : null;
  
              // 根据是否传入健康师ID或科技部老师ID来决定查询方式
              ISugarQueryable<LqXhHyhkEntity> query = null;
  
              // 如果两个都传入了，需要同时JOIN两个表
              if (!string.IsNullOrEmpty(input.jksId) && !string.IsNullOrEmpty(input.kjblsId))
              {

                  query = _db.Queryable<LqXhJksyjEntity, LqXhKjbsyjEntity, LqXhHyhkEntity>((jksyj, kjbsyj, hyhk) => jksyj.Glkdbh == hyhk.Id && kjbsyj.Glkdbh == hyhk.Id)

                      .Where((jksyj, kjbsyj, hyhk) => jksyj.Jkszh == input.jksId && jksyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Where((jksyj, kjbsyj, hyhk) => kjbsyj.Kjblszh == input.kjblsId && kjbsyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((jksyj, kjbsyj, hyhk) => hyhk)
                      .Distinct()
                      .MergeTable(); // 将多表结果集变成单表，后续可以使用it别名
              }
              // 如果只传入了健康师ID，需要通过JOIN健康师业绩表来过滤
              else if (!string.IsNullOrEmpty(input.jksId))
              {
                  query = _db.Queryable<LqXhJksyjEntity, LqXhHyhkEntity>(
                          (jksyj, hyhk) => jksyj.Glkdbh == hyhk.Id)
                      .Where((jksyj, hyhk) => jksyj.Jkszh == input.jksId && jksyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((jksyj, hyhk) => hyhk)
                      .Distinct()
                      .MergeTable(); // 将多表结果集变成单表，后续可以使用it别名
              }
              // 如果只传入了科技部老师ID，需要通过JOIN科技部老师业绩表来过滤
              else if (!string.IsNullOrEmpty(input.kjblsId))
              {
                  query = _db.Queryable<LqXhKjbsyjEntity, LqXhHyhkEntity>(
                          (kjbsyj, hyhk) => kjbsyj.Glkdbh == hyhk.Id)
                      .Where((kjbsyj, hyhk) => kjbsyj.Kjblszh == input.kjblsId && kjbsyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((kjbsyj, hyhk) => hyhk)
                      .Distinct()
                      .MergeTable(); // 将多表结果集变成单表，后续可以使用it别名
              }
              // 如果都没有传入，直接查询耗卡表
              else
              {
                  query = _db.Queryable<LqXhHyhkEntity>();
              }
  
              var data = await query
                  .WhereIF(!string.IsNullOrEmpty(input.keyword), p => p.Hymc.Contains(input.keyword) || p.Hyzh.Contains(input.keyword) || p.MemberPhone.Contains(input.keyword))
                  .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                  .WhereIF(!string.IsNullOrEmpty(input.md), p => p.Md.Equals(input.md))
                  .WhereIF(!string.IsNullOrEmpty(input.mdbh), p => p.Mdbh.Contains(input.mdbh))
                  .WhereIF(!string.IsNullOrEmpty(input.mdmc), p => p.Mdmc.Contains(input.mdmc))
                  .WhereIF(!string.IsNullOrEmpty(input.hy), p => p.Hy.Equals(input.hy))
                  .WhereIF(!string.IsNullOrEmpty(input.hyzh), p => p.Hyzh.Contains(input.hyzh))
                  .WhereIF(!string.IsNullOrEmpty(input.hymc), p => p.Hymc.Contains(input.hymc))
                  .WhereIF(!string.IsNullOrEmpty(input.gklx), p => p.Gklx.Equals(input.gklx))
                  .WhereIF(!string.IsNullOrEmpty(input.sfykjb), p => p.Sfykjb.Equals(input.sfykjb))
                  .WhereIF(queryHksj != null, p => p.Hksj >= new DateTime(startHksj.ToDate().Year, startHksj.ToDate().Month, startHksj.ToDate().Day, 0, 0, 0))
                  .WhereIF(queryHksj != null, p => p.Hksj <= new DateTime(endHksj.ToDate().Year, endHksj.ToDate().Month, endHksj.ToDate().Day, 23, 59, 59))
                  .WhereIF(!string.IsNullOrEmpty(input.czry), p => p.Czry.Equals(input.czry))
                  .WhereIF(input.isEffective != 0, p => p.IsEffective == input.isEffective)
                  .Select(it => new LqXhHyhkListOutput
                  {
                      id = it.Id,
                      md = it.Md,
                      mdbh = it.Mdbh,
                      mdmc = it.Mdmc,
                      hy = it.Hy,
                      hyzh = it.Hyzh,
                      hymc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == it.Hy).Select(w => w.Khmc),
                      gklx = it.Gklx,
                      xfje = SqlFunc.ToString(it.Xfje),
                      sgfy = SqlFunc.ToString(it.Sgfy),
                      sfykjb = it.Sfykjb,
                      hksj = it.Hksj,
                      czry = it.Czry,
                      memberPhone = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == it.Hy).Select(w => w.Sjh),
                      isEffective = it.IsEffective,
                      signatureFile = it.SignatureFile,
                      overtimeCoefficient = it.OvertimeCoefficient,
                      originalSgfy = it.OriginalSgfy,
                      overtimeSgfy = it.OvertimeSgfy,

                      appointmentId = it.AppointmentId,

                  })
                  .MergeTable()
                  .OrderBy($"{sidx} {sort}")
                  .ToPagedListAsync(input.currentPage, input.pageSize);
  
              // 获取当前页的耗卡记录ID列表
              var consumeIds = data.list.Select(x => x.id).ToList();
  
              // 批量查询耗卡明细
              var consumeDetails = new List<LqXhPxmxInfoOutput>();
              if (consumeIds.Any())
              {
                  consumeDetails = await _db.Queryable<LqXhPxmxEntity>()
                      .Where(x => consumeIds.Contains(x.ConsumeInfoId) && x.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select(x => new LqXhPxmxInfoOutput
                      {
                          id = x.Id,
                          consumeInfoId = x.ConsumeInfoId,
                          billingItemId = x.BillingItemId,
                          px = x.Px,
                          pxmc = x.Pxmc,
                          pxjg = x.Pxjg,
                          memberId = x.MemberId,
                          createTime = x.CreateTIme,
                          projectNumber = x.ProjectNumber,
                          originalProjectNumber = x.OriginalProjectNumber,
                          overtimeProjectNumber = x.OvertimeProjectNumber,
                          sourceType = x.SourceType,
                          totalPrice = x.TotalPrice,
                          isEffective = x.IsEffective,
                      })
                      .ToListAsync();
              }
  
              // 按耗卡记录ID分组耗卡明细
              var consumeDetailsGrouped = consumeDetails.GroupBy(x => x.consumeInfoId)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 批量查询健康师业绩（性能优化：一次性查询所有耗卡的健康师业绩）
              var jksyjList = new List<LqXhJksyjInfoOutput>();
              if (consumeIds.Any())
              {
                  // 先查询业绩数据
                  var jksyjEntities = await _db.Queryable<LqXhJksyjEntity>()
                      .Where(x => consumeIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode())
                      .ToListAsync();
  
                  // 批量查询耗卡记录获取会员ID
                  var hyhkList = await _db.Queryable<LqXhHyhkEntity>()
                      .Where(x => consumeIds.Contains(x.Id))
                      .Select(x => new { x.Id, x.Hy })
                      .ToListAsync();
                  var hyhkDict = hyhkList.ToDictionary(x => x.Id, x => x.Hy);
  
                  // 批量查询会员信息
                  var memberIds = hyhkDict.Values.Where(x => !string.IsNullOrEmpty(x)).Distinct().ToList();
                  var memberList = new List<(string Id, string Khmc)>();
                  if (memberIds.Any())
                  {
                      var memberData = await _db.Queryable<LqKhxxEntity>()
                          .Where(x => memberIds.Contains(x.Id))
                          .Select(x => new { x.Id, x.Khmc })
                          .ToListAsync();
                      memberList = memberData.Select(x => (x.Id, x.Khmc)).ToList();
                  }
                  var memberDict = memberList.ToDictionary(x => x.Id, x => x.Khmc);
  
                  // 转换为输出DTO
                  jksyjList = jksyjEntities.Select(x => new LqXhJksyjInfoOutput
                  {
                      id = x.Id,
                      glkdbh = x.Glkdbh,
                      jks = x.Jks,
                      jksxm = x.Jksxm,
                      jkszh = x.Jkszh,
                      jksyj = x.Jksyj?.ToString() ?? "0",
                      yjsj = x.Yjsj,
                      jsjId = x.JsjId,
                      kdpxid = x.Kdpxid,
                      laborCost = x.LaborCost,
                      kdpxNumber = x.KdpxNumber,
                      originalKdpxNumber = x.OriginalKdpxNumber,
                      overtimeKdpxNumber = x.OvertimeKdpxNumber,
                      originalLaborCost = x.OriginalLaborCost,
                      overtimeLaborCost = x.OvertimeLaborCost,
                      isAccompanied = x.IsAccompanied,
                      accompaniedProjectNumber = x.AccompaniedProjectNumber,
                      memberId = hyhkDict.ContainsKey(x.Glkdbh) ? hyhkDict[x.Glkdbh] : null,
                      memberName = hyhkDict.ContainsKey(x.Glkdbh) && memberDict.ContainsKey(hyhkDict[x.Glkdbh])
                          ? memberDict[hyhkDict[x.Glkdbh]]
                          : null,
                  }).ToList();
              }
  
              // 批量查询科技部老师业绩（性能优化：一次性查询所有耗卡的科技部老师业绩）
              var kjbsyjList = new List<LqXhKjbsyjInfoOutput>();
              if (consumeIds.Any())
              {
                  kjbsyjList = await _db.Queryable<LqXhKjbsyjEntity>()
                      .Where(x => consumeIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select(x => new LqXhKjbsyjInfoOutput
                      {
                          id = x.Id,
                          glkdbh = x.Glkdbh,
                          kjbls = x.Kjbls,
                          kjblsxm = x.Kjblsxm,
                          kjblszh = x.Kjblszh,
                          kjblsyj = SqlFunc.ToString(x.Kjblsyj),
                          yjsj = x.Yjsj,
                          hkpxid = x.Hkpxid,
                          laborCost = x.LaborCost,
                          hdpxNumber = x.HdpxNumber,
                          originalHdpxNumber = x.OriginalHdpxNumber,
                          overtimeHdpxNumber = x.OvertimeHdpxNumber,
                          originalLaborCost = x.OriginalLaborCost,
                          overtimeLaborCost = x.OvertimeLaborCost,
                      })
                      .ToListAsync();
              }
  
              // 按耗卡记录ID分组健康师业绩
              var jksyjGrouped = jksyjList.GroupBy(x => x.glkdbh)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 按耗卡记录ID分组科技部老师业绩
              var kjbsyjGrouped = kjbsyjList.GroupBy(x => x.glkdbh)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 为每个耗卡记录分配耗卡明细、健康师业绩和科技部老师业绩
              foreach (var item in data.list)
              {
                  item.ConsumeDetails = consumeDetailsGrouped.ContainsKey(item.id)
                      ? consumeDetailsGrouped[item.id]
                      : new List<LqXhPxmxInfoOutput>();
  
                  item.lqXhJksyjList = jksyjGrouped.ContainsKey(item.id)
                      ? jksyjGrouped[item.id]
                      : new List<LqXhJksyjInfoOutput>();
  
                  item.lqXhKjbsyjList = kjbsyjGrouped.ContainsKey(item.id)
                      ? kjbsyjGrouped[item.id]
                      : new List<LqXhKjbsyjInfoOutput>();
              }
  
              return PageResult<LqXhHyhkListOutput>.SqlSugarPageResult(data);
          }
          #endregion
  

          #region 根据健康师ID获取耗卡列表
          /// <summary>
          /// 根据健康师ID获取耗卡列表
          /// </summary>
          /// <remarks>
          /// 根据健康师ID查询该健康师参与的所有耗卡记录，支持时间周期查询和分页
          /// 
          /// 示例请求：
          /// GET /api/Extend/LqXhHyhk/GetListByJksId?jksId=健康师ID&amp;startTime=2025-01-01&amp;endTime=2025-01-31&amp;currentPage=1&amp;pageSize=10
          /// 
          /// 参数说明：
          /// - jksId: 健康师ID（必填）
          /// - startTime: 开始时间（可选，格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
          /// - endTime: 结束时间（可选，格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
          /// - md: 门店ID（可选）
          /// - isEffective: 是否有效（可选，0=全部，1=有效，2=无效，默认1）
          /// - currentPage: 当前页码（必填）
          /// - pageSize: 每页数量（必填）
          /// 
          /// 返回说明：
          /// - 返回格式与GetList接口相同，包含耗卡基本信息及耗卡明细列表
          /// </remarks>
          /// <param name="input">查询参数</param>
          /// <returns>耗卡列表（分页）</returns>
          /// <response code="200">查询成功</response>
          /// <response code="400">参数错误</response>
          /// <response code="500">服务器内部错误</response>
          [HttpGet("GetListByJksId")]
          public async Task<dynamic> GetListByJksId([FromQuery] LqXhHyhkListByJksQueryInput input)
          {
              try
              {
                  if (string.IsNullOrEmpty(input.jksId))
                  {
                      throw NCCException.Oh("健康师ID不能为空");
                  }
  
                  var sidx = input.sidx == null ? "hksj" : input.sidx;
                  var sort = string.IsNullOrEmpty(input.sort) ? "DESC" : input.sort;
  
                  // 解析时间范围
                  DateTime? startDate = null;
                  DateTime? endDate = null;
                  if (!string.IsNullOrEmpty(input.startTime))
                  {
                      startDate = Ext.GetDateTime(input.startTime);
                  }
                  if (!string.IsNullOrEmpty(input.endTime))
                  {
                      endDate = Ext.GetDateTime(input.endTime);
                      // 如果只传了日期，则设置为当天的23:59:59
                      if (endDate.HasValue && !input.endTime.Contains(":"))
                      {
                          endDate = new DateTime(endDate.Value.Year, endDate.Value.Month, endDate.Value.Day, 23, 59, 59);
                      }
                  }
  
                  // 通过健康师业绩表关联查询耗卡记录

                  var data = await _db.Queryable<LqXhJksyjEntity, LqXhHyhkEntity>((jksyj, hyhk) => jksyj.Glkdbh == hyhk.Id)

                      .Where((jksyj, hyhk) => jksyj.Jkszh == input.jksId)
                      .WhereIF(input.isEffective != 0, (jksyj, hyhk) => jksyj.IsEffective == input.isEffective && hyhk.IsEffective == input.isEffective)
                      .WhereIF(input.isEffective == 0, (jksyj, hyhk) => jksyj.IsEffective == StatusEnum.有效.GetHashCode() && hyhk.IsEffective == StatusEnum.有效.GetHashCode())
                      .WhereIF(startDate.HasValue, (jksyj, hyhk) => hyhk.Hksj >= startDate.Value)
                      .WhereIF(endDate.HasValue, (jksyj, hyhk) => hyhk.Hksj <= endDate.Value)
                      .WhereIF(!string.IsNullOrEmpty(input.md), (jksyj, hyhk) => hyhk.Md == input.md)
                      .Select((jksyj, hyhk) => new LqXhHyhkListOutput
                      {
                          id = hyhk.Id,
                          md = hyhk.Md,
                          mdbh = hyhk.Mdbh,
                          mdmc = hyhk.Mdmc,
                          hy = hyhk.Hy,
                          hyzh = hyhk.Hyzh,
                          hymc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == hyhk.Hy).Select(w => w.Khmc),
                          gklx = hyhk.Gklx,
                          xfje = SqlFunc.ToString(hyhk.Xfje),
                          sgfy = SqlFunc.ToString(hyhk.Sgfy),
                          sfykjb = hyhk.Sfykjb,
                          hksj = hyhk.Hksj,
                          czry = hyhk.Czry,
                          memberPhone = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == hyhk.Hy).Select(w => w.Sjh),
                          isEffective = hyhk.IsEffective,
                          signatureFile = hyhk.SignatureFile,
                          overtimeCoefficient = hyhk.OvertimeCoefficient,
                          originalSgfy = hyhk.OriginalSgfy,
                          overtimeSgfy = hyhk.OvertimeSgfy,
                      })
                      .MergeTable()
                      .Distinct() // 去重，因为一个耗卡可能对应多个健康师业绩记录
                      .OrderBy($"{sidx} {sort}")
                      .ToPagedListAsync(input.currentPage, input.pageSize);
  

                  // 获取当前页的耗卡记录ID列表
                  var consumeIds = data.list.Select(x => x.id).ToList();

                  // 获取人次记录列表
                  var personTimesRecordList = await _db.Queryable<LqPersonTimesRecordEntity>().Where(x => consumeIds.Contains(x.BusinessId) && x.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select(x => new LqPersonTimesRecordListOutput
                      {
                          id = x.Id,
                          businessId = x.BusinessId,
                          businessType = x.BusinessType,
                          personType = x.PersonType,
                          personId = x.PersonId,
                          personName = x.PersonName,
                          memberId = x.MemberId,
                          memberName = x.MemberName,
                          workDate = x.WorkDate,
                          workMonth = x.WorkMonth,
                          quantity = x.Quantity,
                          createTime = x.CreateTime,
                          isEffective = x.IsEffective,
                      })
                      .ToListAsync();
                  // 按耗卡记录ID分组人次记录
                  var personTimesRecordGrouped = personTimesRecordList.GroupBy(x => x.businessId).ToDictionary(g => g.Key, g => g.ToList());
                  // 为每个耗卡记录分配人次记录
                  foreach (var item in data.list)
                  {
                      item.personTimesRecordList = personTimesRecordGrouped.ContainsKey(item.id) ? personTimesRecordGrouped[item.id] : new List<LqPersonTimesRecordListOutput>();
                  }

                  // 批量查询耗卡明细
                  var consumeDetails = new List<LqXhPxmxInfoOutput>();
                  if (consumeIds.Any())
                  {

                      consumeDetails = await _db.Queryable<LqXhPxmxEntity>().Where(x => consumeIds.Contains(x.ConsumeInfoId) && x.IsEffective == StatusEnum.有效.GetHashCode())

                          .Select(x => new LqXhPxmxInfoOutput
                          {
                              id = x.Id,
                              consumeInfoId = x.ConsumeInfoId,
                              billingItemId = x.BillingItemId,
                              px = x.Px,
                              pxmc = x.Pxmc,
                              pxjg = x.Pxjg,
                              memberId = x.MemberId,
                              createTime = x.CreateTIme,
                              projectNumber = x.ProjectNumber,
                              originalProjectNumber = x.OriginalProjectNumber,
                              overtimeProjectNumber = x.OvertimeProjectNumber,
                              sourceType = x.SourceType,
                              totalPrice = x.TotalPrice,
                              isEffective = x.IsEffective,
                          })
                          .ToListAsync();
                  }

                  // 按耗卡记录ID分组耗卡明细

                  var consumeDetailsGrouped = consumeDetails.GroupBy(x => x.consumeInfoId).ToDictionary(g => g.Key, g => g.ToList());

                  // 为每个耗卡记录分配耗卡明细
                  foreach (var item in data.list)
                  {

                      item.ConsumeDetails = consumeDetailsGrouped.ContainsKey(item.id) ? consumeDetailsGrouped[item.id] : new List<LqXhPxmxInfoOutput>();

                  }

                  return PageResult<LqXhHyhkListOutput>.SqlSugarPageResult(data);
              }
              catch (Exception ex)
              {
                  _logger.LogError(ex, $"根据健康师ID获取耗卡列表失败 - 健康师ID: {input?.jksId}, 开始时间: {input?.startTime}, 结束时间: {input?.endTime}");
                  throw NCCException.Oh($"根据健康师ID获取耗卡列表失败: {ex.Message}");
              }
          }
          #endregion
  
          #region 根据科技部老师ID获取耗卡列表
          /// <summary>
          /// 根据科技部老师ID获取耗卡列表
          /// </summary>
          /// <remarks>
          /// 根据科技部老师ID查询该老师参与的所有耗卡记录，支持时间周期查询和分页
          /// 
          /// 示例请求：
          /// GET /api/Extend/LqXhHyhk/GetListByKjbId?kjblsId=科技部老师ID&amp;startTime=2025-01-01&amp;endTime=2025-01-31&amp;currentPage=1&amp;pageSize=10
          /// 
          /// 参数说明：
          /// - kjblsId: 科技部老师ID（必填）
          /// - startTime: 开始时间（可选，格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
          /// - endTime: 结束时间（可选，格式：yyyy-MM-dd 或 yyyy-MM-dd HH:mm:ss）
          /// - md: 门店ID（可选）
          /// - isEffective: 是否有效（可选，0=全部，1=有效，2=无效，默认1）
          /// - currentPage: 当前页码（必填）
          /// - pageSize: 每页数量（必填）
          /// 
          /// 返回说明：
          /// - 返回格式与GetList接口相同，包含耗卡基本信息及耗卡明细列表
          /// </remarks>
          /// <param name="input">查询参数</param>
          /// <returns>耗卡列表（分页）</returns>
          /// <response code="200">查询成功</response>
          /// <response code="400">参数错误</response>
          /// <response code="500">服务器内部错误</response>
          [HttpGet("GetListByKjbId")]
          public async Task<dynamic> GetListByKjbId([FromQuery] LqXhHyhkListByKjbQueryInput input)
          {
              try
              {
                  if (string.IsNullOrEmpty(input.kjblsId))
                  {
                      throw NCCException.Oh("科技部老师ID不能为空");
                  }
  
                  var sidx = input.sidx == null ? "hksj" : input.sidx;
                  var sort = string.IsNullOrEmpty(input.sort) ? "DESC" : input.sort;
  
                  // 解析时间范围
                  DateTime? startDate = null;
                  DateTime? endDate = null;
                  if (!string.IsNullOrEmpty(input.startTime))
                  {
                      startDate = Ext.GetDateTime(input.startTime);
                  }
                  if (!string.IsNullOrEmpty(input.endTime))
                  {
                      endDate = Ext.GetDateTime(input.endTime);
                      // 如果只传了日期，则设置为当天的23:59:59
                      if (endDate.HasValue && !input.endTime.Contains(":"))
                      {
                          endDate = new DateTime(endDate.Value.Year, endDate.Value.Month, endDate.Value.Day, 23, 59, 59);
                      }
                  }
  
                  // 通过科技部老师业绩表关联查询耗卡记录
                  var data = await _db.Queryable<LqXhKjbsyjEntity, LqXhHyhkEntity>(
                          (kjbsyj, hyhk) => kjbsyj.Glkdbh == hyhk.Id)
                      .Where((kjbsyj, hyhk) => kjbsyj.Kjblszh == input.kjblsId)
                      .WhereIF(input.isEffective != 0, (kjbsyj, hyhk) => kjbsyj.IsEffective == input.isEffective && hyhk.IsEffective == input.isEffective)
                      .WhereIF(input.isEffective == 0, (kjbsyj, hyhk) => kjbsyj.IsEffective == StatusEnum.有效.GetHashCode() && hyhk.IsEffective == StatusEnum.有效.GetHashCode())
                      .WhereIF(startDate.HasValue, (kjbsyj, hyhk) => hyhk.Hksj >= startDate.Value)
                      .WhereIF(endDate.HasValue, (kjbsyj, hyhk) => hyhk.Hksj <= endDate.Value)
                      .WhereIF(!string.IsNullOrEmpty(input.md), (kjbsyj, hyhk) => hyhk.Md == input.md)
                      .Select((kjbsyj, hyhk) => new LqXhHyhkListOutput
                      {
                          id = hyhk.Id,
                          md = hyhk.Md,
                          mdbh = hyhk.Mdbh,
                          mdmc = hyhk.Mdmc,
                          hy = hyhk.Hy,
                          hyzh = hyhk.Hyzh,
                          hymc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == hyhk.Hy).Select(w => w.Khmc),
                          gklx = hyhk.Gklx,
                          xfje = SqlFunc.ToString(hyhk.Xfje),
                          sgfy = SqlFunc.ToString(hyhk.Sgfy),
                          sfykjb = hyhk.Sfykjb,
                          hksj = hyhk.Hksj,
                          czry = hyhk.Czry,
                          memberPhone = SqlFunc.Subqueryable<LqKhxxEntity>().Where(w => w.Id == hyhk.Hy).Select(w => w.Sjh),
                          isEffective = hyhk.IsEffective,
                          signatureFile = hyhk.SignatureFile,
                          overtimeCoefficient = hyhk.OvertimeCoefficient,
                          originalSgfy = hyhk.OriginalSgfy,
                          overtimeSgfy = hyhk.OvertimeSgfy,
                      })
                      .MergeTable()
                      .Distinct() // 去重，因为一个耗卡可能对应多个科技部老师业绩记录
                      .OrderBy($"{sidx} {sort}")

                  .ToPagedListAsync(input.currentPage, input.pageSize);

                  // 获取当前页的耗卡记录ID列表
                  var consumeIds = data.list.Select(x => x.id).ToList();

                  // 批量查询耗卡明细
                  var consumeDetails = new List<LqXhPxmxInfoOutput>();
                  if (consumeIds.Any())
                  {
                      consumeDetails = await _db.Queryable<LqXhPxmxEntity>()
                          .Where(x => consumeIds.Contains(x.ConsumeInfoId) && x.IsEffective == StatusEnum.有效.GetHashCode())
                          .Select(x => new LqXhPxmxInfoOutput
                          {
                              id = x.Id,
                              consumeInfoId = x.ConsumeInfoId,
                              billingItemId = x.BillingItemId,
                              px = x.Px,
                              pxmc = x.Pxmc,
                              pxjg = x.Pxjg,
                              memberId = x.MemberId,
                              createTime = x.CreateTIme,
                              projectNumber = x.ProjectNumber,
                              originalProjectNumber = x.OriginalProjectNumber,
                              overtimeProjectNumber = x.OvertimeProjectNumber,
                              sourceType = x.SourceType,
                              totalPrice = x.TotalPrice,
                              isEffective = x.IsEffective,
                          })
                          .ToListAsync();
                  }

                  // 按耗卡记录ID分组耗卡明细
                  var consumeDetailsGrouped = consumeDetails.GroupBy(x => x.consumeInfoId)
                      .ToDictionary(g => g.Key, g => g.ToList());

                  // 为每个耗卡记录分配耗卡明细
                  foreach (var item in data.list)
                  {
                      item.ConsumeDetails = consumeDetailsGrouped.ContainsKey(item.id)
                          ? consumeDetailsGrouped[item.id]
                          : new List<LqXhPxmxInfoOutput>();
                  }