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;

  
  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;

  
          /// <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

          )

          {

              _lqKdKdjlbRepository = lqKdKdjlbRepository;

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

              _weChatBotService = weChatBotService;
              _stringGenerator = stringGenerator;

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

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

                  //获取会员信息
                  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;
              var data = await _db.Queryable<LqKdKdjlbEntity>()

              .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),

                  })
                  .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());
  
              // 为每个开单记录分配品项明细
              foreach (var item in data.list)
              {
                  item.ItemDetails = itemDetailsGrouped.ContainsKey(item.id)
                      ? itemDetailsGrouped[item.id]
                      : new List<LqKdPxmxInfoOutput>();
              }
  

              return PageResult<LqKdKdjlbListOutput>.SqlSugarPageResult(data);

          }

          #endregion

          #region 新建开单记录表

          /// <summary>
          /// 新建开单记录表
          /// </summary>
          /// <param name="input">参数</param>
          /// <returns></returns>
          [HttpPost("")]
          public async Task Create([FromBody] LqKdKdjlbCrInput input)
          {
              var userInfo = await _userManager.GetUserInfo();
              var entity = input.Adapt<LqKdKdjlbEntity>();

              var HealthInstructorNames = "";

              entity.Id = YitIdHelper.NextId().ToString();

              entity.CreateTime = DateTime.Now;
              entity.UpdateTime = DateTime.Now;

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

              try
              {
                  //开启事务
                  _db.BeginTran();

                  //判断是否有作废关联id

                  //暂时先不需要
                  // if (!string.IsNullOrEmpty(input.cancelRefId))
                  // {
                  //     //查询作废关联id
                  //     var cancelRefEntity = await _db.Queryable<LqKdKdjlbEntity>().FirstAsync(p => p.Id == input.cancelRefId);
                  //     if (cancelRefEntity == null || cancelRefEntity.IsEffective == StatusEnum.无效.GetHashCode())
                  //     {
                  //         throw NCCException.Oh("该开单记录已经作废");
                  //     }
                  //     // 检查作废关联记录是否可以作废
                  //     var (canCancel, errorMessage) = await CheckBillingCanCancelAsync(input.cancelRefId);
                  //     if (!canCancel)
                  //     {
                  //         throw NCCException.Oh(errorMessage);
                  //     }
  
                  //     //将作废关联id的IsEffective设置为无效
                  //     cancelRefEntity.IsEffective = StatusEnum.无效.GetHashCode();
                  //     await _db.Updateable(cancelRefEntity).ExecuteCommandAsync();
                  //     //把品项明细表的IsEffective设置为无效
                  //     await _db.Updateable<LqKdPxmxEntity>().Where(p => p.Glkdbh == input.cancelRefId).UpdateColumns(p => new LqKdPxmxEntity { IsEffective = StatusEnum.无效.GetHashCode() }).ExecuteCommandAsync();
                  //     //把健康师业绩表的IsEffective设置为无效
                  //     await _db.Updateable<LqKdJksyjEntity>().Where(p => p.Glkdbh == input.cancelRefId).UpdateColumns(p => new LqKdJksyjEntity { IsEffective = StatusEnum.无效.GetHashCode() }).ExecuteCommandAsync();
                  //     //把科技部老师业绩表的IsEffective设置为无效
                  //     await _db.Updateable<LqKdKjbsyjEntity>().Where(p => p.Glkdbh == input.cancelRefId).UpdateColumns(p => new LqKdKjbsyjEntity { IsEffective = StatusEnum.无效.GetHashCode() }).ExecuteCommandAsync();
                  //     //把扣款信息表的IsEffective设置为无效
                  //     await _db.Updateable<LqKdDeductinfoEntity>().Where(p => p.BillingId == input.cancelRefId).UpdateColumns(p => new LqKdDeductinfoEntity { IsEffective = StatusEnum.无效.GetHashCode() }).ExecuteCommandAsync();
                  // }

                  //判断是否有补缴开单ID
                  if (!string.IsNullOrEmpty(input.supplementBillingId))
                  {
                      //查询补缴开单ID
                      var supplementBillingEntity = await _db.Queryable<LqKdKdjlbEntity>().FirstAsync(p => p.Id == input.supplementBillingId);
                      if (supplementBillingEntity == null || supplementBillingEntity.IsEffective == StatusEnum.无效.GetHashCode())
                      {
                          throw NCCException.Oh("补缴开单记录不存在或已作废");
                      }
                      //然后对之前的开单表的补缴金额进行累加
                      //需要判断补缴金额是否超过欠款金额，只记录应缴金额
                      var supplementAmount = supplementBillingEntity.Qk - supplementBillingEntity.PaidDebt;

                      supplementBillingEntity.PaidDebt += input.supplementAmount > supplementAmount ? supplementAmount : input.supplementAmount;
                      await _db.Updateable(supplementBillingEntity).ExecuteCommandAsync();

                  }
  

                  //新增开单记录表记录

                  entity.CreateUser = userInfo.userId;

                  entity.DeductAmount = input.lqKdKdjlbDeductList.Sum(x => x.Amount ?? 0);//计算储扣总金额

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

                  //循环品相信息
                  // 收集所有需要插入的实体，然后批量插入
                  var allPxmxEntities = new List<LqKdPxmxEntity>();
                  var allJksyjEntities = new List<LqKdJksyjEntity>();
                  var allKjbsyjEntities = new List<LqKdKjbsyjEntity>();

                  var allDeductEntities = new List<LqKdDeductinfoEntity>();
                  // 处理扣款信息列表
                  foreach (var item in input.lqKdKdjlbDeductList)
                  {
                      var lqKdDeductEntity = new LqKdDeductinfoEntity
                      {
                          Id = YitIdHelper.NextId().ToString(),
                          BillingId = newEntity.Id,
                          DeductId = item.DeductId,
                          DeductType = item.DeductType,
                          Amount = item.Amount,

                          ProjectNumber = item.ProjectNumber,
                          UnitPrice = item.UnitPrice,
                          ItemName = item.ItemName,
                          ItemId = item.ItemId,
                          IsEffective = StatusEnum.有效.GetHashCode(), // 设置为有效
                          CreateTime = DateTime.Now, // 设置创建时间

                      };
                      allDeductEntities.Add(lqKdDeductEntity);
                  }

                  // 处理品项明细列表
                  foreach (var item in input.lqKdPxmxList)

                  {

                      // 创建品项明细实体
                      var lqKdPxmxEntity = new LqKdPxmxEntity

                      {

                          Id = YitIdHelper.NextId().ToString(),
                          Glkdbh = newEntity.Id,

                          Yjsj = input.kdrq,

                          CreateTIme = DateTime.Now,
                          MemberId = entity.Kdhy,

                          IsEnabled = StatusEnum.有效.GetHashCode(),

                          ProjectNumber = item.projectNumber,
                          TotalPrice = (decimal)(item.pxjg * item.projectNumber),

                          Px = item.px,
                          Pxmc = item.pxmc,
                          Pxjg = item.pxjg,
                          SourceType = item.sourceType,

                          ActualPrice = item.actualPrice,

                          Remark = item.remark,
                          IsEffective = StatusEnum.有效.GetHashCode(),

                          ActivityId = input.activityId,

                      };
                      allPxmxEntities.Add(lqKdPxmxEntity);

                      // 收集该品项关联的健康师业绩
                      if (item.lqKdJksyjList != null && item.lqKdJksyjList.Any())

                      {

                          //把jksxm保存到HealthInstructorNames

                          foreach (var ijks_tem in item.lqKdJksyjList)

                          {

                              HealthInstructorNames += ijks_tem.jksxm + ",";
                              allJksyjEntities.Add(new LqKdJksyjEntity
                              {
                                  Id = YitIdHelper.NextId().ToString(),
                                  Glkdbh = newEntity.Id,
                                  Jks = ijks_tem.jks,
                                  Jksxm = ijks_tem.jksxm,
                                  Jkszh = ijks_tem.jkszh,
                                  Jksyj = ijks_tem.jksyj,
                                  Yjsj = input.kdrq,
                                  Jsj_id = ijks_tem.jsj_id,
                                  Kdpxid = lqKdPxmxEntity.Id,

                                  IsEffective = StatusEnum.有效.GetHashCode(),

                                  ActivityId = input.activityId,

                              });

                          }

                      }

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

                          {

                              allKjbsyjEntities.Add(new LqKdKjbsyjEntity
                              {
                                  Id = YitIdHelper.NextId().ToString(),
                                  Glkdbh = newEntity.Id,
                                  Kjbls = ikjbs_tem.kjbls,
                                  Kjblsxm = ikjbs_tem.kjblsxm,
                                  Kjblszh = ikjbs_tem.kjblszh,
                                  Kjblsyj = ikjbs_tem.kjblsyj,
                                  Yjsj = input.kdrq,
                                  Kdpxid = lqKdPxmxEntity.Id,
                                  IsEffective = StatusEnum.有效.GetHashCode(),
                                  ActivityId = input.activityId,
                              }

                              );

                          }

                      }

                  }

                  //通过会员id查询会员信息
                  var memberInfo = await _db.Queryable<LqKhxxEntity>().Where(u => u.Id == entity.Kdhy).FirstAsync();

                  //通过开单记录表查询这个会员开单金额
                  var kdAmount = await _db.Queryable<LqKdKdjlbEntity>().Where(u => u.Kdhy == entity.Kdhy).SumAsync(u => u.Sfyj);
                  //如果开单金额小于500，为散客，如果大于500，为会员

                  if (kdAmount < 500 && kdAmount > 0)

                  {
                      memberInfo.Khlx = MemberTypeEnum.散客.GetHashCode().ToString();
                  }
                  else
                  {
                      memberInfo.Khlx = MemberTypeEnum.会员.GetHashCode().ToString();
                  }

                  await _db.Updateable(memberInfo).ExecuteCommandAsync();

                  // 批量插入扣款信息
                  if (allDeductEntities.Any())
                  {
                      await _db.Insertable(allDeductEntities).ExecuteCommandAsync();
                  }

                  // 批量插入品项明细
                  if (allPxmxEntities.Any())
                  {
                      await _db.Insertable(allPxmxEntities).ExecuteCommandAsync();
                  }
                  // 批量插入健康师业绩
                  if (allJksyjEntities.Any())
                  {
                      await _db.Insertable(allJksyjEntities).ExecuteCommandAsync();
                  }
                  // 批量插入科技部老师业绩
                  if (allKjbsyjEntities.Any())
                  {
                      await _db.Insertable(allKjbsyjEntities).ExecuteCommandAsync();
                  }

                  //关闭事务
                  _db.CommitTran();

                  // 生成开单记录字符串并发送到企业微信
                  try
                  {
                      var entityInfo = await GetInfo(newEntity.Id);
                      if (entityInfo != null)
                      {

                          var orderRecordString = _stringGenerator.GenerateOrderRecordString(entityInfo, HealthInstructorNames);

                          Console.WriteLine("开单记录字符串生成成功:");
                          Console.WriteLine(orderRecordString);

                          // 发送到企业微信群
                          try
                          {

                              var sendResult = await _weChatBotService.SendOrderRecordMessage(orderRecordString);

                              if (sendResult)
                              {
                                  Console.WriteLine("开单记录已成功发送到企业微信群");
                              }
                              else
                              {
                                  Console.WriteLine("开单记录发送到企业微信群失败");
                              }
                          }
                          catch (Exception wechatEx)
                          {
                              Console.WriteLine($"发送企业微信消息异常: {wechatEx.Message}");
                          }
                      }
                  }
                  catch (Exception ex)
                  {
                      // 字符串生成失败不影响主流程，只记录日志
                      Console.WriteLine($"生成开单记录字符串失败: {ex.Message}");
                  }

              }

              catch (Exception ex)

              {
                  //回滚事务
                  _db.RollbackTran();

                  Console.WriteLine($"开单创建失败: {ex.Message}");
                  Console.WriteLine($"异常堆栈: {ex.StackTrace}");

                  throw NCCException.Oh(ErrorCode.COM1000);
              }
          }

          #endregion

          #region 新建开单记录表_备份
          /// <summary>
          /// 新建开单记录表_备份
          /// </summary>
          /// <param name="input">参数</param>
          /// <returns></returns>
          [HttpPost("Create_Bak")]
          public async Task Create_Bak([FromBody] LqKdKdjlbCrInput input)
          {
              var userInfo = await _userManager.GetUserInfo();
              var entity = input.Adapt<LqKdKdjlbEntity>();
              var HealthInstructorNames = "";
              entity.Id = YitIdHelper.NextId().ToString();
              entity.CreateTime = DateTime.Now;
              entity.UpdateTime = DateTime.Now;
              try
              {
                  //开启事务
                  _db.BeginTran();
                  //新增开单记录表记录
                  entity.CreateUser = userInfo.userId;
                  entity.DeductAmount = input.lqKdKdjlbDeductList.Sum(x => x.Amount ?? 0);//计算储扣总金额
                  var newEntity = await _db.Insertable(entity).IgnoreColumns(ignoreNullColumn: true).ExecuteReturnEntityAsync();
                  //循环品相信息
                  // 收集所有需要插入的实体，然后批量插入
                  var allPxmxEntities = new List<LqKdPxmxEntity>();
                  var allJksyjEntities = new List<LqKdJksyjEntity>();
                  var allKjbsyjEntities = new List<LqKdKjbsyjEntity>();
                  var allDeductEntities = new List<LqKdDeductinfoEntity>();
                  // 处理扣款信息列表
                  foreach (var item in input.lqKdKdjlbDeductList)
                  {
                      var lqKdDeductEntity = new LqKdDeductinfoEntity
                      {
                          Id = YitIdHelper.NextId().ToString(),
                          BillingId = newEntity.Id,
                          DeductId = item.DeductId,
                          DeductType = item.DeductType,
                          Amount = item.Amount,
                      };
                      allDeductEntities.Add(lqKdDeductEntity);
                  }
                  // 处理品项明细列表
                  foreach (var item in input.lqKdPxmxList)
                  {
                      // 创建品项明细实体
                      var lqKdPxmxEntity = new LqKdPxmxEntity
                      {
                          Id = YitIdHelper.NextId().ToString(),
                          Glkdbh = newEntity.Id,
                          Yjsj = input.kdrq,
                          CreateTIme = DateTime.Now,
                          MemberId = entity.Kdhy,
                          IsEnabled = 0,
                          ProjectNumber = item.projectNumber,
                          TotalPrice = (decimal)(item.pxjg * item.projectNumber),
                          Px = item.px,
                          Pxmc = item.pxmc,
                          Pxjg = item.pxjg,
                          SourceType = item.sourceType,
                          ActualPrice = item.actualPrice,
                      };
                      allPxmxEntities.Add(lqKdPxmxEntity);
  
                      // 收集该品项关联的健康师业绩
                      if (item.lqKdJksyjList != null && item.lqKdJksyjList.Any())
                      {
                          //把jksxm保存到HealthInstructorNames
                          foreach (var ijks_tem in item.lqKdJksyjList)
                          {
                              HealthInstructorNames += ijks_tem.jksxm + ",";
                              allJksyjEntities.Add(new LqKdJksyjEntity
                              {
                                  Id = YitIdHelper.NextId().ToString(),
                                  Glkdbh = newEntity.Id,
                                  Jks = ijks_tem.jks,
                                  Jksxm = ijks_tem.jksxm,
                                  Jkszh = ijks_tem.jkszh,
                                  Jksyj = ijks_tem.jksyj,
                                  Yjsj = input.kdrq,
                                  Jsj_id = ijks_tem.jsj_id,
                                  Kdpxid = lqKdPxmxEntity.Id,
                              });
                          }
                      }
  
                      // 收集该品项关联的科技部老师业绩
                      if (item.lqKdKjbsyjList != null && item.lqKdKjbsyjList.Any())
                      {
                          foreach (var ikjbs_tem in item.lqKdKjbsyjList)
                          {
                              allKjbsyjEntities.Add(
                                  new LqKdKjbsyjEntity
                                  {
                                      Id = YitIdHelper.NextId().ToString(),
                                      Glkdbh = newEntity.Id,
                                      Kjbls = ikjbs_tem.kjbls,
                                      Kjblsxm = ikjbs_tem.kjblsxm,
                                      Kjblszh = ikjbs_tem.kjblszh,
                                      Kjblsyj = ikjbs_tem.kjblsyj,
                                      Yjsj = input.kdrq,
                                      Kdpxid = lqKdPxmxEntity.Id,
                                  }
                              );
                          }
                      }
                  }
  
  
                  //通过会员id查询会员信息
                  var memberInfo = await _db.Queryable<LqKhxxEntity>().Where(u => u.Id == entity.Kdhy).FirstAsync();
                  //通过开单记录表查询这个会员开单金额
                  var kdAmount = await _db.Queryable<LqKdKdjlbEntity>().Where(u => u.Kdhy == entity.Kdhy).SumAsync(u => u.Sfyj);
                  //如果开单金额小于500，为散客，如果大于500，为会员
                  if (kdAmount < 500)
                  {
                      memberInfo.Khlx = MemberTypeEnum.散客.GetHashCode().ToString();
                  }
                  else
                  {
                      memberInfo.Khlx = MemberTypeEnum.会员.GetHashCode().ToString();
                  }
                  await _db.Updateable(memberInfo).ExecuteCommandAsync();
                  // 批量插入扣款信息
                  if (allDeductEntities.Any())
                  {
                      await _db.Insertable(allDeductEntities).ExecuteCommandAsync();
                  }
                  // 批量插入品项明细
                  if (allPxmxEntities.Any())
                  {
                      await _db.Insertable(allPxmxEntities).ExecuteCommandAsync();
                  }
                  // 批量插入健康师业绩
                  if (allJksyjEntities.Any())
                  {
                      await _db.Insertable(allJksyjEntities).ExecuteCommandAsync();
                  }
                  // 批量插入科技部老师业绩
                  if (allKjbsyjEntities.Any())
                  {
                      await _db.Insertable(allKjbsyjEntities).ExecuteCommandAsync();
                  }
  
                  //关闭事务
                  _db.CommitTran();
  
                  // 生成开单记录字符串并发送到企业微信
                  try
                  {
                      var entityInfo = await GetInfo(newEntity.Id);
                      if (entityInfo != null)
                      {
                          var orderRecordString = _stringGenerator.GenerateOrderRecordString(entityInfo, HealthInstructorNames);
                          Console.WriteLine("开单记录字符串生成成功:");
                          Console.WriteLine(orderRecordString);
  
                          // 发送到企业微信群
                          try
                          {
                              var sendResult = await _weChatBotService.SendOrderRecordMessage(orderRecordString);
                              if (sendResult)
                              {
                                  Console.WriteLine("开单记录已成功发送到企业微信群");
                              }
                              else
                              {
                                  Console.WriteLine("开单记录发送到企业微信群失败");
                              }
                          }
                          catch (Exception wechatEx)
                          {
                              Console.WriteLine($"发送企业微信消息异常: {wechatEx.Message}");
                          }
                      }
                  }
                  catch (Exception ex)
                  {
                      // 字符串生成失败不影响主流程，只记录日志
                      Console.WriteLine($"生成开单记录字符串失败: {ex.Message}");
                  }
              }
              catch (Exception ex)
              {
                  //回滚事务
                  _db.RollbackTran();
                  Console.WriteLine($"开单创建失败: {ex.Message}");
                  Console.WriteLine($"异常堆栈: {ex.StackTrace}");
                  throw NCCException.Oh(ErrorCode.COM1000);
              }
          }
          #endregion
  

          #region 获取开单记录表无分页列表

          /// <summary>

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