antissoft / lvqianmeiye_ERP

  using System;

  using System.Collections.Generic;
  using System.Linq;
  using System.Net.Http;
  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.Common;

  using NCC.Extend.Entitys.Dto.LqKdDeductinfo;

  using NCC.Extend.Entitys.Dto.LqKdKdjlb;

  using NCC.Extend.Entitys.Enum;

  using NCC.Extend.Entitys.lq_hytk_hytk;

  using NCC.Extend.Entitys.lq_hytk_mx;

  using NCC.Extend.Entitys.lq_hytk_jksyj;
  using NCC.Extend.Entitys.lq_hytk_kjbsyj;

  using NCC.Extend.Entitys.lq_jinsanjiao_user;

  using NCC.Extend.Entitys.lq_kd_deductinfo;

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

  using NCC.Extend.Entitys.lq_kd_jksyj;

  using NCC.Extend.Entitys.lq_kd_kdjlb;

  using NCC.Extend.Entitys.lq_kd_kjbsyj;
  using NCC.Extend.Entitys.lq_kd_pxmx;

  using NCC.Extend.Entitys.lq_khxx;

  using NCC.Extend.Entitys.lq_xmzl;
  using NCC.Extend.Interfaces.LqKdKdjlb;

  using NCC.Extend.Utils;

  using NCC.FriendlyException;
  using NCC.JsonSerialization;

  using NCC.System.Entitys.Permission;

  using SqlSugar;
  using Yitter.IdGenerator;

  using NCC.Extend.Entitys.lq_package_info;

  using NCC.Extend.Entitys.lq_mdxx;

  using NCC.Extend.Entitys.lq_card_transfer_log;

  using NCC.Extend.Entitys.Dto.LqDailyReport;

  using NCC.Extend.Entitys.lq_yyjl;

  using NCC.Extend.Entitys.lq_hzf;

  
  namespace NCC.Extend.LqKdKdjlb
  {
      /// <summary>
      /// 开单记录表服务
      /// </summary>

      [ApiDescriptionSettings(Tag = "绿纤开单记录表服务", Name = "LqKdKdjlb", Order = 200)]

      [Route("api/Extend/[controller]")]
      public class LqKdKdjlbService : ILqKdKdjlbService, IDynamicApiController, ITransient
      {
          private readonly ISqlSugarRepository<LqKdKdjlbEntity> _lqKdKdjlbRepository;
          private readonly ISqlSugarRepository<LqKdJksyjEntity> _lqKdJksyjRepository;
          private readonly ISqlSugarRepository<LqKdKjbsyjEntity> _lqKdKjbsyjRepository;
          private readonly ISqlSugarRepository<LqKdPxmxEntity> _lqKdPxmxRepository;
          private readonly SqlSugarScope _db;
          private readonly IUserManager _userManager;

          private readonly WeChatBotService _weChatBotService;
          private readonly LqKdKdjlbStringGenerator _stringGenerator;

          private readonly ILogger<LqKdKdjlbService> _logger;

          private readonly LqDailyReportService _dailyReportService;

  
          /// <summary>
          /// 初始化一个<see cref="LqKdKdjlbService"/>类型的新实例
          /// </summary>
          public LqKdKdjlbService(
              ISqlSugarRepository<LqKdKdjlbEntity> lqKdKdjlbRepository,
              ISqlSugarRepository<LqKdJksyjEntity> lqKdJksyjRepository,
              ISqlSugarRepository<LqKdKjbsyjEntity> lqKdKjbsyjRepository,
              ISqlSugarRepository<LqKdPxmxEntity> lqKdPxmxRepository,

              IUserManager userManager,
              WeChatBotService weChatBotService,

              LqKdKdjlbStringGenerator stringGenerator,

              ILogger<LqKdKdjlbService> logger,
              LqDailyReportService dailyReportService

          )

          {

              _lqKdKdjlbRepository = lqKdKdjlbRepository;

              _db = _lqKdKdjlbRepository.Context;
              _lqKdJksyjRepository = lqKdJksyjRepository;
              _lqKdKjbsyjRepository = lqKdKjbsyjRepository;
              _lqKdPxmxRepository = lqKdPxmxRepository;
              _userManager = userManager;

              _weChatBotService = weChatBotService;
              _stringGenerator = stringGenerator;

              _logger = logger;

              _dailyReportService = dailyReportService;

          }

          #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<LqKdKdjlbEntity>().FirstAsync(p => p.Id == id);
                  if (entity == null)
                  {
                      throw NCCException.Oh(ErrorCode.COM1005, "开单记录不存在");
                  }

                  var output = entity.Adapt<LqKdKdjlbInfoOutput>();

                  output.upgradeLifeBeauty = entity.UpgradeLifeBeauty;
                  output.upgradeTechBeauty = entity.UpgradeTechBeauty;
                  output.upgradeMedicalBeauty = entity.UpgradeMedicalBeauty;

                  output.fileUrl = entity.F_FIleUrl;

                  if (!string.IsNullOrEmpty(entity.AppointmentId))
                  {
                      output.appointmentTime = await _db.Queryable<LqYyjlEntity>().Where(x => x.Id == entity.AppointmentId).Select(x => x.Yysj).FirstAsync();
                  }

                  if (output.activityId != null)
                  {
                      output.activityName = await _db.Queryable<LqPackageInfoEntity>().Where(x => x.Id == entity.ActivityId).Select(x => x.ActivityName).FirstAsync();
                  }

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

                  if (!string.IsNullOrEmpty(entity.ActivityId))
                  {
                      output.activityName = await _db.Queryable<LqPackageInfoEntity>().Where(x => x.Id == entity.ActivityId).Select(x => x.ActivityName).FirstAsync();
                  }

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

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

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

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

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

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

                  // 5. 查询扣款信息列表
                  var lqKdDeductList = await _db.Queryable<LqKdDeductinfoEntity>().Where(w => w.BillingId == entity.Id).ToListAsync();
  

                  // 5. 构建品项明细输出，每个品项关联对应的业绩信息
                  var pxmxOutputList = new List<LqKdPxmxInfoOutput>();
                  foreach (var pxmx in lqKdPxmxList)
                  {
                      var pxmxOutput = new LqKdPxmxInfoOutput
                      {
                          id = pxmx.Id,
                          glkdbh = pxmx.Glkdbh,
                          px = pxmx.Px,
                          pxmc = pxmx.Pxmc,
                          pxjg = pxmx.Pxjg,
                          projectNumber = pxmx.ProjectNumber,
                          isEnabled = pxmx.IsEnabled,
                          sourceType = pxmx.SourceType,
                          memberId = pxmx.MemberId,
                          createTime = pxmx.CreateTIme,

                          totalPrice = pxmx.TotalPrice,

                          actualPrice = pxmx.ActualPrice,

                          remark = pxmx.Remark,

                          isEffective = pxmx.IsEffective,

                      };
  
                      // 关联该品项的健康师业绩
                      var jksyjForPx = lqKdJksyjList.Where(j => j.Kdpxid == pxmx.Id).ToList();
                      pxmxOutput.lqKdJksyjList = jksyjForPx.Adapt<List<LqKdJksyjInfoOutput>>();
  
                      // 关联该品项的科技部老师业绩
                      var kjbsyjForPx = lqKdKjbsyjList.Where(k => k.Kdpxid == pxmx.Id).ToList();
                      pxmxOutput.lqKdKjbsyjList = kjbsyjForPx.Adapt<List<LqKdKjbsyjInfoOutput>>();
  

                      pxmxOutputList.Add(pxmxOutput);
                  }
  
                  // 6. 设置输出结果
                  output.lqKdPxmxList = pxmxOutputList;
  
                  // 7. 设置全局业绩列表（用于兼容性，但主要使用品项关联的业绩）
                  output.lqKdJksyjList = lqKdJksyjList.Adapt<List<LqKdJksyjInfoOutput>>();
                  output.lqKdKjbsyjList = lqKdKjbsyjList.Adapt<List<LqKdKjbsyjInfoOutput>>();

                  // 8. 设置扣款信息列表
                  output.lqKdDeductList = lqKdDeductList.Adapt<List<LqKdDeductinfoInfoOutput>>();

  
                  return output;
              }
              catch (Exception ex)
              {
                  Console.WriteLine($"获取开单记录失败: {ex.Message}");
                  throw NCCException.Oh(ErrorCode.COM1000, "获取开单记录失败");
              }

          }

          #endregion

          #region 获取开单记录表列表

          /// <summary>

          /// 获取开单记录表列表
          /// </summary>
          /// <param name="input">请求参数</param>
          /// <returns></returns>

          [HttpGet("")]
          public async Task<dynamic> GetList([FromQuery] LqKdKdjlbListQueryInput input)
          {

              var sidx = input.sidx == null ? "kdrq" : input.sidx;

              List<string> queryKdrq = input.kdrq != null ? input.kdrq.Split(',').ToObeject<List<string>>() : null;

              DateTime? startKdrq = queryKdrq != null ? Ext.GetDateTime(queryKdrq.First()) : null;
              DateTime? endKdrq = queryKdrq != null ? Ext.GetDateTime(queryKdrq.Last()) : null;

  
              // 根据是否传入健康师ID或科技部老师ID，动态构建查询
              ISugarQueryable<LqKdKdjlbEntity> baseQuery = null;
  
              if (!string.IsNullOrEmpty(input.jksId) && !string.IsNullOrEmpty(input.kjblsId))
              {
                  // 同时传入健康师ID和科技部老师ID，需要同时关联两个业绩表
                  baseQuery = _db.Queryable<LqKdJksyjEntity, LqKdKjbsyjEntity, LqKdKdjlbEntity>(
                          (jksyj, kjbsyj, kdjlb) => jksyj.Glkdbh == kdjlb.Id && kjbsyj.Glkdbh == kdjlb.Id)
                      .Where((jksyj, kjbsyj, kdjlb) => jksyj.Jkszh == input.jksId && jksyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Where((jksyj, kjbsyj, kdjlb) => kjbsyj.Kjbls == input.kjblsId && kjbsyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((jksyj, kjbsyj, kdjlb) => kdjlb)
                      .Distinct()
                      .MergeTable();
              }
              else if (!string.IsNullOrEmpty(input.jksId))
              {
                  // 只传入健康师ID，关联健康师业绩表
                  baseQuery = _db.Queryable<LqKdJksyjEntity, LqKdKdjlbEntity>(
                          (jksyj, kdjlb) => jksyj.Glkdbh == kdjlb.Id)
                      .Where((jksyj, kdjlb) => jksyj.Jkszh == input.jksId && jksyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((jksyj, kdjlb) => kdjlb)
                      .Distinct()
                      .MergeTable();
              }
              else if (!string.IsNullOrEmpty(input.kjblsId))
              {
                  // 只传入科技部老师ID，关联科技部老师业绩表
                  baseQuery = _db.Queryable<LqKdKjbsyjEntity, LqKdKdjlbEntity>(
                          (kjbsyj, kdjlb) => kjbsyj.Glkdbh == kdjlb.Id)
                      .Where((kjbsyj, kdjlb) => kjbsyj.Kjbls == input.kjblsId && kjbsyj.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select((kjbsyj, kdjlb) => kdjlb)
                      .Distinct()
                      .MergeTable();
              }
              else
              {
                  // 没有传入健康师ID或科技部老师ID，使用原来的查询逻辑
                  baseQuery = _db.Queryable<LqKdKdjlbEntity>();
              }
  
              var data = await baseQuery
                  .WhereIF(!string.IsNullOrEmpty(input.keyword), p => p.Kdhyc.Contains(input.keyword) || p.Kdhysjh.Contains(input.keyword))

                  .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                  .WhereIF(!string.IsNullOrEmpty(input.djmd), p => p.Djmd.Equals(input.djmd))
                  .WhereIF(!string.IsNullOrEmpty(input.jsj), p => p.Jsj.Equals(input.jsj))

                  .WhereIF(queryKdrq != null, p => p.Kdrq >= new DateTime(startKdrq.ToDate().Year, startKdrq.ToDate().Month, startKdrq.ToDate().Day, 0, 0, 0))
                  .WhereIF(queryKdrq != null, p => p.Kdrq <= new DateTime(endKdrq.ToDate().Year, endKdrq.ToDate().Month, endKdrq.ToDate().Day, 23, 59, 59))

                  .WhereIF(!string.IsNullOrEmpty(input.gjlx), p => p.Gjlx.Equals(input.gjlx))
                  .WhereIF(!string.IsNullOrEmpty(input.hgjg), p => p.Hgjg.Equals(input.hgjg))

                  .WhereIF(input.zdyj != null, p => p.Zdyj > input.zdyj)
                  .WhereIF(input.sfyj != null, p => p.Sfyj > input.sfyj)
                  .WhereIF(input.qk != null, p => p.Qk > input.qk)

                  .WhereIF(!string.IsNullOrEmpty(input.ckfs), p => p.Ckfs.Equals(input.ckfs))

                  .WhereIF(!string.IsNullOrEmpty(input.fkfs), p => p.Fkfs.Equals(input.fkfs))
                  .WhereIF(!string.IsNullOrEmpty(input.fkyy), p => p.Fkyy.Equals(input.fkyy))
                  .WhereIF(!string.IsNullOrEmpty(input.fkpd), p => p.Fkpd.Contains(input.fkpd))
                  .WhereIF(!string.IsNullOrEmpty(input.khly), p => p.Khly.Equals(input.khly))
                  .WhereIF(!string.IsNullOrEmpty(input.tjr), p => p.Tjr.Contains(input.tjr))
                  .WhereIF(!string.IsNullOrEmpty(input.sfskdd), p => p.Sfskdd.Equals(input.sfskdd))
                  .WhereIF(!string.IsNullOrEmpty(input.jj), p => p.Jj.Contains(input.jj))
                  .WhereIF(!string.IsNullOrEmpty(input.bz), p => p.Bz.Contains(input.bz))
                  .WhereIF(!string.IsNullOrEmpty(input.kdhy), p => p.Kdhy.Equals(input.kdhy))
                  .WhereIF(!string.IsNullOrEmpty(input.kdhyc), p => p.Kdhyc.Contains(input.kdhyc))

                  .WhereIF(!string.IsNullOrEmpty(input.kdhysjh), p => p.Kdhysjh.Contains(input.kdhysjh))

                  .WhereIF(!string.IsNullOrEmpty(input.F_FIleUrl), p => p.F_FIleUrl.Contains(input.F_FIleUrl))

                  .WhereIF(!string.IsNullOrEmpty(input.CreateUser), p => p.CreateUser.Equals(input.CreateUser))

                  .WhereIF(input.isEffective != 0, p => p.IsEffective == input.isEffective)

                  .Select(it => new LqKdKdjlbListOutput

                  {
                      id = it.Id,

                      djmd = it.Djmd,
                      jsj = it.Jsj,
                      kdrq = it.Kdrq,
                      gjlx = it.Gjlx,
                      hgjg = it.Hgjg,
                      zdyj = it.Zdyj,
                      sfyj = it.Sfyj,
                      qk = it.Qk,
                      ckfs = it.Ckfs,

                      fkfs = it.Fkfs,
                      fkyy = it.Fkyy,
                      fkpd = it.Fkpd,
                      khly = it.Khly,
                      tjr = it.Tjr,

                      deductAmount = it.DeductAmount,

                      paidDebt = it.PaidDebt,
                      supplementBillingId = it.SupplementBillingId,

                      sfskdd = it.Sfskdd,
                      jj = it.Jj,
                      bz = it.Bz,
                      kdhy = it.Kdhy,

                      kdhyc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == it.Kdhy).Select(x => x.Khmc),
                      kdhysjh = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == it.Kdhy).Select(x => x.Sjh),

                      isEffective = it.IsEffective,
                      createUser = it.CreateUser,
                      createUserName = SqlFunc.Subqueryable<UserEntity>().Where(x => x.Id == it.CreateUser).Select(x => x.RealName),

                      activityId = it.ActivityId,
                      activityName = SqlFunc.Subqueryable<LqPackageInfoEntity>().Where(x => x.Id == it.ActivityId).Select(x => x.ActivityName),

                      appointmentId = it.AppointmentId,
                      appointmentTime = it.AppointmentId == null ? (DateTime?)null : SqlFunc.Subqueryable<LqYyjlEntity>().Where(x => x.Id == it.AppointmentId).Select(x => SqlFunc.ToDate(x.Yysj)),

                      upgradeMedicalBeauty = it.UpgradeMedicalBeauty,
                      upgradeTechBeauty = it.UpgradeTechBeauty,
                      upgradeLifeBeauty = it.UpgradeLifeBeauty,

                  })
                  .MergeTable()
                  .OrderBy(sidx + " " + input.sort)
                  .ToPagedListAsync(input.currentPage, input.pageSize);

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

              // 批量查询品项明细
              var itemDetails = new List<LqKdPxmxInfoOutput>();
              if (billingIds.Any())
              {

                  itemDetails = await _db.Queryable<LqKdPxmxEntity>().Where(x => billingIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode())

                      .Select(x => new LqKdPxmxInfoOutput
                      {
                          id = x.Id,
                          glkdbh = x.Glkdbh,
                          px = x.Px,
                          pxmc = x.Pxmc,
                          pxjg = x.Pxjg,
                          projectNumber = x.ProjectNumber,
                          isEnabled = x.IsEnabled,
                          sourceType = x.SourceType,
                          memberId = x.MemberId,
                          createTime = x.CreateTIme,
                          totalPrice = x.TotalPrice,
                          actualPrice = x.ActualPrice,
                          remark = x.Remark,
                          isEffective = x.IsEffective
                      })
                      .ToListAsync();
              }
  
              // 按开单ID分组品项明细
              var itemDetailsGrouped = itemDetails.GroupBy(x => x.glkdbh)
                  .ToDictionary(g => g.Key, g => g.ToList());
  

              // 批量查询健康师业绩（性能优化：一次性查询所有开单的健康师业绩）
              var jksyjList = new List<LqKdJksyjInfoOutput>();
              if (billingIds.Any())
              {

                  jksyjList = await _db.Queryable<LqKdJksyjEntity>().Where(x => billingIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode()).Select(x => new LqKdJksyjInfoOutput
                  {
                      id = x.Id,
                      glkdbh = x.Glkdbh,
                      kdpxid = x.Kdpxid,
                      jks = x.Jks,
                      jksxm = x.Jksxm,
                      jkszh = x.Jkszh,
                      jksyj = x.Jksyj,
                      yjsj = x.Yjsj,
                      jsj_id = x.Jsj_id,
                      isEffective = x.IsEffective
                  }).ToListAsync();

              }
  
              // 批量查询科技部老师业绩（性能优化：一次性查询所有开单的科技部老师业绩）
              var kjbsyjList = new List<LqKdKjbsyjInfoOutput>();
              if (billingIds.Any())
              {

                  kjbsyjList = await _db.Queryable<LqKdKjbsyjEntity>().Where(x => billingIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode()).Select(x => new LqKdKjbsyjInfoOutput
                  {
                      id = x.Id,
                      glkdbh = x.Glkdbh,
                      kdpxid = x.Kdpxid,
                      kjbls = x.Kjbls,
                      kjblsxm = x.Kjblsxm,
                      kjblszh = x.Kjblszh,
                      kjblsyj = x.Kjblsyj,
                      yjsj = x.Yjsj,
                      isEffective = x.IsEffective
                  })
                      .ToListAsync();
              }
  
              // 批量查询储扣扣款信息（性能优化：一次性查询所有开单的储扣扣款信息）
              var deductinfoList = new List<LqKdDeductinfoInfoOutput>();
              if (billingIds.Any())
              {
                  deductinfoList = await _db.Queryable<LqKdDeductinfoEntity>().Where(x => billingIds.Contains(x.BillingId) && x.IsEffective == StatusEnum.有效.GetHashCode())
                      .Select(x => new LqKdDeductinfoInfoOutput

                      {
                          id = x.Id,

                          deductType = x.DeductType,
                          deductId = x.DeductId,
                          billingId = x.BillingId,
                          amount = x.Amount,
                          isEffective = x.IsEffective,
                          unitPrice = x.UnitPrice,
                          itemName = x.ItemName,
                          itemId = x.ItemId,
                          createTime = x.CreateTime,
                          projectNumber = x.ProjectNumber,
  

                      })
                      .ToListAsync();
              }
  

              // 按开单ID分组储扣扣款信息
              var deductinfoGrouped = deductinfoList.GroupBy(x => x.billingId).ToDictionary(g => g.Key, g => g.ToList());

              // 按开单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.ItemDetails = itemDetailsGrouped.ContainsKey(item.id) ? itemDetailsGrouped[item.id] : new List<LqKdPxmxInfoOutput>();
                  item.lqKdJksyjList = jksyjGrouped.ContainsKey(item.id) ? jksyjGrouped[item.id] : new List<LqKdJksyjInfoOutput>();
                  item.lqKdKjbsyjList = kjbsyjGrouped.ContainsKey(item.id) ? kjbsyjGrouped[item.id] : new List<LqKdKjbsyjInfoOutput>();
                  item.lqKdDeductList = deductinfoGrouped.ContainsKey(item.id) ? deductinfoGrouped[item.id] : new List<LqKdDeductinfoInfoOutput>();

              }
  

              return PageResult<LqKdKdjlbListOutput>.SqlSugarPageResult(data);

          }

          #endregion

          #region 根据健康师ID获取开单列表
          /// <summary>
          /// 根据健康师ID获取开单列表
          /// </summary>
          /// <remarks>
          /// 根据健康师ID查询该健康师参与的所有开单记录，支持时间周期查询和分页
          /// 
          /// 示例请求：
          /// GET /api/Extend/LqKdKdjlb/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）
          /// - djmd: 门店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] LqKdKdjlbListByJksQueryInput input)
          {
              try
              {
                  if (string.IsNullOrEmpty(input.jksId))
                  {
                      throw NCCException.Oh("健康师ID不能为空");
                  }

                  var sidx = input.sidx == null ? "kdrq" : 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<LqKdJksyjEntity, LqKdKdjlbEntity>((jksyj, kdjlb) => jksyj.Glkdbh == kdjlb.Id)

                      .Where((jksyj, kdjlb) => jksyj.Jkszh == input.jksId)
                      .WhereIF(input.isEffective != 0, (jksyj, kdjlb) => jksyj.IsEffective == input.isEffective && kdjlb.IsEffective == input.isEffective)
                      .WhereIF(input.isEffective == 0, (jksyj, kdjlb) => jksyj.IsEffective == StatusEnum.有效.GetHashCode() && kdjlb.IsEffective == StatusEnum.有效.GetHashCode())
                      .WhereIF(startDate.HasValue, (jksyj, kdjlb) => kdjlb.Kdrq >= startDate.Value)
                      .WhereIF(endDate.HasValue, (jksyj, kdjlb) => kdjlb.Kdrq <= endDate.Value)
                      .WhereIF(!string.IsNullOrEmpty(input.djmd), (jksyj, kdjlb) => kdjlb.Djmd == input.djmd)
                      .Select((jksyj, kdjlb) => new LqKdKdjlbListOutput
                      {
                          id = kdjlb.Id,
                          djmd = kdjlb.Djmd,
                          jsj = kdjlb.Jsj,
                          kdrq = kdjlb.Kdrq,
                          gjlx = kdjlb.Gjlx,
                          hgjg = kdjlb.Hgjg,
                          zdyj = kdjlb.Zdyj,
                          sfyj = kdjlb.Sfyj,
                          qk = kdjlb.Qk,
                          ckfs = kdjlb.Ckfs,
                          fkfs = kdjlb.Fkfs,
                          fkyy = kdjlb.Fkyy,
                          fkpd = kdjlb.Fkpd,
                          khly = kdjlb.Khly,
                          tjr = kdjlb.Tjr,
                          deductAmount = kdjlb.DeductAmount,
                          paidDebt = kdjlb.PaidDebt,
                          supplementBillingId = kdjlb.SupplementBillingId,
                          sfskdd = kdjlb.Sfskdd,
                          jj = kdjlb.Jj,
                          bz = kdjlb.Bz,
                          kdhy = kdjlb.Kdhy,
                          kdhyc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == kdjlb.Kdhy).Select(x => x.Khmc),
                          kdhysjh = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == kdjlb.Kdhy).Select(x => x.Sjh),
                          isEffective = kdjlb.IsEffective,
                          createUser = kdjlb.CreateUser,
                          createUserName = SqlFunc.Subqueryable<UserEntity>().Where(x => x.Id == kdjlb.CreateUser).Select(x => x.RealName),
                          activityId = kdjlb.ActivityId,
                          activityName = SqlFunc.Subqueryable<LqPackageInfoEntity>().Where(x => x.Id == kdjlb.ActivityId).Select(x => x.ActivityName),

                          appointmentId = kdjlb.AppointmentId,
                          appointmentTime = kdjlb.AppointmentId == null ? (DateTime?)null : SqlFunc.Subqueryable<LqYyjlEntity>().Where(x => x.Id == kdjlb.AppointmentId).Select(x => SqlFunc.ToDate(x.Yysj)),

                      })
                      .MergeTable()
                      .Distinct() // 去重，因为一个开单可能对应多个健康师业绩记录
                      .OrderBy($"{sidx} {sort}")
                      .ToPagedListAsync(input.currentPage, input.pageSize);
  
                  // 获取当前页的开单记录ID列表
                  var billingIds = data.list.Select(x => x.id).ToList();
  
                  // 批量查询品项明细
                  var itemDetails = new List<LqKdPxmxInfoOutput>();
                  if (billingIds.Any())
                  {
                      itemDetails = await _db.Queryable<LqKdPxmxEntity>()
                          .Where(x => billingIds.Contains(x.Glkdbh) && x.IsEffective == StatusEnum.有效.GetHashCode())
                          .Select(x => new LqKdPxmxInfoOutput
                          {
                              id = x.Id,
                              glkdbh = x.Glkdbh,
                              px = x.Px,
                              pxmc = x.Pxmc,
                              pxjg = x.Pxjg,
                              projectNumber = x.ProjectNumber,
                              isEnabled = x.IsEnabled,
                              sourceType = x.SourceType,
                              memberId = x.MemberId,
                              createTime = x.CreateTIme,
                              totalPrice = x.TotalPrice,
                              actualPrice = x.ActualPrice,
                              remark = x.Remark,
                              isEffective = x.IsEffective
                          })
                          .ToListAsync();
                  }
  
                  // 按开单ID分组品项明细
                  var itemDetailsGrouped = itemDetails.GroupBy(x => x.glkdbh)
                      .ToDictionary(g => g.Key, g => g.ToList());
  
                  // 为每个开单记录分配品项明细
                  foreach (var item in data.list)
                  {
                      item.ItemDetails = itemDetailsGrouped.ContainsKey(item.id)
                          ? itemDetailsGrouped[item.id]
                          : new List<LqKdPxmxInfoOutput>();
                  }
  
                  return PageResult<LqKdKdjlbListOutput>.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/LqKdKdjlb/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）
          /// - djmd: 门店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] LqKdKdjlbListByKjbQueryInput input)
          {
              try
              {
                  if (string.IsNullOrEmpty(input.kjblsId))
                  {
                      throw NCCException.Oh("科技部老师ID不能为空");
                  }
  
                  var sidx = input.sidx == null ? "kdrq" : 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<LqKdKjbsyjEntity, LqKdKdjlbEntity>(
                          (kjbsyj, kdjlb) => kjbsyj.Glkdbh == kdjlb.Id)
                      .Where((kjbsyj, kdjlb) => kjbsyj.Kjbls == input.kjblsId)
                      .WhereIF(input.isEffective != 0, (kjbsyj, kdjlb) => kjbsyj.IsEffective == input.isEffective && kdjlb.IsEffective == input.isEffective)
                      .WhereIF(input.isEffective == 0, (kjbsyj, kdjlb) => kjbsyj.IsEffective == StatusEnum.有效.GetHashCode() && kdjlb.IsEffective == StatusEnum.有效.GetHashCode())
                      .WhereIF(startDate.HasValue, (kjbsyj, kdjlb) => kdjlb.Kdrq >= startDate.Value)
                      .WhereIF(endDate.HasValue, (kjbsyj, kdjlb) => kdjlb.Kdrq <= endDate.Value)
                      .WhereIF(!string.IsNullOrEmpty(input.djmd), (kjbsyj, kdjlb) => kdjlb.Djmd == input.djmd)
                      .Select((kjbsyj, kdjlb) => new LqKdKdjlbListOutput
                      {
                          id = kdjlb.Id,
                          djmd = kdjlb.Djmd,
                          jsj = kdjlb.Jsj,
                          kdrq = kdjlb.Kdrq,
                          gjlx = kdjlb.Gjlx,
                          hgjg = kdjlb.Hgjg,
                          zdyj = kdjlb.Zdyj,
                          sfyj = kdjlb.Sfyj,
                          qk = kdjlb.Qk,
                          ckfs = kdjlb.Ckfs,
                          fkfs = kdjlb.Fkfs,
                          fkyy = kdjlb.Fkyy,
                          fkpd = kdjlb.Fkpd,
                          khly = kdjlb.Khly,
                          tjr = kdjlb.Tjr,
                          deductAmount = kdjlb.DeductAmount,
                          paidDebt = kdjlb.PaidDebt,
                          supplementBillingId = kdjlb.SupplementBillingId,
                          sfskdd = kdjlb.Sfskdd,
                          jj = kdjlb.Jj,
                          bz = kdjlb.Bz,
                          kdhy = kdjlb.Kdhy,
                          kdhyc = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == kdjlb.Kdhy).Select(x => x.Khmc),
                          kdhysjh = SqlFunc.Subqueryable<LqKhxxEntity>().Where(x => x.Id == kdjlb.Kdhy).Select(x => x.Sjh),
                          isEffective = kdjlb.IsEffective,
                          createUser = kdjlb.CreateUser,
                          createUserName = SqlFunc.Subqueryable<UserEntity>().Where(x => x.Id == kdjlb.CreateUser).Select(x => x.RealName),
                          activityId = kdjlb.ActivityId,
                          activityName = SqlFunc.Subqueryable<LqPackageInfoEntity>().Where(x => x.Id == kdjlb.ActivityId).Select(x => x.ActivityName),