antissoft / lvqianmeiye_ERP

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  using Mapster;
  using Microsoft.AspNetCore.Mvc;
  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.LqHytkHytk;

  using NCC.Extend.Entitys.Dto.LqHytkJksyj;
  using NCC.Extend.Entitys.Dto.LqHytkKjbsyj;

  using NCC.Extend.Entitys.Dto.LqHytkMx;

  using NCC.Extend.Entitys.Enum;

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

  using NCC.Extend.Entitys.lq_kd_pxmx;

  using NCC.Extend.Entitys.lq_xmzl;

  using NCC.Extend.Interfaces.LqHytkHytk;
  using NCC.FriendlyException;

  using NCC.JsonSerialization;

  using SqlSugar;
  using Yitter.IdGenerator;

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

      /// 退卡_信息表服务

      /// </summary>

      [ApiDescriptionSettings(Tag = "绿纤退卡信息表服务", Name = "LqHytkHytk", Order = 200)]

      [Route("api/Extend/[controller]")]
      public class LqHytkHytkService : ILqHytkHytkService, IDynamicApiController, ITransient
      {
          private readonly ISqlSugarRepository<LqHytkHytkEntity> _lqHytkHytkRepository;
          private readonly ISqlSugarRepository<LqHytkMxEntity> _lqHytkMxRepository;

          private readonly ISqlSugarRepository<LqHytkJksyjEntity> _lqHytkJksyjRepository;
          private readonly ISqlSugarRepository<LqHytkKjbsyjEntity> _lqHytkKjbsyjRepository;

          private readonly SqlSugarScope _db;
          private readonly IUserManager _userManager;
  
          /// <summary>
          /// 初始化一个<see cref="LqHytkHytkService"/>类型的新实例
          /// </summary>
          public LqHytkHytkService(
              ISqlSugarRepository<LqHytkHytkEntity> lqHytkHytkRepository,
              ISqlSugarRepository<LqHytkMxEntity> lqHytkMxRepository,

              ISqlSugarRepository<LqHytkJksyjEntity> lqHytkJksyjRepository,
              ISqlSugarRepository<LqHytkKjbsyjEntity> lqHytkKjbsyjRepository,

              IUserManager userManager
          )

          {

              _lqHytkHytkRepository = lqHytkHytkRepository;

              _lqHytkMxRepository = lqHytkMxRepository;

              _lqHytkJksyjRepository = lqHytkJksyjRepository;
              _lqHytkKjbsyjRepository = lqHytkKjbsyjRepository;
              _db = _lqHytkHytkRepository.Context;

              _userManager = userManager;
          }
  

          #region 获取退卡信息列表

          /// <summary>

          /// 获取退卡信息列表

          /// </summary>

          /// <remarks>
          /// 获取退卡记录列表，支持根据健康师ID或科技部老师ID筛选，返回品项明细、健康师业绩和科技部老师业绩
          /// 
          /// 示例请求：
          /// ```json
          /// GET /api/Extend/LqHytkHytk?jksId=健康师ID&amp;kjblsId=科技部老师ID&amp;currentPage=1&amp;pageSize=10
          /// ```
          /// 
          /// 参数说明：
          /// - jksId: 健康师ID（可选，传入后只返回该健康师参与的退卡记录）
          /// - kjblsId: 科技部老师ID（可选，传入后只返回该老师参与的退卡记录）
          /// - id: 退卡编号（可选）
          /// - md: 门店ID（可选）
          /// - hy: 会员ID（可选）
          /// - tksj: 退卡时间（可选，格式：yyyy-MM-dd,yyyy-MM-dd）
          /// - currentPage: 当前页码（必填）
          /// - pageSize: 每页数量（必填）
          /// 
          /// 返回数据说明：
          /// - 退卡基本信息：id、门店信息、会员信息、退卡金额、退卡时间等
          /// - lqHytkMxList: 退卡品项明细列表，每个明细包含品项信息、退款金额、项目次数等
          /// - lqHytkJksyjList: 健康师业绩列表，每个业绩包含健康师信息、业绩金额、手工费、退卡品项次数等
          /// - lqHytkKjbsyjList: 科技部老师业绩列表，每个业绩包含科技部老师信息、业绩金额、手工费、退卡品项次数等
          /// </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] LqHytkHytkListQueryInput input)
          {
              var sidx = input.sidx == null ? "id" : input.sidx;

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

              DateTime? startTksj = queryTksj != null ? Ext.GetDateTime(queryTksj.First()) : null;
              DateTime? endTksj = queryTksj != null ? Ext.GetDateTime(queryTksj.Last()) : null;

  
              // 根据是否传入健康师ID或科技部老师ID，动态构建查询
              ISugarQueryable<LqHytkHytkEntity> baseQuery = null;
  
              if (!string.IsNullOrEmpty(input.jksId) && !string.IsNullOrEmpty(input.kjblsId))
              {
                  // 同时传入健康师ID和科技部老师ID，需要同时关联两个业绩表（不过滤有效性）
                  baseQuery = _db.Queryable<LqHytkJksyjEntity, LqHytkKjbsyjEntity, LqHytkHytkEntity>(
                          (jksyj, kjbsyj, hytk) => jksyj.Gltkbh == hytk.Id && kjbsyj.Gltkbh == hytk.Id)
                      .Where((jksyj, kjbsyj, hytk) => jksyj.Jkszh == input.jksId)
                      .Where((jksyj, kjbsyj, hytk) => kjbsyj.Kjblszh == input.kjblsId)
                      .Select((jksyj, kjbsyj, hytk) => hytk)
                      .Distinct()
                      .MergeTable();
              }
              else if (!string.IsNullOrEmpty(input.jksId))
              {
                  // 只传入健康师ID，关联健康师业绩表（不过滤有效性）
                  baseQuery = _db.Queryable<LqHytkJksyjEntity, LqHytkHytkEntity>(
                          (jksyj, hytk) => jksyj.Gltkbh == hytk.Id)
                      .Where((jksyj, hytk) => jksyj.Jkszh == input.jksId)
                      .Select((jksyj, hytk) => hytk)
                      .Distinct()
                      .MergeTable();
              }
              else if (!string.IsNullOrEmpty(input.kjblsId))
              {
                  // 只传入科技部老师ID，关联科技部老师业绩表（不过滤有效性）
                  baseQuery = _db.Queryable<LqHytkKjbsyjEntity, LqHytkHytkEntity>(
                          (kjbsyj, hytk) => kjbsyj.Gltkbh == hytk.Id)
                      .Where((kjbsyj, hytk) => kjbsyj.Kjblszh == input.kjblsId)
                      .Select((kjbsyj, hytk) => hytk)
                      .Distinct()
                      .MergeTable();
              }
              else
              {
                  // 没有传入健康师ID或科技部老师ID，使用原来的查询逻辑
                  baseQuery = _db.Queryable<LqHytkHytkEntity>();
              }
  
              var data = await baseQuery

                  .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.hymc), p => p.Hymc.Contains(input.hymc))

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

                  .WhereIF(!string.IsNullOrEmpty(input.gklx), p => p.Gklx.Contains(input.gklx))
                  .WhereIF(input.tkje.HasValue, p => p.Tkje == input.tkje)
                  .WhereIF(input.sgfy.HasValue, p => p.Sgfy == input.sgfy)

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

                  .WhereIF(!string.IsNullOrEmpty(input.tkzt), p => p.Tkzt.Contains(input.tkzt))
                  .WhereIF(!string.IsNullOrEmpty(input.tkyy), p => p.Tkyy.Contains(input.tkyy))

                  .WhereIF(!string.IsNullOrEmpty(input.fileUrl), p => p.FileUrl.Contains(input.fileUrl))
                  .WhereIF(queryTksj != null, p => p.Tksj >= new DateTime(startTksj.ToDate().Year, startTksj.ToDate().Month, startTksj.ToDate().Day, 0, 0, 0))
                  .WhereIF(queryTksj != null, p => p.Tksj <= new DateTime(endTksj.ToDate().Year, endTksj.ToDate().Month, endTksj.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 LqHytkHytkListOutput

                  {
                      id = it.Id,

                      md = it.Md,
                      mdbh = it.Mdbh,
                      mdmc = it.Mdmc,
                      hy = it.Hy,
                      hymc = it.Hymc,
                      hyzh = it.Hyzh,
                      gklx = it.Gklx,
                      tkje = it.Tkje,
                      sgfy = it.Sgfy,
                      bz = it.Bz,
                      tkzt = it.Tkzt,
                      tkyy = it.Tkyy,
                      tksj = it.Tksj,
                      czry = it.Czry,
                      fileUrl = it.FileUrl,

                      isEffective = it.IsEffective,

                      cancelRemark = it.CancelRemark,

                      actualRefundAmount = it.ActualRefundAmount

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

  
              // 获取当前页的退卡记录ID列表
              var refundIds = data.list.Select(x => x.id).ToList();
  
              // 批量查询品项明细（不过滤有效性，返回所有记录）
              var itemDetails = new List<LqHytkMxInfoOutput>();
              if (refundIds.Any())
              {
                  itemDetails = await _db.Queryable<LqHytkMxEntity>()
                      .Where(x => refundIds.Contains(x.RefundInfoId))
                      .Select(x => new LqHytkMxInfoOutput
                      {
                          id = x.Id,
                          refundInfoId = x.RefundInfoId,
                          billingItemId = x.BillingItemId,
                          px = x.Px,
                          pxmc = x.Pxmc,
                          pxjg = x.Pxjg,
                          tkje = x.Tkje,
                          projectNumber = x.ProjectNumber,
                          isEffective = x.IsEffective,
                          sourceType = x.SourceType,
                          totalPrice = x.TotalPrice
                      })
                      .ToListAsync();
              }
  
              // 批量查询健康师业绩（性能优化：一次性查询所有退卡的健康师业绩，不过滤有效性）
              var jksyjList = new List<LqHytkJksyjInfoOutput>();
              if (refundIds.Any())
              {
                  jksyjList = await _db.Queryable<LqHytkJksyjEntity>()
                      .Where(x => refundIds.Contains(x.Gltkbh))
                      .Select(x => new LqHytkJksyjInfoOutput
                      {
                          id = x.Id,
                          gltkbh = x.Gltkbh,
                          jks = x.Jks,
                          jksxm = x.Jksxm,
                          jkszh = x.Jkszh,
                          jksyj = x.Jksyj,
                          tksj = x.Tksj,
                          F_jsjid = x.F_jsjid,
                          F_tkpxid = x.F_tkpxid,
                          F_LaborCost = x.F_LaborCost,
                          F_tkpxNumber = x.F_tkpxNumber
                      })
                      .ToListAsync();
              }
  
              // 批量查询科技部老师业绩（性能优化：一次性查询所有退卡的科技部老师业绩，不过滤有效性）
              var kjbsyjList = new List<LqHytkKjbsyjInfoOutput>();
              if (refundIds.Any())
              {
                  kjbsyjList = await _db.Queryable<LqHytkKjbsyjEntity>()
                      .Where(x => refundIds.Contains(x.Gltkbh))
                      .Select(x => new LqHytkKjbsyjInfoOutput
                      {
                          id = x.Id,
                          gltkbh = x.Gltkbh,
                          kjbls = x.Kjbls,
                          kjblsxm = x.Kjblsxm,
                          kjblszh = x.Kjblszh,
                          kjblsyj = x.Kjblsyj,
                          tksj = x.Tksj,
                          F_tkpxid = x.F_tkpxid,
                          F_LaborCost = x.F_LaborCost,
                          F_tkpxNumber = x.F_tkpxNumber
                      })
                      .ToListAsync();
              }
  
              // 按退卡ID分组品项明细
              var itemDetailsGrouped = itemDetails.GroupBy(x => x.refundInfoId)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 按退卡ID分组健康师业绩
              var jksyjGrouped = jksyjList.GroupBy(x => x.gltkbh)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 按退卡ID分组科技部老师业绩
              var kjbsyjGrouped = kjbsyjList.GroupBy(x => x.gltkbh)
                  .ToDictionary(g => g.Key, g => g.ToList());
  
              // 为每个退卡记录分配品项明细、健康师业绩和科技部老师业绩
              foreach (var item in data.list)
              {
                  item.lqHytkMxList = itemDetailsGrouped.ContainsKey(item.id)
                      ? itemDetailsGrouped[item.id]
                      : new List<LqHytkMxInfoOutput>();
                  item.lqHytkJksyjList = jksyjGrouped.ContainsKey(item.id)
                      ? jksyjGrouped[item.id]
                      : new List<LqHytkJksyjInfoOutput>();
                  item.lqHytkKjbsyjList = kjbsyjGrouped.ContainsKey(item.id)
                      ? kjbsyjGrouped[item.id]
                      : new List<LqHytkKjbsyjInfoOutput>();
              }
  

              return PageResult<LqHytkHytkListOutput>.SqlSugarPageResult(data);

          }

          #endregion

          #region 创建退卡信息及其关联的品项明细、健康师业绩、科技部老师业绩信息

          /// <summary>

          /// 创建退卡信息及其关联的品项明细、健康师业绩、科技部老师业绩信息

          /// </summary>

          /// <remarks>
          /// 创建退卡记录及其关联的品项明细、健康师业绩、科技部老师业绩信息

          ///

          /// 示例请求：
          /// ```json
          /// {
          ///   "md": "门店ID",
          ///   "mdbh": "门店编号",
          ///   "mdmc": "门店名称",
          ///   "hy": "会员ID",
          ///   "hymc": "会员姓名",
          ///   "hyzh": "会员账号",
          ///   "gklx": "顾客类型",
          ///   "tkje": 1000.00,
          ///   "sgfy": 50.00,
          ///   "bz": "备注",
          ///   "tkzt": "退卡状态",
          ///   "tkyy": "退卡原因",
          ///   "lqHytkMxList": [
          ///     {
          ///       "px": "品项编号",
          ///       "pxmc": "品项名称",
          ///       "pxjg": 100.00,
          ///       "tkje": 100.00,
          ///       "F_ProjectNumber": 1,
          ///       "F_SourceType": "来源类型",
          ///       "F_TotalPrice": 100.00,
          ///       "lqHytkJksyjList": [
          ///         {
          ///           "jks": "健康师",
          ///           "jksxm": "健康师姓名",
          ///           "jkszh": "健康师账号",
          ///           "jksyj": 50.00,
          ///           "F_jsjid": "金三角ID",
          ///           "F_tkpxid": "项目资料ID",
          ///           "F_LaborCost": 10.00,
          ///           "F_tkpxNumber": 1
          ///         }
          ///       ],
          ///       "lqHytkKjbsyjList": [
          ///         {
          ///           "kjbls": "科技部老师",
          ///           "kjblsxm": "科技部老师姓名",
          ///           "kjblszh": "科技部老师账号",
          ///           "kjblsyj": 30.00,
          ///           "F_tkpxid": "项目资料ID",
          ///           "F_LaborCost": 5.00,
          ///           "F_tkpxNumber": 1
          ///         }
          ///       ]
          ///     }
          ///   ]
          /// }
          /// ```

          ///

          /// 参数说明：
          /// - md: 门店ID
          /// - hy: 会员ID
          /// - lqHytkMxList: 退卡品项明细列表
          /// </remarks>
          /// <param name="input">退卡创建参数</param>
          /// <returns>无返回值</returns>
          /// <response code="200">创建成功</response>
          /// <response code="400">参数错误或数据验证失败</response>
          /// <response code="500">服务器内部错误</response>

          [HttpPost("")]
          public async Task Create([FromBody] LqHytkHytkCrInput input)
          {
              var userInfo = await _userManager.GetUserInfo();
              var entity = input.Adapt<LqHytkHytkEntity>();
              entity.Id = YitIdHelper.NextId().ToString();

              entity.F_CreateTime = DateTime.Now;
              entity.F_CreateUser = userInfo.userId;

              entity.IsEffective = StatusEnum.有效.GetHashCode();

              entity.Czry = userInfo.userId;

              try
              {

                  // 开启事务

                  _db.BeginTran();

                  // 新增退卡主表记录

                  var newEntity = await _db.Insertable(entity).IgnoreColumns(ignoreNullColumn: true).ExecuteReturnEntityAsync();

                  // 收集所有需要插入的实体，然后批量插入
                  var allMxEntities = new List<LqHytkMxEntity>();
                  var allJksyjEntities = new List<LqHytkJksyjEntity>();
                  var allKjbsyjEntities = new List<LqHytkKjbsyjEntity>();

                  // 处理品项明细列表
                  if (input.lqHytkMxList != null && input.lqHytkMxList.Any())

                  {

                      foreach (var item in input.lqHytkMxList)

                      {

                          // 创建品项明细实体
                          var lqHytkMxEntity = new LqHytkMxEntity
                          {
                              Id = YitIdHelper.NextId().ToString(),

                              RefundInfoId = newEntity.Id,
                              BillingItemId = item.billingItemId,

                              MemberId = newEntity.Hy,

                              CreateTime = DateTime.Now,
                              CreateUser = userInfo.userId,

                              Px = item.px,
                              Pxmc = item.pxmc,
                              Pxjg = item.pxjg,
                              Tkje = item.tkje,

                              ProjectNumber = item.F_ProjectNumber ?? 1,

                              SourceType = item.F_SourceType,
                              TotalPrice = item.F_TotalPrice ?? (item.pxjg * (item.F_ProjectNumber ?? 1)),

                              IsEffective = StatusEnum.有效.GetHashCode(),

                              ItemCategory = await _db.Queryable<LqXmzlEntity>().Where(x => x.Id == item.px).Select(x => x.Qt2).FirstAsync(),

                          };
                          allMxEntities.Add(lqHytkMxEntity);

                          // 收集该品项关联的健康师业绩
                          if (item.lqHytkJksyjList != null && item.lqHytkJksyjList.Any())
                          {
                              foreach (var ijks_tem in item.lqHytkJksyjList)
                              {

                                  allJksyjEntities.Add(new LqHytkJksyjEntity
                                  {
                                      Id = YitIdHelper.NextId().ToString(),
                                      Gltkbh = newEntity.Id,
                                      Jks = ijks_tem.jks,
                                      Jksxm = ijks_tem.jksxm,
                                      Jkszh = ijks_tem.jkszh,
                                      Jksyj = ijks_tem.jksyj,
                                      Tksj = DateTime.Now,
                                      F_jsjid = ijks_tem.F_jsjid,
                                      F_tkpxid = ijks_tem.F_tkpxid,
                                      F_LaborCost = ijks_tem.F_LaborCost,
                                      F_tkpxNumber = ijks_tem.F_tkpxNumber,
                                      F_CreateTime = DateTime.Now,
                                      F_CreateUser = userInfo.userId,

                                      CardReturn = lqHytkMxEntity.Id,
                                      IsEffective = StatusEnum.有效.GetHashCode(),

                                      ItemCategory = lqHytkMxEntity.ItemCategory,
                                      ItemId = lqHytkMxEntity.Px,

                                      StoreId = newEntity.Md,
                                      ItemName = lqHytkMxEntity.Pxmc

                                  }

                                  );

                              }
                          }

                          // 收集该品项关联的科技部老师业绩
                          if (item.lqHytkKjbsyjList != null && item.lqHytkKjbsyjList.Any())
                          {
                              foreach (var ikjbs_tem in item.lqHytkKjbsyjList)
                              {

                                  allKjbsyjEntities.Add(
                                      new LqHytkKjbsyjEntity
                                      {
                                          Id = YitIdHelper.NextId().ToString(),
                                          Gltkbh = newEntity.Id,
                                          Kjbls = ikjbs_tem.kjbls,
                                          Kjblsxm = ikjbs_tem.kjblsxm,
                                          Kjblszh = ikjbs_tem.kjblszh,
                                          Kjblsyj = ikjbs_tem.kjblsyj,
                                          Tksj = DateTime.Now,
                                          F_tkpxid = ikjbs_tem.F_tkpxid,
                                          F_LaborCost = ikjbs_tem.F_LaborCost,
                                          F_tkpxNumber = ikjbs_tem.F_tkpxNumber,
                                          F_CreateTime = DateTime.Now,
                                          F_CreateUser = userInfo.userId,

                                          CardReturn = lqHytkMxEntity.Id,

                                          IsEffective = StatusEnum.有效.GetHashCode(),

                                          ItemCategory = lqHytkMxEntity.ItemCategory,
                                          ItemId = lqHytkMxEntity.Px,

                                          StoreId = newEntity.Md,
                                          ItemName = lqHytkMxEntity.Pxmc

                                      }
                                  );

                              }
                          }

                      }

                  }

                  // 批量插入品项明细
                  if (allMxEntities.Any())

                  {

                      await _db.Insertable(allMxEntities).ExecuteCommandAsync();

                  }

                  // 批量插入健康师业绩
                  if (allJksyjEntities.Any())

                  {

                      await _db.Insertable(allJksyjEntities).ExecuteCommandAsync();

                  }

                  // 批量插入科技部老师业绩
                  if (allKjbsyjEntities.Any())

                  {

                      await _db.Insertable(allKjbsyjEntities).ExecuteCommandAsync();

                  }

                  // 关闭事务
                  _db.CommitTran();
              }
              catch (Exception ex)
              {
                  _db.RollbackTran();
                  throw NCCException.Oh(ErrorCode.COM1005, ex.Message);

              }
          }

          #endregion

          #region 更新退卡信息及其关联的品项明细、健康师业绩、科技部老师业绩信息

          /// <summary>

          /// 更新退卡信息及其关联的品项明细、健康师业绩、科技部老师业绩信息

          /// </summary>

          /// <remarks>
          /// 更新退卡记录及其关联的品项明细、健康师业绩、科技部老师业绩信息
          /// 先删除原有的关联数据，再插入新的数据
          /// </remarks>
          /// <param name="id">退卡ID</param>
          /// <param name="input">退卡更新参数</param>
          /// <returns>无返回值</returns>
          /// <response code="200">更新成功</response>
          /// <response code="400">参数错误或数据验证失败</response>
          /// <response code="500">服务器内部错误</response>

          [HttpPut("{id}")]
          public async Task Update(string id, [FromBody] LqHytkHytkUpInput input)
          {

              var userInfo = await _userManager.GetUserInfo();

              var entity = input.Adapt<LqHytkHytkEntity>();

              entity.Id = id;
              entity.F_ModifyTime = DateTime.Now;
              entity.F_ModifyUser = userInfo.userId;

              try
              {

                  // 开启事务

                  _db.BeginTran();

                  // 更新退卡主表记录
                  await _db.Updateable(entity).IgnoreColumns(true).ExecuteCommandAsync();

                  // 删除原有的关联数据

                  await _db.Deleteable<LqHytkMxEntity>().Where(x => x.RefundInfoId == id).ExecuteCommandAsync();

                  await _db.Deleteable<LqHytkJksyjEntity>().Where(x => x.Gltkbh == id).ExecuteCommandAsync();
                  await _db.Deleteable<LqHytkKjbsyjEntity>().Where(x => x.Gltkbh == id).ExecuteCommandAsync();

                  // 收集所有需要插入的实体，然后批量插入
                  var allMxEntities = new List<LqHytkMxEntity>();
                  var allJksyjEntities = new List<LqHytkJksyjEntity>();
                  var allKjbsyjEntities = new List<LqHytkKjbsyjEntity>();

                  // 处理品项明细列表
                  if (input.lqHytkMxList != null && input.lqHytkMxList.Any())

                  {

                      foreach (var item in input.lqHytkMxList)

                      {

                          // 创建品项明细实体
                          var lqHytkMxEntity = new LqHytkMxEntity
                          {
                              Id = YitIdHelper.NextId().ToString(),

                              RefundInfoId = id,
                              BillingItemId = item.billingItemId,

                              MemberId = entity.Hy,

                              CreateTime = DateTime.Now,
                              CreateUser = userInfo.userId,

                              Tksj = input.tksj,

                              Px = item.px,
                              Pxmc = item.pxmc,
                              Pxjg = item.pxjg,
                              Tkje = item.tkje,

                              ProjectNumber = item.F_ProjectNumber ?? 1,

                              SourceType = item.F_SourceType,
                              TotalPrice = item.F_TotalPrice ?? (item.pxjg * (item.F_ProjectNumber ?? 1)),

                              ItemCategory = await _db.Queryable<LqXmzlEntity>().Where(x => x.Id == item.px).Select(x => x.Qt2).FirstAsync(),

                          };
                          allMxEntities.Add(lqHytkMxEntity);

                          // 收集该品项关联的健康师业绩
                          if (item.lqHytkJksyjList != null && item.lqHytkJksyjList.Any())
                          {
                              foreach (var ijks_tem in item.lqHytkJksyjList)
                              {

                                  allJksyjEntities.Add(
                                      new LqHytkJksyjEntity
                                      {
                                          Id = YitIdHelper.NextId().ToString(),
                                          Gltkbh = id,
                                          Jks = ijks_tem.jks,
                                          Jksxm = ijks_tem.jksxm,
                                          Jkszh = ijks_tem.jkszh,
                                          Jksyj = ijks_tem.jksyj,
                                          Tksj = DateTime.Now,
                                          F_jsjid = ijks_tem.F_jsjid,
                                          F_tkpxid = ijks_tem.F_tkpxid,
                                          F_LaborCost = ijks_tem.F_LaborCost,
                                          F_tkpxNumber = ijks_tem.F_tkpxNumber,
                                          F_CreateTime = DateTime.Now,
                                          F_CreateUser = userInfo.userId,

                                          ItemCategory = lqHytkMxEntity.ItemCategory,
                                          ItemId = lqHytkMxEntity.Px,

                                          StoreId = entity.Md,
                                          ItemName = lqHytkMxEntity.Pxmc

                                      }
                                  );

                              }
                          }

                          // 收集该品项关联的科技部老师业绩
                          if (item.lqHytkKjbsyjList != null && item.lqHytkKjbsyjList.Any())
                          {
                              foreach (var ikjbs_tem in item.lqHytkKjbsyjList)
                              {

                                  allKjbsyjEntities.Add(
                                      new LqHytkKjbsyjEntity
                                      {
                                          Id = YitIdHelper.NextId().ToString(),
                                          Gltkbh = id,
                                          Kjbls = ikjbs_tem.kjbls,
                                          Kjblsxm = ikjbs_tem.kjblsxm,
                                          Kjblszh = ikjbs_tem.kjblszh,
                                          Kjblsyj = ikjbs_tem.kjblsyj,
                                          Tksj = DateTime.Now,
                                          F_tkpxid = ikjbs_tem.F_tkpxid,
                                          F_LaborCost = ikjbs_tem.F_LaborCost,
                                          F_tkpxNumber = ikjbs_tem.F_tkpxNumber,
                                          F_CreateTime = DateTime.Now,
                                          F_CreateUser = userInfo.userId,

                                          ItemCategory = lqHytkMxEntity.ItemCategory,
                                          ItemId = lqHytkMxEntity.Px,

                                          StoreId = entity.Md,
                                          ItemName = lqHytkMxEntity.Pxmc

                                      }
                                  );

                              }
                          }

                      }

                  }

                  // 批量插入品项明细
                  if (allMxEntities.Any())
                  {
                      await _db.Insertable(allMxEntities).ExecuteCommandAsync();
                  }

                  // 批量插入健康师业绩
                  if (allJksyjEntities.Any())
                  {
                      await _db.Insertable(allJksyjEntities).ExecuteCommandAsync();
                  }

                  // 批量插入科技部老师业绩
                  if (allKjbsyjEntities.Any())
                  {
                      await _db.Insertable(allKjbsyjEntities).ExecuteCommandAsync();
                  }

                  // 关闭事务

                  _db.CommitTran();
              }

              catch (Exception ex)

              {

                  _db.RollbackTran();

                  throw NCCException.Oh(ErrorCode.COM1005, ex.Message);

              }
          }

          #endregion

          #region 作废退卡信息

          /// <summary>

          /// 作废退卡信息

          /// </summary>

          /// <param name="id">主键</param>

          /// <returns></returns>

          [HttpPut("VoidRefundCardInfo/{id}")]

          public async Task<dynamic> VoidRefundCardInfo(string id, [FromQuery] string remarks = null)

          {

              try

              {

                  var entity = await _db.Queryable<LqHytkHytkEntity>().FirstAsync(p => p.Id == id && p.IsEffective == StatusEnum.有效.GetHashCode());
                  if (entity == null)
                  {
                      throw NCCException.Oh("退卡信息不存在或已被作废");
                  }
                  // 开启事务
                  _db.BeginTran();
                  // 更新主表

                  entity.IsEffective = StatusEnum.无效.GetHashCode();

                  entity.F_ModifyTime = DateTime.Now;

                  entity.CancelRemark = remarks;

                  await _db.Updateable(entity).ExecuteCommandAsync();
                  // 更新明细表

                  await _db.Updateable<LqHytkMxEntity>().SetColumns(it => new LqHytkMxEntity { IsEffective = StatusEnum.无效.GetHashCode() }).Where(w => w.RefundInfoId == id).ExecuteCommandAsync();

                  // 更新健康师业绩表

                  await _db.Updateable<LqHytkJksyjEntity>().SetColumns(it => new LqHytkJksyjEntity { IsEffective = StatusEnum.无效.GetHashCode() }).Where(w => w.Gltkbh == id).ExecuteCommandAsync();

                  // 更新科技部业绩表

                  await _db.Updateable<LqHytkKjbsyjEntity>().SetColumns(it => new LqHytkKjbsyjEntity { IsEffective = StatusEnum.无效.GetHashCode() }).Where(w => w.Gltkbh == id).ExecuteCommandAsync();

                  // 提交事务
                  _db.CommitTran();
                  return entity;
              }
              catch (Exception ex)
              {
                  _db.RollbackTran();
                  throw NCCException.Oh($"删除退卡信息失败: {ex.Message}");

              }
          }

          #endregion

          #region 物理删除退卡信息
          /// <summary>
          /// 物理删除退卡信息
          /// </summary>
          /// <remarks>
          /// 彻底删除退卡记录及其所有关联数据，包括：
          /// - 退卡主表记录
          /// - 退卡品项明细记录
          /// - 退卡健康师业绩记录
          /// - 退卡科技部老师业绩记录
          /// 
          /// 注意：此操作不可逆，请谨慎使用
          /// </remarks>
          /// <param name="id">退卡记录主键ID</param>
          /// <returns>删除结果</returns>
          /// <response code="200">删除成功</response>
          /// <response code="404">退卡记录不存在</response>
          /// <response code="500">服务器内部错误</response>
          [HttpDelete("physical/{id}")]
          public async Task<dynamic> PhysicalDelete(string id)
          {
              try
              {
                  // 检查退卡记录是否存在
                  var entity = await _db.Queryable<LqHytkHytkEntity>().FirstAsync(p => p.Id == id);
                  if (entity == null)
                  {
                      throw NCCException.Oh("退卡记录不存在");
                  }
  
                  // 开启事务
                  _db.BeginTran();
  
                  // 1. 删除退卡品项明细记录