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>

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

          /// <returns></returns>
          [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>();

  
              // 获取节点配置
              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>
  		/// <param name="input">请求参数</param>
  		/// <returns></returns>
          [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;

              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)));
  

              // 获取门店名称
              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 ?? "");
              }
  

              // 组装返回数据
              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
              }).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>();
              List<string> selectKeyList = input.selectKey.Split(',').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();

                  // 获取第一个节点
                  var firstNode = await _db.Queryable<LqReimbursementApplicationNodeEntity>()
                      .Where(x => x.ApplicationId == id && x.NodeOrder == 1)
                      .FirstAsync();
  
                  if (firstNode == null)
                  {
                      throw new Exception("未找到第一个审批节点配置");
                  }
  
                  // 更新报销申请状态
                  entity.CurrentNodeOrder = 1;
                  entity.CurrentNodeId = firstNode.Id;
                  entity.ApprovalStatus = "审批中";

                  // 清除退回原因（重新提交审批）
                  entity.ReturnedReason = null;
                  entity.ReturnedNodeOrder = null;

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

                  // 获取第一个节点的所有审批人

                  var firstNodeApprovers = await _db.Queryable<LqReimbursementApplicationNodeUserEntity>()
                      .Where(x => x.ApplicationId == id && x.NodeOrder == 1)
                      .ToListAsync();
  

                  // 获取第一个节点已有的审批记录
                  var existingRecords = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                      .Where(x => x.ApplicationId == id && x.NodeOrder == 1)
                      .ToListAsync();
  
                  // 为第一个节点的每个审批人创建待审批记录（如果不存在）

                  foreach (var approver in firstNodeApprovers)

                  {

                      // 检查是否已存在该审批人的"待审批"记录
                      var existingPendingRecord = existingRecords.FirstOrDefault(x =>
                          x.ApproverId == approver.UserId && x.ApprovalResult == "待审批");
  
                      if (existingPendingRecord == null)

                      {

                          // 如果不存在"待审批"记录，创建新的待审批记录
                          // 注意：即使之前有"退回"记录，也创建新的"待审批"记录，保留历史记录
                          var record = new LqReimbursementApprovalRecordEntity
                          {
                              Id = YitIdHelper.NextId().ToString(),
                              ApplicationId = id,
                              NodeId = firstNode.Id,
                              NodeOrder = 1,
                              ApproverId = approver.UserId,
                              ApproverName = approver.UserName,
                              ApprovalResult = "待审批",
                              IsCurrentNode = 1,
                              ApprovalTime = null
                          };
                          await _db.Insertable(record).ExecuteCommandAsync();
                      }
                      else
                      {
                          // 如果已存在"待审批"记录，只更新IsCurrentNode状态
                          existingPendingRecord.IsCurrentNode = 1;
                          await _db.Updateable(existingPendingRecord).ExecuteCommandAsync();
                      }

                  }

                  // 更新所有审批记录的IsCurrentNode状态（将第一个节点的"待审批"记录设为1，其他设为0）
                  // 注意：保留所有历史记录（包括"退回"记录），只更新IsCurrentNode状态
                  await _db.Updateable<LqReimbursementApprovalRecordEntity>()
                      .SetColumns(it => it.IsCurrentNode == 0)
                      .Where(it => it.ApplicationId == id && (it.NodeOrder != 1 || it.ApprovalResult != "待审批"))
                      .ExecuteCommandAsync();
  

                  _db.CommitTran();
              }
              catch (Exception)
              {

                  _db.RollbackTran();
                  throw;
              }
          }
  
          /// <summary>

          /// 审批操作（通过/不通过/退回）

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

          /// <param name="result">审批结果：通过/不通过/退回</param>
          /// <param name="opinion">审批意见</param>

          /// <returns></returns>

          [HttpPost("{id}/Actions/Approve")]
          public async Task Approve(string id, [FromQuery] string result, [FromQuery] string opinion = "")

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

              if (entity.CurrentNodeOrder == null || entity.CurrentNodeOrder == 0)
              {
                  throw new Exception("该申请尚未提交审批");
              }
  
              if (entity.ApprovalStatus != "审批中")
              {
                  throw new Exception($"该申请当前状态为{entity.ApprovalStatus}，无法进行审批操作");
              }
  
              // 验证当前用户是否有审批权限（管理员可以审批所有节点）
              var isAdmin = userInfo.isAdministrator;
              if (!isAdmin)
              {
                  var hasPermission = await _db.Queryable<LqReimbursementApplicationNodeUserEntity>()
                      .Where(x => x.ApplicationId == id
                          && x.NodeOrder == entity.CurrentNodeOrder
                          && x.UserId == userInfo.userId)
                      .AnyAsync();
  
                  if (!hasPermission)
                  {
                      throw new Exception("您没有当前节点的审批权限");
                  }
              }
  

              // 检查是否已经审批过（排除待审批状态）
              // 注意：如果存在"待审批"记录，说明可以审批
              // 如果不存在"待审批"记录，但存在其他状态的记录（通过、不通过），说明已经审批过
              // 但是，如果之前有"退回"记录，重新提交审批后会创建新的"待审批"记录，所以这里优先检查"待审批"状态
              var existingPendingApprovalRecord = await _db.Queryable<LqReimbursementApprovalRecordEntity>()

                  .Where(x => x.ApplicationId == id
                      && x.NodeOrder == entity.CurrentNodeOrder
                      && x.ApproverId == userInfo.userId

                      && x.ApprovalResult == "待审批")
                  .FirstAsync();

              // 如果存在"待审批"记录，说明可以审批，不需要抛出异常
              // 如果不存在"待审批"记录，需要检查是否有"通过"或"不通过"的记录（不包括"退回"，因为退回后可以重新审批）

              // 注意：如果状态已经是"已通过"，说明整个流程已完成，不允许再次审批

              if (existingPendingApprovalRecord == null)

              {

                  // 如果申请状态已经是"已通过"，不允许再次审批
                  if (entity.ApprovalStatus == "已通过")
                  {
                      throw new Exception("该申请已经审批通过，无法再次审批");
                  }
  

                  // 检查是否有"通过"或"不通过"的记录（不包括"退回"）
                  var completedRecord = await _db.Queryable<LqReimbursementApprovalRecordEntity>()
                      .Where(x => x.ApplicationId == id
                          && x.NodeOrder == entity.CurrentNodeOrder
                          && x.ApproverId == userInfo.userId
                          && (x.ApprovalResult == "通过" || x.ApprovalResult == "不通过"))
                      .FirstAsync();
  
                  if (completedRecord != null)
                  {