antissoft / lvqianmeiye_ERP

  using NCC.Common.Core.Manager;

  using NCC.Common.Enum;
  using NCC.Common.Extension;
  using NCC.Common.Filter;
  using NCC.Dependency;
  using NCC.DynamicApiController;
  using NCC.FriendlyException;
  using NCC.Extend.Interfaces.LqReimbursementApplication;
  using Mapster;
  using Microsoft.AspNetCore.Mvc;
  using SqlSugar;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  using NCC.Extend.Entitys;
  using NCC.Extend.Entitys.Dto.LqReimbursementApplication;

  using NCC.Extend.Entitys.lq_reimbursement_application_node;
  using NCC.Extend.Entitys.lq_reimbursement_application_node_user;
  using NCC.Extend.Entitys.lq_reimbursement_approval_record;

  using NCC.Extend.Entitys.lq_mdxx;

  using Yitter.IdGenerator;
  using NCC.Common.Helper;
  using NCC.JsonSerialization;
  using NCC.Common.Model.NPOI;
  using NCC.Common.Configuration;
  using NCC.DataEncryption;
  using NCC.ClayObject;
  
  namespace NCC.Extend.LqReimbursementApplication
  {
      /// <summary>
      /// 报销申请表服务
      /// </summary>

      [ApiDescriptionSettings(Tag = "Extend", Name = "LqReimbursementApplication", Order = 200)]

      [Route("api/Extend/[controller]")]
      public class LqReimbursementApplicationService : ILqReimbursementApplicationService, IDynamicApiController, ITransient
      {
          private readonly ISqlSugarRepository<LqReimbursementApplicationEntity> _lqReimbursementApplicationRepository;
          private readonly SqlSugarScope _db;
          private readonly IUserManager _userManager;
  
          /// <summary>
          /// 初始化一个<see cref="LqReimbursementApplicationService"/>类型的新实例
          /// </summary>
          public LqReimbursementApplicationService(
              ISqlSugarRepository<LqReimbursementApplicationEntity> lqReimbursementApplicationRepository,
              IUserManager userManager)
          {

              _lqReimbursementApplicationRepository = lqReimbursementApplicationRepository;

              _db = _lqReimbursementApplicationRepository.Context;
              _userManager = userManager;
          }
  
          /// <summary>

          /// 获取报销申请表详情（包含表单和流程信息）

          /// </summary>

          /// <remarks>
          /// 根据申请编号获取报销申请的详细信息，包括表单数据、节点配置、审批历史、购买记录等。
          /// 
          /// 示例请求：
          /// ```
          /// GET /api/Extend/LqReimbursementApplication/{id}
          /// ```
          /// 
          /// 参数说明：
          /// - id: 申请编号（必填）
          /// 
          /// 返回说明：
          /// - form: 表单基本信息，包含申请编号、申请人信息、门店信息、审批状态、完成时间等
          /// - nodes: 节点配置列表，包含每个节点的审批人、审批记录等
          /// - currentApprovers: 当前节点审批人列表
          /// - currentNodeOrder: 当前节点顺序
          /// - approvalStatus: 审批状态
          /// - returnedReason: 退回原因（如果有）
          /// - purchaseRecords: 关联的购买记录列表
          /// - form.completionTime: 完成时间（最后一个审批人通过的时间），如果申请未完成则为null
          /// </remarks>

          /// <param name="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)
          {
              var entity = await _db.Queryable<LqReimbursementApplicationEntity>().FirstAsync(p => p.Id == id);

              _ = entity ?? throw NCCException.Oh(ErrorCode.COM1005);
  

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

              // 获取完成时间（优先使用实体类中的 CompletionTime，如果没有则查询审批记录）
              if (entity.CompletionTime.HasValue)
              {
                  output.completionTime = entity.CompletionTime;
              }
              else
              {
                  // 查询最后一次审批通过的记录
                  var completionRecord = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                      .Where(x => x.ApplicationId == id && x.ApprovalResult == "通过")
                      .OrderBy(x => x.ApprovalTime, OrderByType.Desc)
                      .FirstAsync();
                  output.completionTime = completionRecord?.ApprovalTime;
              }
  

              // 获取节点配置
              var nodes = await _db.Queryable<LqReimbursementApplicationNodeEntity>()
                  .Where(x => x.ApplicationId == id)
                  .OrderBy(x => x.NodeOrder)
                  .ToListAsync();
  
              // 获取每个节点的审批人
              var nodeUsers = await _db.Queryable<LqReimbursementApplicationNodeUserEntity>()
                  .Where(x => x.ApplicationId == id)
                  .OrderBy(x => x.NodeOrder)
                  .OrderBy(x => x.SortOrder)
                  .ToListAsync();
  
              // 获取审批历史
              var approvalRecords = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                  .Where(x => x.ApplicationId == id)
                  .OrderBy(x => x.NodeOrder)
                  .OrderBy(x => x.ApprovalTime)
                  .ToListAsync();
  

              // 获取关联的购买记录
              var purchaseRecords = await _db.Queryable<LqPurchaseRecordsEntity>()
                  .Where(x => x.ApplicationId == id)
                  .OrderBy(x => x.CreateTime)
                  .ToListAsync();
  
              // 获取门店名称
              string storeName = null;
              if (!string.IsNullOrEmpty(entity.ApplicationStoreId))
              {
                  var store = await _db.Queryable<LqMdxxEntity>()
                      .Where(x => x.Id == entity.ApplicationStoreId)
                      .Select(x => x.Dm)
                      .FirstAsync();
                  storeName = store ?? null;
              }
              output.applicationStoreName = storeName;
  

              // 组装节点信息
              var nodeList = nodes.Select(n => new
              {
                  nodeId = n.Id,
                  nodeOrder = n.NodeOrder,
                  nodeName = n.NodeName,
                  approvalType = n.ApprovalType,
                  isRequired = n.IsRequired,
                  approvers = nodeUsers.Where(u => u.NodeId == n.Id).Select(u => new
                  {
                      userId = u.UserId,
                      userName = u.UserName,
                      sortOrder = u.SortOrder
                  }).ToList(),
                  approvalRecords = approvalRecords.Where(r => r.NodeId == n.Id).Select(r => new
                  {
                      approverName = r.ApproverName,
                      approvalResult = r.ApprovalResult,
                      approvalOpinion = r.ApprovalOpinion,
                      approvalTime = r.ApprovalTime
                  }).ToList()
              }).ToList();
  
              // 获取当前节点审批人
              var currentApprovers = new List<object>();
              if (entity.CurrentNodeOrder.HasValue && entity.CurrentNodeOrder > 0)
              {
                  currentApprovers = nodeUsers
                      .Where(u => u.NodeOrder == entity.CurrentNodeOrder.Value)
                      .Select(u => new
                      {
                          userId = u.UserId,
                          userName = u.UserName
                      })
                      .Cast<object>()
                      .ToList();
              }
  

              // 组装购买记录数据
              var purchaseRecordsList = purchaseRecords.Select(pr => new
              {
                  id = pr.Id,
                  reimbursementCategoryId = pr.ReimbursementCategoryId,
                  reimbursementCategoryName = pr.ReimbursementCategoryName,
                  unitPrice = pr.UnitPrice,
                  quantity = pr.Quantity,
                  amount = pr.Amount,
                  memo = pr.Memo,
                  attachment = pr.Attachment,
                  purchaseTime = pr.PurchaseTime,
                  createTime = pr.CreateTime,
                  createUser = pr.CreateUser,
                  createUserStoreId = pr.CreateUserStoreId,
                  approveStatus = pr.ApproveStatus,
                  approveUser = pr.ApproveUser,
                  approveTime = pr.ApproveTime,
                  applicationId = pr.ApplicationId
              }).ToList();
  

              return new
              {
                  form = output,
                  nodes = nodeList,
                  currentApprovers = currentApprovers,
                  currentNodeOrder = entity.CurrentNodeOrder,
                  approvalStatus = entity.ApprovalStatus ?? entity.ApproveStatus,

                  returnedReason = entity.ReturnedReason,
                  purchaseRecords = purchaseRecordsList

              };

          }
  
          /// <summary>
  		/// 获取报销申请表列表
  		/// </summary>

  		/// <remarks>
  		/// 获取报销申请表分页列表，支持多种查询条件组合查询。
  		/// 
  		/// 示例请求：
  		/// ```
  		/// GET /api/Extend/LqReimbursementApplication?currentPage=1&pageSize=20&approveStatus=已通过&completionTime=2025-01-01,2025-12-31
  		/// ```
  		/// 
  		/// 参数说明：
  		/// - currentPage: 当前页码（默认1）
  		/// - pageSize: 每页数量（默认20）
  		/// - id: 申请编号（可选，模糊查询）
  		/// - applicationUserId: 申请人编号（可选，模糊查询）
  		/// - applicationUserName: 申请人姓名（可选，模糊查询）
  		/// - applicationStoreId: 申请门店ID（可选，模糊查询）
  		/// - applicationTime: 申请时间范围（可选，格式：开始时间,结束时间）
  		/// - amount: 总金额（可选，模糊查询）
  		/// - approveUser: 审批人（可选，精确匹配）
  		/// - approveStatus: 审批结果（可选，模糊查询）
  		/// - approveTime: 审批时间范围（可选，格式：开始时间,结束时间）
  		/// - purchaseRecordsId: 关联购买编号（可选，模糊查询）
  		/// - completionTime: 完成时间范围（可选，格式：开始时间,结束时间）。完成时间指最后一个审批人通过的时间
  		/// 
  		/// 返回说明：
  		/// - 返回分页列表，包含报销申请详细信息
  		/// - 每条记录包含：申请编号、申请人信息、门店信息、审批状态、完成时间等
  		/// - completionTime: 完成时间（最后一个审批人通过的时间），如果申请未完成则为null
  		/// </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] LqReimbursementApplicationListQueryInput input)
          {

              List<string> queryApplicationTime = input.applicationTime != null ? input.applicationTime.Split(',').ToObeject<List<string>>() : null;
              DateTime? startApplicationTime = queryApplicationTime != null ? Ext.GetDateTime(queryApplicationTime.First()) : null;
              DateTime? endApplicationTime = queryApplicationTime != null ? Ext.GetDateTime(queryApplicationTime.Last()) : null;
              List<string> queryApproveTime = input.approveTime != null ? input.approveTime.Split(',').ToObeject<List<string>>() : null;
              DateTime? startApproveTime = queryApproveTime != null ? Ext.GetDateTime(queryApproveTime.First()) : null;
              DateTime? endApproveTime = queryApproveTime != null ? Ext.GetDateTime(queryApproveTime.Last()) : null;

              List<string> queryCompletionTime = input.completionTime != null ? input.completionTime.Split(',').ToObeject<List<string>>() : null;
              DateTime? startCompletionTime = queryCompletionTime != null ? Ext.GetDateTime(queryCompletionTime.First()) : null;
              DateTime? endCompletionTime = queryCompletionTime != null ? Ext.GetDateTime(queryCompletionTime.Last()) : null;

              var query = _db.Queryable<LqReimbursementApplicationEntity>()

                  .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationUserId), p => p.ApplicationUserId.Contains(input.applicationUserId))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationUserName), p => p.ApplicationUserName.Contains(input.applicationUserName))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationStoreId), p => p.ApplicationStoreId.Contains(input.applicationStoreId))
                  .WhereIF(queryApplicationTime != null, p => p.ApplicationTime >= new DateTime(startApplicationTime.ToDate().Year, startApplicationTime.ToDate().Month, startApplicationTime.ToDate().Day, 0, 0, 0))
                  .WhereIF(queryApplicationTime != null, p => p.ApplicationTime <= new DateTime(endApplicationTime.ToDate().Year, endApplicationTime.ToDate().Month, endApplicationTime.ToDate().Day, 23, 59, 59))
                  .WhereIF(!string.IsNullOrEmpty(input.amount), p => p.Amount.Contains(input.amount))
                  .WhereIF(!string.IsNullOrEmpty(input.approveUser), p => p.ApproveUser.Equals(input.approveUser))

                  .WhereIF(!string.IsNullOrEmpty(input.approveStatus), p => (p.ApprovalStatus ?? p.ApproveStatus).Contains(input.approveStatus))

                  // .WhereIF(queryApproveTime != null, p => p.ApproveTime >= new DateTime(startApproveTime.ToDate().Year, startApproveTime.ToDate().Month, startApproveTime.ToDate().Day, 0, 0, 0))

                  //.WhereIF(queryApproveTime != null, p => p.ApproveTime <= new DateTime(endApproveTime.ToDate().Year, endApproveTime.ToDate().Month, endApproveTime.ToDate().Day, 23, 59, 59))

                  .WhereIF(!string.IsNullOrEmpty(input.purchaseRecordsId), p => p.PurchaseRecordsId.Contains(input.purchaseRecordsId));
  
              // 处理排序（兼容前端传入的字段名）
              if (string.IsNullOrEmpty(input.sidx))
              {
                  query = query.OrderBy(x => x.ApplicationTime, OrderByType.Desc);
              }
              else
              {
                  var sortType = input.sort?.ToLower() == "desc" ? OrderByType.Desc : OrderByType.Asc;
                  // 根据字段名映射到实体属性（兼容前端传入的字段名）
                  switch (input.sidx.ToLower())
                  {
                      case "id":
                          query = query.OrderBy(x => x.Id, sortType);
                          break;
                      case "applicationtime":
                      case "application_time":
                          query = query.OrderBy(x => x.ApplicationTime, sortType);
                          break;
                      case "amount":
                          query = query.OrderBy(x => x.Amount, sortType);
                          break;
                      case "applicationuserid":
                      case "application_user_id":
                          query = query.OrderBy(x => x.ApplicationUserId, sortType);
                          break;
                      case "applicationusername":
                      case "application_user_name":
                          query = query.OrderBy(x => x.ApplicationUserName, sortType);
                          break;
                      case "approvestatus":
                      case "approve_status":
                          query = query.OrderBy(x => x.ApprovalStatus ?? x.ApproveStatus, sortType);
                          break;
                      case "approvetime":
                      case "approve_time":
                          query = query.OrderBy(x => x.ApproveTime, sortType);
                          break;
                      default:
                          query = query.OrderBy(x => x.ApplicationTime, OrderByType.Desc);
                          break;
                  }
              }

  
              var total = await query.CountAsync();
              var entities = await query.ToPageListAsync(input.currentPage, input.pageSize);
  
              // 获取当前审批人信息
              var applicationIds = entities.Select(x => x.Id).ToList();
              var currentApprovers = new List<dynamic>();
              if (applicationIds.Any())
              {
                  var approverList = await _db.Queryable<LqReimbursementApplicationNodeUserEntity>()
                      .Where(x => applicationIds.Contains(x.ApplicationId))
                      .InnerJoin<LqReimbursementApplicationEntity>((u, a) => u.ApplicationId == a.Id && u.NodeOrder == a.CurrentNodeOrder)
                      .Select((u, a) => new
                      {
                          applicationId = a.Id,
                          approverName = u.UserName
                      })
                      .ToListAsync();
                  currentApprovers = approverList.Cast<dynamic>().ToList();
              }
  
              var approverDict = currentApprovers
                  .GroupBy(x => (string)x.applicationId)
                  .ToDictionary(g => g.Key, g => string.Join(", ", g.Select(x => (string)x.approverName)));
  

              // 如果提供了完成时间筛选，需要先查询完成时间，然后过滤
              if (queryCompletionTime != null && applicationIds.Any())
              {
                  var completionTimeRecords = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                      .Where(x => applicationIds.Contains(x.ApplicationId) && x.ApprovalResult == "通过")
                      .GroupBy(x => x.ApplicationId)
                      .Select(x => new
                      {
                          ApplicationId = x.ApplicationId,
                          MaxApprovalTime = SqlFunc.AggregateMax(x.ApprovalTime)
                      })
                      .ToListAsync();
  
                  var filteredApplicationIds = completionTimeRecords
                      .Where(x => x.MaxApprovalTime.HasValue &&
                                  x.MaxApprovalTime.Value >= new DateTime(startCompletionTime.ToDate().Year, startCompletionTime.ToDate().Month, startCompletionTime.ToDate().Day, 0, 0, 0) &&
                                  x.MaxApprovalTime.Value <= new DateTime(endCompletionTime.ToDate().Year, endCompletionTime.ToDate().Month, endCompletionTime.ToDate().Day, 23, 59, 59))
                      .Select(x => x.ApplicationId)
                      .ToList();
  
                  entities = entities.Where(x => filteredApplicationIds.Contains(x.Id)).ToList();
                  total = entities.Count;
                  applicationIds = entities.Select(x => x.Id).ToList();
              }
  

              // 获取门店名称
              var storeIds = entities.Where(x => !string.IsNullOrEmpty(x.ApplicationStoreId)).Select(x => x.ApplicationStoreId).Distinct().ToList();
              var storeDict = new Dictionary<string, string>();
              if (storeIds.Any())
              {
                  var stores = await _db.Queryable<LqMdxxEntity>()
                      .Where(x => storeIds.Contains(x.Id))
                      .Select(x => new { x.Id, x.Dm })
                      .ToListAsync();
                  storeDict = stores.ToDictionary(x => x.Id, x => x.Dm ?? "");
              }
  

              // 获取完成时间（优先使用实体类中的 CompletionTime，如果没有则查询审批记录）

              var completionTimeDict = new Dictionary<string, DateTime?>();
              if (applicationIds.Any())
              {

                  // 先检查实体类中是否有 CompletionTime
                  var entitiesWithCompletionTime = entities.Where(x => x.CompletionTime.HasValue).ToList();
                  foreach (var entity in entitiesWithCompletionTime)
                  {
                      completionTimeDict[entity.Id] = entity.CompletionTime;
                  }
  
                  // 对于没有 CompletionTime 的实体，查询审批记录
                  var entitiesWithoutCompletionTime = entities.Where(x => !x.CompletionTime.HasValue).Select(x => x.Id).ToList();
                  if (entitiesWithoutCompletionTime.Any())
                  {
                      var completionRecords = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                          .Where(x => entitiesWithoutCompletionTime.Contains(x.ApplicationId) && x.ApprovalResult == "通过")
                          .GroupBy(x => x.ApplicationId)
                          .Select(x => new
                          {
                              ApplicationId = x.ApplicationId,
                              MaxApprovalTime = SqlFunc.AggregateMax(x.ApprovalTime)
                          })
                          .ToListAsync();
                      foreach (var record in completionRecords)

                      {

                          if (!completionTimeDict.ContainsKey(record.ApplicationId))
                          {
                              completionTimeDict[record.ApplicationId] = record.MaxApprovalTime;
                          }
                      }
                  }

              }
  

              // 组装返回数据
              var result = entities.Select(item => new LqReimbursementApplicationListOutput
              {
                  id = item.Id,
                  applicationUserId = item.ApplicationUserId,
                  applicationUserName = item.ApplicationUserName,
                  applicationStoreId = item.ApplicationStoreId,

                  applicationStoreName = !string.IsNullOrEmpty(item.ApplicationStoreId) && storeDict.ContainsKey(item.ApplicationStoreId)
                      ? storeDict[item.ApplicationStoreId]
                      : null,

                  applicationTime = item.ApplicationTime,
                  amount = item.Amount,
                  approveUser = item.ApproveUser,
                  approveStatus = item.ApprovalStatus ?? item.ApproveStatus,
                  approveTime = item.ApproveTime,
                  purchaseRecordsId = item.PurchaseRecordsId,
                  currentApprovers = approverDict.ContainsKey(item.Id) ? approverDict[item.Id] : null,
                  currentNodeOrder = item.CurrentNodeOrder,

                  nodeCount = item.NodeCount,

                  completionTime = completionTimeDict.ContainsKey(item.Id) ? completionTimeDict[item.Id] : (item.CompletionTime ?? null)

              }).ToList();
  
              return PageResult<LqReimbursementApplicationListOutput>.SqlSugarPageResult(
                  new SqlSugarPagedList<LqReimbursementApplicationListOutput>

                  {

                      list = result,
                      pagination = new PagedModel { PageIndex = input.currentPage, PageSize = input.pageSize, Total = total }
                  });

          }
  
          /// <summary>
          /// 新建报销申请表
          /// </summary>
          /// <param name="input">参数</param>

          /// <returns>返回创建的申请ID</returns>

          [HttpPost("")]

          public async Task<dynamic> Create([FromBody] LqReimbursementApplicationCrInput input)

          {
              var userInfo = await _userManager.GetUserInfo();
              var entity = input.Adapt<LqReimbursementApplicationEntity>();
              entity.Id = YitIdHelper.NextId().ToString();

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

                  // 1. 验证节点配置

                  if (input.nodes == null || input.nodes.Count == 0)
                  {
                      throw new Exception("至少需要配置1个审批节点");
                  }
  
                  // 设置合理的上限，避免节点过多
                  if (input.nodes.Count > 20)

                  {

                      throw new Exception("节点数量不能超过20个");

                  }
  
                  // 验证节点顺序是否连续（1, 2, 3, ...）
                  var nodeOrders = input.nodes.Select(n => n.nodeOrder).OrderBy(x => x).ToList();
                  for (int i = 0; i < nodeOrders.Count; i++)
                  {
                      if (nodeOrders[i] != i + 1)
                      {
                          throw new Exception($"节点顺序必须连续，从1开始");
                      }
                  }
  
                  // 验证每个节点至少有一个审批人
                  foreach (var node in input.nodes)
                  {
                      if (node.approverIds == null || node.approverIds.Count == 0)
                      {
                          throw new Exception($"节点{node.nodeOrder}（{node.nodeName}）必须至少指定一个审批人");
                      }
                  }
  
                  // 2. 设置报销申请初始状态
                  entity.NodeCount = input.nodes.Count;
                  entity.CurrentNodeOrder = 0;
                  entity.ApprovalStatus = "待审批";
                  entity.ApplicationTime = DateTime.Now;
                  if (string.IsNullOrEmpty(entity.ApplicationUserId))
                  {
                      entity.ApplicationUserId = userInfo.userId;
                  }
                  if (string.IsNullOrEmpty(entity.ApplicationUserName))
                  {
                      entity.ApplicationUserName = userInfo.userName;
                  }
  
                  // 3. 保存报销申请表（不使用IgnoreColumns，确保新字段被保存）
                  var isOk = await _db.Insertable(entity).ExecuteCommandAsync();

                  if (!(isOk > 0)) throw NCCException.Oh(ErrorCode.COM1000);

                  // 4. 创建节点配置
                  if (input.nodes != null && input.nodes.Count > 0)
                  {
                      foreach (var nodeConfig in input.nodes)
                      {
                          var node = new LqReimbursementApplicationNodeEntity
                          {
                              Id = YitIdHelper.NextId().ToString(),
                              ApplicationId = entity.Id,
                              NodeOrder = nodeConfig.nodeOrder,
                              NodeName = nodeConfig.nodeName,
                              ApprovalType = nodeConfig.approvalType ?? "会签",
                              IsRequired = 1,
                              CreateTime = DateTime.Now
                          };
                          var nodeResult = await _db.Insertable(node).ExecuteCommandAsync();
                          if (nodeResult <= 0)
                          {
                              throw new Exception($"创建节点{nodeConfig.nodeOrder}失败");
                          }
  
                          // 5. 创建节点审批人
                          if (nodeConfig.approverIds != null && nodeConfig.approverIds.Count > 0)
                          {
                              for (int i = 0; i < nodeConfig.approverIds.Count; i++)
                              {
                                  var nodeUser = new LqReimbursementApplicationNodeUserEntity
                                  {
                                      Id = YitIdHelper.NextId().ToString(),
                                      ApplicationId = entity.Id,
                                      NodeId = node.Id,
                                      NodeOrder = nodeConfig.nodeOrder,
                                      UserId = nodeConfig.approverIds[i],
                                      UserName = nodeConfig.approverNames != null && i < nodeConfig.approverNames.Count
                                          ? nodeConfig.approverNames[i]
                                          : null,
                                      SortOrder = i + 1,
                                      CreateTime = DateTime.Now
                                  };
                                  var userResult = await _db.Insertable(nodeUser).ExecuteCommandAsync();
                                  if (userResult <= 0)
                                  {
                                      throw new Exception($"创建节点{nodeConfig.nodeOrder}的审批人{nodeConfig.approverIds[i]}失败");
                                  }
                              }
                          }
                      }
                  }
  
                  // 6. 更新购买记录的审批单编号和审批状态为"待审批"

                  if (input.selectedPurchaseRecordIds != null && input.selectedPurchaseRecordIds.Count > 0)
                  {
                      // 先更新ApplicationId
                      await _db.Updateable<LqPurchaseRecordsEntity>()
                          .SetColumns(it => it.ApplicationId == entity.Id)
                          .Where(it => input.selectedPurchaseRecordIds.Contains(it.Id))
                          .ExecuteCommandAsync();

                      // 再更新ApproveStatus（分开更新确保都能执行）
                      await _db.Updateable<LqPurchaseRecordsEntity>()
                          .SetColumns(it => it.ApproveStatus == "待审批")
                          .Where(it => input.selectedPurchaseRecordIds.Contains(it.Id))
                          .ExecuteCommandAsync();
                  }

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

  
                  // 返回创建的申请ID
                  return new { id = entity.Id };

              }
              catch (Exception)
              {
                  //回滚事务
                  _db.RollbackTran();
                  throw;
              }
          }
  
          /// <summary>
  		/// 获取报销申请表无分页列表
  		/// </summary>
  		/// <param name="input">请求参数</param>
  		/// <returns></returns>
          [NonAction]
          public async Task<dynamic> GetNoPagingList([FromQuery] LqReimbursementApplicationListQueryInput input)
          {
              var sidx = input.sidx == null ? "id" : input.sidx;
              List<string> queryApplicationTime = input.applicationTime != null ? input.applicationTime.Split(',').ToObeject<List<string>>() : null;
              DateTime? startApplicationTime = queryApplicationTime != null ? Ext.GetDateTime(queryApplicationTime.First()) : null;
              DateTime? endApplicationTime = queryApplicationTime != null ? Ext.GetDateTime(queryApplicationTime.Last()) : null;
              List<string> queryApproveTime = input.approveTime != null ? input.approveTime.Split(',').ToObeject<List<string>>() : null;
              DateTime? startApproveTime = queryApproveTime != null ? Ext.GetDateTime(queryApproveTime.First()) : null;
              DateTime? endApproveTime = queryApproveTime != null ? Ext.GetDateTime(queryApproveTime.Last()) : null;
              var data = await _db.Queryable<LqReimbursementApplicationEntity>()
                  .WhereIF(!string.IsNullOrEmpty(input.id), p => p.Id.Contains(input.id))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationUserId), p => p.ApplicationUserId.Contains(input.applicationUserId))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationUserName), p => p.ApplicationUserName.Contains(input.applicationUserName))
                  .WhereIF(!string.IsNullOrEmpty(input.applicationStoreId), p => p.ApplicationStoreId.Contains(input.applicationStoreId))
                  .WhereIF(queryApplicationTime != null, p => p.ApplicationTime >= new DateTime(startApplicationTime.ToDate().Year, startApplicationTime.ToDate().Month, startApplicationTime.ToDate().Day, 0, 0, 0))
                  .WhereIF(queryApplicationTime != null, p => p.ApplicationTime <= new DateTime(endApplicationTime.ToDate().Year, endApplicationTime.ToDate().Month, endApplicationTime.ToDate().Day, 23, 59, 59))
                  .WhereIF(!string.IsNullOrEmpty(input.amount), p => p.Amount.Contains(input.amount))
                  .WhereIF(!string.IsNullOrEmpty(input.approveUser), p => p.ApproveUser.Equals(input.approveUser))
                  .WhereIF(!string.IsNullOrEmpty(input.approveStatus), p => p.ApproveStatus.Contains(input.approveStatus))

                  //    .WhereIF(queryApproveTime != null, p => p.ApproveTime >= new DateTime(startApproveTime.ToDate().Year, startApproveTime.ToDate().Month, startApproveTime.ToDate().Day, 0, 0, 0))
                  //      .WhereIF(queryApproveTime != null, p => p.ApproveTime <= new DateTime(endApproveTime.ToDate().Year, endApproveTime.ToDate().Month, endApproveTime.ToDate().Day, 23, 59, 59))

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

                  .Select(it => new LqReimbursementApplicationListOutput

                  {
                      id = it.Id,

                      applicationUserId = it.ApplicationUserId,
                      applicationUserName = it.ApplicationUserName,
                      applicationStoreId = it.ApplicationStoreId,
                      applicationTime = it.ApplicationTime,
                      amount = it.Amount,
                      approveUser = it.ApproveUser,
                      approveStatus = it.ApproveStatus,
                      approveTime = it.ApproveTime,
                      purchaseRecordsId = it.PurchaseRecordsId,
                  }).MergeTable().OrderBy(sidx + " " + input.sort).ToListAsync();
              return data;

          }
  
          /// <summary>
  		/// 导出报销申请表
  		/// </summary>
  		/// <param name="input">请求参数</param>
  		/// <returns></returns>
          [HttpGet("Actions/Export")]
          public async Task<dynamic> Export([FromQuery] LqReimbursementApplicationListQueryInput input)
          {
              var userInfo = await _userManager.GetUserInfo();
              var exportData = new List<LqReimbursementApplicationListOutput>();
              if (input.dataType == 0)
              {
                  var data = Clay.Object(await this.GetList(input));
                  exportData = data.Solidify<PageResult<LqReimbursementApplicationListOutput>>().list;
              }
              else
              {
                  exportData = await this.GetNoPagingList(input);
              }

              List<ParamsModel> paramList = "[{\"value\":\"申请编号\",\"field\":\"id\"},{\"value\":\"申请人编号\",\"field\":\"applicationUserId\"},{\"value\":\"申请人姓名\",\"field\":\"applicationUserName\"},{\"value\":\"申请门店\",\"field\":\"applicationStoreId\"},{\"value\":\"申请时间\",\"field\":\"applicationTime\"},{\"value\":\"总金额\",\"field\":\"amount\"},{\"value\":\"审批人\",\"field\":\"approveUser\"},{\"value\":\"审批结果\",\"field\":\"approveStatus\"},{\"value\":\"审批时间\",\"field\":\"approveTime\"},{\"value\":\"关联购买编号\",\"field\":\"purchaseRecordsId\"},]".ToList<ParamsModel>();

              ExcelConfig excelconfig = new ExcelConfig();
              excelconfig.FileName = "报销申请表.xls";
              excelconfig.HeadFont = "微软雅黑";
              excelconfig.HeadPoint = 10;
              excelconfig.IsAllSizeColumn = true;
              excelconfig.ColumnModel = new List<ExcelColumnModel>();

              // 当未传入 selectKey 时，默认导出全部字段，避免空引用异常
              List<string> selectKeyList = !string.IsNullOrEmpty(input.selectKey)
                  ? input.selectKey.Split(',').ToList()
                  : paramList.Select(p => p.field).ToList();

              foreach (var item in selectKeyList)
              {
                  var isExist = paramList.Find(p => p.field == item);
                  if (isExist != null)
                  {
                      excelconfig.ColumnModel.Add(new ExcelColumnModel() { Column = isExist.field, ExcelColumn = isExist.value });
                  }
              }
              var addPath = FileVariable.TemporaryFilePath + excelconfig.FileName;
              ExcelExportHelper<LqReimbursementApplicationListOutput>.Export(exportData, excelconfig, addPath);
              var fileName = _userManager.UserId + "|" + addPath + "|xls";
              var output = new
              {
                  name = excelconfig.FileName,
                  url = "/api/File/Download?encryption=" + DESCEncryption.Encrypt(fileName, "NCC")
              };
              return output;
          }
  
          /// <summary>
          /// 批量删除报销申请表
          /// </summary>
          /// <param name="ids">主键数组</param>
          /// <returns></returns>
          [HttpPost("batchRemove")]
          public async Task BatchRemove([FromBody] List<string> ids)
          {
              var entitys = await _db.Queryable<LqReimbursementApplicationEntity>().In(it => it.Id, ids).ToListAsync();
              if (entitys.Count > 0)
              {
                  try
                  {
                      //开启事务
                      _db.BeginTran();
                      //批量删除报销申请表

                      await _db.Deleteable<LqReimbursementApplicationEntity>().In(d => d.Id, ids).ExecuteCommandAsync();

                      //关闭事务
                      _db.CommitTran();
                  }
                  catch (Exception)
                  {
                      //回滚事务
                      _db.RollbackTran();
                      throw NCCException.Oh(ErrorCode.COM1002);
                  }
              }
          }
  
          /// <summary>
          /// 更新报销申请表
          /// </summary>
          /// <param name="id">主键</param>
          /// <param name="input">参数</param>
          /// <returns></returns>
          [HttpPut("{id}")]
          public async Task Update(string id, [FromBody] LqReimbursementApplicationUpInput input)
          {
              try
              {
                  //开启事务
                  _db.BeginTran();

                  // 获取原有的关联购买记录ID
                  var oldEntity = await _db.Queryable<LqReimbursementApplicationEntity>().FirstAsync(p => p.Id == id);

                  _ = oldEntity ?? throw NCCException.Oh(ErrorCode.COM1005);
  
                  // 检查是否可以修改：只有"待审批"（CurrentNodeOrder=0）或"已退回"状态的申请才能修改
                  if (oldEntity.CurrentNodeOrder != null && oldEntity.CurrentNodeOrder != 0 && oldEntity.ApprovalStatus != "已退回")
                  {
                      throw new Exception($"该申请当前状态为{oldEntity.ApprovalStatus}，无法修改。只有待审批或已退回状态的申请才能修改。");
                  }

                  var oldIds = new List<string>();
                  if (oldEntity != null && !string.IsNullOrEmpty(oldEntity.PurchaseRecordsId))
                  {
                      // 获取原有购买记录ID列表
                      oldIds = oldEntity.PurchaseRecordsId.Split(',').Where(x => !string.IsNullOrEmpty(x)).ToList();
                  }

                  // 获取新的购买记录ID列表
                  var newIds = input.selectedPurchaseRecordIds ?? new List<string>();

                  // 确保 purchaseRecordsId 字段包含所有选中的记录ID（逗号分隔）
                  if (newIds.Count > 0)
                  {
                      input.purchaseRecordsId = string.Join(",", newIds);
                  }
                  else
                  {
                      input.purchaseRecordsId = null;
                  }

                  // 找出需要移除关联的记录（在旧列表中但不在新列表中）
                  var idsToRemove = oldIds.Where(x => !newIds.Contains(x)).ToList();
                  if (idsToRemove.Count > 0)
                  {
                      // 清除这些购买记录的审批单编号和审批状态
                      await _db.Updateable<LqPurchaseRecordsEntity>()

                          .SetColumns(it => new LqPurchaseRecordsEntity
                          {

                              ApplicationId = null,
                              ApproveStatus = "未审批"
                          })
                          .Where(it => idsToRemove.Contains(it.Id))
                          .ExecuteCommandAsync();
                  }

                  // 更新报销申请表（确保 purchaseRecordsId 字段被正确更新）
                  var entity = input.Adapt<LqReimbursementApplicationEntity>();
                  var isOk = await _db.Updateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                  if (!(isOk > 0)) throw NCCException.Oh(ErrorCode.COM1001);

                  // 更新所有选中的购买记录的审批单编号和审批状态为"待审批"
                  // 包括新追加的记录和已存在的记录（确保状态正确）
                  if (newIds.Count > 0)
                  {
                      // 先更新ApplicationId
                      await _db.Updateable<LqPurchaseRecordsEntity>()
                          .SetColumns(it => it.ApplicationId == id)
                          .Where(it => newIds.Contains(it.Id))
                          .ExecuteCommandAsync();

                      // 再更新ApproveStatus（分开更新确保都能执行）
                      await _db.Updateable<LqPurchaseRecordsEntity>()
                          .SetColumns(it => it.ApproveStatus == "待审批")
                          .Where(it => newIds.Contains(it.Id))
                          .ExecuteCommandAsync();
                  }

                  //关闭事务
                  _db.CommitTran();
              }
              catch (Exception)
              {
                  //回滚事务
                  _db.RollbackTran();
                  throw;
              }
          }
  
          /// <summary>
          /// 删除报销申请表
          /// </summary>
          /// <returns></returns>
          [HttpDelete("{id}")]
          public async Task Delete(string id)
          {
              var entity = await _db.Queryable<LqReimbursementApplicationEntity>().FirstAsync(p => p.Id == id);
              _ = entity ?? throw NCCException.Oh(ErrorCode.COM1005);
              var isOk = await _db.Deleteable<LqReimbursementApplicationEntity>().Where(d => d.Id == id).ExecuteCommandAsync();
              if (!(isOk > 0)) throw NCCException.Oh(ErrorCode.COM1002);
          }
  
          /// <summary>

          /// 提交审批（进入第一个节点）

          /// </summary>
          /// <param name="id">申请编号</param>
          /// <returns></returns>

          [HttpPost("{id}/Actions/SubmitApproval")]
          public async Task SubmitApproval(string id)

          {

              var entity = await _db.Queryable<LqReimbursementApplicationEntity>().FirstAsync(p => p.Id == id);
              _ = entity ?? throw NCCException.Oh(ErrorCode.COM1005);

              // 允许"待审批"和"已退回"状态的申请提交审批
              if (entity.CurrentNodeOrder != 0 && entity.ApprovalStatus != "已退回")
              {
                  throw new Exception("该申请已经提交审批，不能重复提交");
              }
  

              if (entity.NodeCount == null || entity.NodeCount == 0)

              {
                  throw new Exception("节点配置异常，无法提交审批");
              }
  

              try
              {

                  _db.BeginTran();