antissoft / lvqianmeiye_ERP

  using Microsoft.AspNetCore.Authorization;

  using Microsoft.AspNetCore.Http;

  using Microsoft.AspNetCore.Mvc;

  using Microsoft.Extensions.Logging;

  using NCC.Common.Enum;
  using NCC.Common.Filter;
  using NCC.Common.Helper;
  using NCC.Dependency;
  using NCC.DynamicApiController;
  using NCC.Extend.Entitys.Dto.LqSalary;

  using NCC.FriendlyException;
  using System.IO;

  using Yitter.IdGenerator;
  using NCC.Extend.Entitys.lq_attendance_summary;
  using NCC.Extend.Entitys.lq_jinsanjiao_user;
  using NCC.Extend.Entitys.lq_kd_jksyj;
  using NCC.Extend.Entitys.lq_kd_kdjlb;
  using NCC.Extend.Entitys.lq_md_target;
  using NCC.Extend.Entitys.lq_person_times_record;
  using NCC.Extend.Entitys.lq_salary_statistics;
  using NCC.Extend.Entitys.lq_xh_jksyj;
  using NCC.Extend.Entitys.lq_ycsd_jsj;

  using NCC.Extend.Entitys.lq_mdxx;
  using NCC.Extend.Entitys.lq_hytk_hytk;

  using NCC.Extend.Entitys.lq_hytk_jksyj;

  using NCC.Extend.Entitys.lq_md_xdbhsj;
  using NCC.Extend.Entitys.lq_salary_extra_calculation;
  using NCC.System.Entitys.Permission;

  using SqlSugar;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  
  namespace NCC.Extend
  {
      /// <summary>

      /// 健康师薪酬服务

      /// </summary>

      [ApiDescriptionSettings(Tag = "健康师薪酬服务", Name = "LqSalary", Order = 300)]

      [Route("api/Extend/[controller]")]
      public class LqSalaryService : IDynamicApiController, ITransient
      {
          private readonly ISqlSugarClient _db;

          private readonly ILogger<LqSalaryService> _logger;

  
          /// <summary>
          /// 初始化一个<see cref="LqSalaryService"/>类型的新实例
          /// </summary>

          public LqSalaryService(ISqlSugarClient db, ILogger<LqSalaryService> logger)

          {
              _db = db;

              _logger = logger;

          }
  
          /// <summary>
          /// 获取健康师工资列表
          /// </summary>
          /// <param name="input">查询参数</param>
          /// <returns>健康师工资分页列表</returns>
          [HttpGet("health-coach")]

          public async Task<dynamic> GetHealthCoachSalaryList([FromQuery] HealthCoachSalaryInput input)

          {
              var monthStr = $"{input.Year}{input.Month:D2}";
  

              // 查询数据

              var query = _db.Queryable<LqSalaryStatisticsEntity>()
                  .Where(x => x.StatisticsMonth == monthStr);
  
              if (!string.IsNullOrEmpty(input.StoreId))
              {
                  query = query.Where(x => x.StoreId == input.StoreId);
              }
  
              if (!string.IsNullOrEmpty(input.Keyword))
              {
                  query = query.Where(x => x.EmployeeName.Contains(input.Keyword) || x.EmployeeId.Contains(input.Keyword));
              }
  
              var list = await query.Select(x => new HealthCoachSalaryOutput
              {
                  Id = x.Id,

                  StoreId = x.StoreId,

                  StoreName = x.StoreName,

                  EmployeeId = x.EmployeeId,

                  EmployeeName = x.EmployeeName,
                  Position = x.Position,

                  GoldTriangleId = x.GoldTriangleId,

                  GoldTriangleTeam = x.GoldTriangleTeam,
                  TotalPerformance = x.TotalPerformance,
                  BasePerformance = x.BasePerformance,
                  CooperationPerformance = x.CooperationPerformance,

                  BaseRewardPerformance = x.BaseRewardPerformance,
                  CooperationRewardPerformance = x.CooperationRewardPerformance,
                  ActualBasePerformance = x.ActualBasePerformance,
                  ActualCooperationPerformance = x.ActualCooperationPerformance,

                  RewardPerformance = x.RewardPerformance,

                  StoreTotalPerformance = x.StoreTotalPerformance,
                  TeamPerformance = x.TeamPerformance,
                  Percentage = x.Percentage,
                  NewCustomerPerformance = x.NewCustomerPerformance,
                  NewCustomerConversionRate = x.NewCustomerConversionRate,
                  NewCustomerPoint = x.NewCustomerPoint,
                  UpgradeCustomerCount = x.UpgradeCustomerCount,
                  UpgradePerformance = x.UpgradePerformance,
                  UpgradePoint = x.UpgradePoint,
                  NewCustomerCommission = x.NewCustomerPerformanceCommission,
                  UpgradeCommission = x.UpgradePerformanceCommission,
                  OtherPerformanceAdd = x.OtherPerformanceAdd,
                  OtherPerformanceSubtract = x.OtherPerformanceSubtract,

                  Consumption = x.Consumption,
                  ProjectCount = x.ProjectCount,
                  CustomerCount = x.CustomerCount,
                  WorkingDays = x.WorkingDays,

                  LeaveDays = x.LeaveDays,
                  CommissionPoint = x.CommissionPoint,
                  BasePerformanceCommission = x.BasePerformanceCommission,
                  CooperationPerformanceCommission = x.CooperationPerformanceCommission,
                  ConsultantCommission = x.ConsultantCommission,
                  StoreTZoneCommission = x.StoreTZoneCommission,

                  TotalCommission = x.TotalCommission,

                  HealthCoachBaseSalary = x.HealthCoachBaseSalary,

                  HandworkFee = x.HandworkFee,

                  OutherHandworkFee = x.OutherHandworkFee,
                  TransportationAllowance = x.TransportationAllowance,
                  LessRest = x.LessRest,
                  FullAttendance = x.FullAttendance,
                  CalculatedGrossSalary = x.CalculatedGrossSalary,
                  GuaranteedSalary = x.GuaranteedSalary,
                  GuaranteedLeaveDeduction = x.GuaranteedLeaveDeduction,
                  GuaranteedBaseSalary = x.GuaranteedBaseSalary,
                  GuaranteedSupplement = x.GuaranteedSupplement,
                  FinalGrossSalary = x.FinalGrossSalary,
                  MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
                  MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
                  LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
                  LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,

                  TotalSubsidy = x.TotalSubsidy,

                  MissingCard = x.MissingCard,
                  LateArrival = x.LateArrival,
                  LeaveDeduction = x.LeaveDeduction,
                  SocialInsuranceDeduction = x.SocialInsuranceDeduction,
                  RewardDeduction = x.RewardDeduction,
                  AccommodationDeduction = x.AccommodationDeduction,
                  StudyPeriodDeduction = x.StudyPeriodDeduction,
                  WorkClothesDeduction = x.WorkClothesDeduction,

                  TotalDeduction = x.TotalDeduction,

                  Bonus = x.Bonus,
                  ReturnPhoneDeposit = x.ReturnPhoneDeposit,
                  ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,

                  ActualSalary = x.ActualSalary,

                  MonthlyPaymentStatus = x.MonthlyPaymentStatus,
                  PaidAmount = x.PaidAmount,
                  PendingAmount = x.PendingAmount,
                  LastMonthSupplement = x.LastMonthSupplement,
                  MonthlyTotalPayment = x.MonthlyTotalPayment,
                  StatisticsMonth = x.StatisticsMonth,

                  IsLocked = x.IsLocked,

                  EmployeeConfirmStatus = x.EmployeeConfirmStatus,

                  CreateTime = x.CreateTime,
                  CreateUser = x.CreateUser,

                  UpdateTime = x.UpdateTime,

                  UpdateUser = x.UpdateUser,

                  IsNewStore = x.IsNewStore,
                  NewStoreProtectionStage = x.NewStoreProtectionStage,
                  StoreType = x.StoreType,
                  StoreCategory = x.StoreCategory,

                  DailyAverageConsumption = x.DailyAverageConsumption,
                  DailyAverageProjectCount = x.DailyAverageProjectCount,
                  TeamTotalConsumption = x.TeamTotalConsumption

              })
              .ToPagedListAsync(input.currentPage, input.pageSize);
  
              return PageResult<HealthCoachSalaryOutput>.SqlSugarPageResult(list);
          }
  
          /// <summary>

          /// 通过月份和员工ID查询工资（仅查询已锁定且未确认的工资）

          /// </summary>
          /// <remarks>
          /// 根据年份、月份和员工ID查询对应员工的工资记录
          /// 

          /// **重要**：此接口只能查询已锁定（IsLocked=1）且未确认（EmployeeConfirmStatus=0或null）的工资记录
          /// **注意**：已确认的工资记录无法通过此接口查询

          /// 

          /// 示例请求：
          /// ```
          /// GET /api/Extend/lqsalary/query-by-employee?Year=2026&Month=1&EmployeeId=员工ID
          /// ```
          /// 
          /// 参数说明：
          /// - Year: 年份（必填）
          /// - Month: 月份（必填）
          /// - EmployeeId: 员工ID（必填）
          /// </remarks>
          /// <param name="input">查询参数</param>
          /// <returns>工资记录详情</returns>
          /// <response code="200">查询成功，返回工资记录</response>
          /// <response code="404">未找到对应的工资记录</response>
          [HttpGet("query-by-employee")]
          public async Task<HealthCoachSalaryOutput> GetSalaryByEmployee([FromQuery] SalaryQueryByEmployeeInput input)
          {
              if (input.Year <= 0 || input.Month <= 0 || input.Month > 12)
              {
                  throw NCCException.Oh("年份和月份参数不正确");
              }
  
              if (string.IsNullOrWhiteSpace(input.EmployeeId))
              {
                  throw NCCException.Oh("员工ID不能为空");
              }
  
              var monthStr = $"{input.Year}{input.Month:D2}";
  
              var salary = await _db.Queryable<LqSalaryStatisticsEntity>()

                  .Where(x => x.StatisticsMonth == monthStr && x.EmployeeId == input.EmployeeId && x.IsLocked == 1 && x.EmployeeConfirmStatus != 1)

                  .Select(x => new HealthCoachSalaryOutput
                  {
                      Id = x.Id,
                      StoreId = x.StoreId,
                      StoreName = x.StoreName,
                      EmployeeId = x.EmployeeId,
                      EmployeeName = x.EmployeeName,
                      Position = x.Position,
                      GoldTriangleId = x.GoldTriangleId,
                      GoldTriangleTeam = x.GoldTriangleTeam,
                      TotalPerformance = x.TotalPerformance,
                      BasePerformance = x.BasePerformance,
                      CooperationPerformance = x.CooperationPerformance,
                      BaseRewardPerformance = x.BaseRewardPerformance,
                      CooperationRewardPerformance = x.CooperationRewardPerformance,
                      ActualBasePerformance = x.ActualBasePerformance,
                      ActualCooperationPerformance = x.ActualCooperationPerformance,
                      RewardPerformance = x.RewardPerformance,
                      StoreTotalPerformance = x.StoreTotalPerformance,
                      TeamPerformance = x.TeamPerformance,
                      Percentage = x.Percentage,
                      NewCustomerPerformance = x.NewCustomerPerformance,
                      NewCustomerConversionRate = x.NewCustomerConversionRate,
                      NewCustomerPoint = x.NewCustomerPoint,
                      UpgradeCustomerCount = x.UpgradeCustomerCount,
                      UpgradePerformance = x.UpgradePerformance,
                      UpgradePoint = x.UpgradePoint,
                      NewCustomerCommission = x.NewCustomerPerformanceCommission,
                      UpgradeCommission = x.UpgradePerformanceCommission,
                      OtherPerformanceAdd = x.OtherPerformanceAdd,
                      OtherPerformanceSubtract = x.OtherPerformanceSubtract,
                      Consumption = x.Consumption,
                      ProjectCount = x.ProjectCount,
                      CustomerCount = x.CustomerCount,
                      WorkingDays = x.WorkingDays,
                      LeaveDays = x.LeaveDays,
                      CommissionPoint = x.CommissionPoint,
                      BasePerformanceCommission = x.BasePerformanceCommission,
                      CooperationPerformanceCommission = x.CooperationPerformanceCommission,
                      ConsultantCommission = x.ConsultantCommission,
                      StoreTZoneCommission = x.StoreTZoneCommission,
                      TotalCommission = x.TotalCommission,
                      HealthCoachBaseSalary = x.HealthCoachBaseSalary,
                      HandworkFee = x.HandworkFee,
                      OutherHandworkFee = x.OutherHandworkFee,
                      TransportationAllowance = x.TransportationAllowance,
                      LessRest = x.LessRest,
                      FullAttendance = x.FullAttendance,
                      CalculatedGrossSalary = x.CalculatedGrossSalary,
                      GuaranteedSalary = x.GuaranteedSalary,
                      GuaranteedLeaveDeduction = x.GuaranteedLeaveDeduction,
                      GuaranteedBaseSalary = x.GuaranteedBaseSalary,
                      GuaranteedSupplement = x.GuaranteedSupplement,
                      FinalGrossSalary = x.FinalGrossSalary,
                      MonthlyTrainingSubsidy = x.MonthlyTrainingSubsidy,
                      MonthlyTransportSubsidy = x.MonthlyTransportSubsidy,
                      LastMonthTrainingSubsidy = x.LastMonthTrainingSubsidy,
                      LastMonthTransportSubsidy = x.LastMonthTransportSubsidy,
                      TotalSubsidy = x.TotalSubsidy,
                      MissingCard = x.MissingCard,
                      LateArrival = x.LateArrival,
                      LeaveDeduction = x.LeaveDeduction,
                      SocialInsuranceDeduction = x.SocialInsuranceDeduction,
                      RewardDeduction = x.RewardDeduction,
                      AccommodationDeduction = x.AccommodationDeduction,
                      StudyPeriodDeduction = x.StudyPeriodDeduction,
                      WorkClothesDeduction = x.WorkClothesDeduction,
                      TotalDeduction = x.TotalDeduction,
                      Bonus = x.Bonus,
                      ReturnPhoneDeposit = x.ReturnPhoneDeposit,
                      ReturnAccommodationDeposit = x.ReturnAccommodationDeposit,
                      ActualSalary = x.ActualSalary,
                      MonthlyPaymentStatus = x.MonthlyPaymentStatus,
                      PaidAmount = x.PaidAmount,
                      PendingAmount = x.PendingAmount,
                      LastMonthSupplement = x.LastMonthSupplement,
                      MonthlyTotalPayment = x.MonthlyTotalPayment,
                      StatisticsMonth = x.StatisticsMonth,
                      IsLocked = x.IsLocked,

                      EmployeeConfirmStatus = x.EmployeeConfirmStatus,

                      CreateTime = x.CreateTime,
                      CreateUser = x.CreateUser,
                      UpdateTime = x.UpdateTime,
                      UpdateUser = x.UpdateUser,
                      IsNewStore = x.IsNewStore,
                      NewStoreProtectionStage = x.NewStoreProtectionStage,
                      StoreType = x.StoreType,
                      StoreCategory = x.StoreCategory,
                      DailyAverageConsumption = x.DailyAverageConsumption,
                      DailyAverageProjectCount = x.DailyAverageProjectCount,
                      TeamTotalConsumption = x.TeamTotalConsumption
                  })
                  .FirstAsync();
  
              if (salary == null)
              {
                  throw NCCException.Oh($"未找到员工{input.EmployeeId}在{input.Year}年{input.Month}月的工资记录");
              }
  
              return salary;
          }
  
          #region 计算工资
  
          /// <summary>

          /// 计算健康师工资
          /// </summary>
          /// <param name="year">年份</param>
          /// <param name="month">月份</param>
          /// <returns></returns>
          [HttpPost("calculate/health-coach")]
          public async Task CalculateHealthCoachSalary(int year, int month)
          {
              var startDate = new DateTime(year, month, 1);
              var endDate = startDate.AddMonths(1).AddDays(-1);
              var monthStr = $"{year}{month:D2}";
  
              // 1. 获取基础数据
  
              // 1.1 业绩数据 (lq_kd_jksyj)
              var performanceList = await _db.Queryable<LqKdJksyjEntity>()
                  .Where(x => x.Yjsj >= startDate && x.Yjsj <= endDate.AddDays(1) && x.IsEffective == 1)
                  .ToListAsync();
  
              // 1.1.1 获取关联的开单记录(用于获取 sfskdd)
              var billingIds = performanceList.Select(x => x.Glkdbh).Distinct().ToList();
              var billingDict = await _db.Queryable<LqKdKdjlbEntity>()

                  .Where(x => billingIds.Contains(x.Id) && x.Id != null)

                  .ToDictionaryAsync(x => x.Id, x => x.Sfskdd);
  
              // 1.1.2 组合数据
              var performanceData = performanceList.Select(p => new
              {

                  Jks = p.Jkszh, // 使用 Jkszh (账号/ID) 而不是 Jks (姓名)

                  p.Jksxm,
                  p.StoreId,
                  p.Jksyj,
                  p.ItemCategory,

                  p.PerformanceType, // 新增业绩类型字段

                  Sfskdd = billingDict.ContainsKey(p.Glkdbh) ? billingDict[p.Glkdbh] : null
              }).ToList();
  
              // 1.2 消耗数据 (lq_xh_jksyj)
              var consumptionList = await _db.Queryable<LqXhJksyjEntity>()
                  .Where(x => x.Yjsj >= startDate && x.Yjsj <= endDate.AddDays(1) && x.IsEffective == 1)
                  .ToListAsync();
  
              // 1.3 考勤数据 (lq_attendance_summary)
              var attendanceList = await _db.Queryable<LqAttendanceSummaryEntity>()
                  .Where(x => x.Year == year && x.Month == month && x.IsEffective == 1)
                  .ToListAsync();
  

              // 1.3.1 退款数据 (lq_hytk_jksyj)
              var refundList = await _db.Queryable<LqHytkJksyjEntity>()
                  .Where(x => x.Tksj >= startDate && x.Tksj <= endDate.AddDays(1) && x.IsEffective == 1)
                  .ToListAsync();
  

              // 1.4 战队成员及顾问信息 (lq_jinsanjiao_user + lq_ycsd_jsj)
              var teamUserList = await _db.Queryable<LqJinsanjiaoUserEntity>()
                  .Where(x => x.Month == monthStr && x.DeleteMark == 0)
                  .ToListAsync();
  
              // 1.4.1 获取战队信息
              var teamIds = teamUserList.Select(x => x.JsjId).Distinct().ToList();
              var teamList = await _db.Queryable<LqYcsdJsjEntity>()
                  .Where(x => teamIds.Contains(x.Id))
                  .ToListAsync();

              var teamDict = teamList.Where(x => !string.IsNullOrEmpty(x.Id)).ToDictionary(x => x.Id, x => x.Jsj);

  
              // 1.4.2 组合数据
              var teamMembers = teamUserList.Select(user => new
              {
                  user.UserId,
                  user.IsLeader,
                  TeamId = user.JsjId,
                  TeamName = teamDict.ContainsKey(user.JsjId) ? teamDict[user.JsjId] : (string)null
              }).ToList();
  
              // 1.5 到店人头 (lq_person_times_record)
              // 统计每个健康师的去重会员数
              var headcountList = await _db.Queryable<LqPersonTimesRecordEntity>()
                  .Where(x => x.WorkMonth == monthStr && x.IsEffective == 1)
                  .GroupBy(x => x.PersonId)
                  .Select(x => new { PersonId = x.PersonId, Count = SqlFunc.AggregateDistinctCount(x.MemberId) })
                  .ToListAsync();
  
              // 1.6 门店生命线 (lq_md_target)
              var storeTargets = await _db.Queryable<LqMdTargetEntity>()
                  .Where(x => x.Month == monthStr)
                  .ToListAsync();
  

              // 1.6.1 门店总业绩计算 (开单实付 - 退款金额)
              // 开单实付
              var storeBillingList = await _db.Queryable<LqKdKdjlbEntity>()
                  .Where(x => x.Kdrq >= startDate && x.Kdrq <= endDate.AddDays(1) && x.IsEffective == 1)
                  .Select(x => new { x.Djmd, x.Sfyj })
                  .ToListAsync();
              var storeBillingDict = storeBillingList
                  .Where(x => !string.IsNullOrEmpty(x.Djmd))
                  .GroupBy(x => x.Djmd)
                  .ToDictionary(g => g.Key, g => g.Sum(x => x.Sfyj));
  
              // 退款金额
              var storeRefundList = await _db.Queryable<LqHytkHytkEntity>()
                  .Where(x => x.Tksj >= startDate && x.Tksj <= endDate.AddDays(1) && x.IsEffective == 1)

                  .Select(x => new { x.Mdbh, x.Tkje, x.ActualRefundAmount })

                  .ToListAsync();
              var storeRefundDict = storeRefundList
                  .Where(x => !string.IsNullOrEmpty(x.Mdbh))
                  .GroupBy(x => x.Mdbh)

                  .ToDictionary(g => g.Key, g => g.Sum(x => x.ActualRefundAmount ?? 0));

  
              // 1.7 门店信息 (lq_mdxx)
              var storeList = await _db.Queryable<LqMdxxEntity>().ToListAsync();
              var storeDict = storeList.Where(x => !string.IsNullOrEmpty(x.Id)).ToDictionary(x => x.Id, x => x);
  
              // 1.7.1 门店新店保护信息 (lq_md_xdbhsj)
              var newStoreProtectionList = await _db.Queryable<LqMdXdbhsjEntity>()
                  .Where(x => x.Sfqy == 1)
                  .ToListAsync();
  
              // 构造新店保护查找字典: StoreId -> List<ProtectionInfo>
              // 因为一个门店可能有多个阶段配置，虽然通常是一个时间段，但为了严谨取符合当前月份的配置
              // 逻辑: 统计月份 (startDate ~ endDate) 是否在 bhkssj ~ bhjssj 范围内
              // 只要统计月份与保护期有交集，就算保护期。或者严格一点，统计月份的第一天在保护期内。
              // 这里取: 统计月份的第一天 (startDate) 在保护期内
              var newStoreProtectionDict = newStoreProtectionList
                  .Where(x => x.Bhkssj <= startDate && x.Bhjssj >= startDate)
                  .GroupBy(x => x.Mdid)
                  .ToDictionary(g => g.Key, g => g.First()); // 取第一个匹配的配置
  
              // 1.8 健康师工资额外计算数据 (lq_salary_extra_calculation)
              var extraCalculationList = await _db.Queryable<LqSalaryExtraCalculationEntity>()
                  .Where(x => x.Year == year && x.Month == month)
                  .ToListAsync();
  
              var extraCalculationDict = extraCalculationList
                  .Where(x => !string.IsNullOrEmpty(x.EmployeeId))
                  .ToDictionary(x => x.EmployeeId, x => x);
  

              // 2. 聚合每个健康师的数据对象
              var employeeStats = new Dictionary<string, LqSalaryStatisticsEntity>();
  
              // 获取所有涉及的健康师ID
              var allEmployeeIds = performanceData.Select(x => x.Jks)
                  .Union(consumptionList.Select(x => x.Jks))
                  .Union(attendanceList.Select(x => x.UserId))
                  .Union(teamMembers.Select(x => x.UserId))
                  .Where(x => !string.IsNullOrEmpty(x))
                  .Distinct()
                  .ToList();
  

              // 1.8 批量获取员工信息 (BASE_USER + BASE_POSITION)
              // 使用 allEmployeeIds 作为驱动，查询 BASE_USER

              // 重要：只统计岗位为"健康师"的员工

              var userList = await _db.Queryable<UserEntity>()

                  .Where(x => allEmployeeIds.Contains(x.Id)
                      && x.Gw == "健康师"  // 只统计岗位为"健康师"的员工
                      && x.DeleteMark == null
                      && x.EnabledMark == 1)

                  .Select(x => new { x.Id, x.RealName, x.PositionId, x.Mdid })
                  .ToListAsync();
  

              // 过滤出健康师ID列表
              var healthCoachIds = userList.Select(x => x.Id).ToList();
  

              var userDict = userList.ToDictionary(x => x.Id, x => x);
  
              var positionIds = userList.Select(x => x.PositionId).Distinct().ToList();
              var positionList = await _db.Queryable<PositionEntity>().Where(x => positionIds.Contains(x.Id)).ToListAsync();
              var positionLookup = positionList.Where(x => !string.IsNullOrEmpty(x.Id)).ToDictionary(x => x.Id, x => x.FullName);
  

              // 只处理健康师员工
              foreach (var empId in allEmployeeIds.Where(x => healthCoachIds.Contains(x)))

              {
                  var salary = new LqSalaryStatisticsEntity
                  {
                      Id = YitIdHelper.NextId().ToString(),
                      EmployeeId = empId,
                      StatisticsMonth = monthStr,
                      CreateTime = DateTime.Now,
                      UpdateTime = DateTime.Now,
                      IsLocked = 0
                  };
  

                  // 填充基础信息 (优先从 BASE_USER 获取)
                  string userMdid = null;
                  if (userDict.ContainsKey(empId))
                  {
                      var user = userDict[empId];
                      salary.EmployeeName = user.RealName;
                      userMdid = user.Mdid;
  
                      // 岗位
                      if (user.PositionId != null && positionLookup.ContainsKey(user.PositionId))
                      {
                          salary.Position = positionLookup[user.PositionId];
                      }
                  }

                  // 如果 BASE_USER 没名字，尝试从业务表获取
                  if (string.IsNullOrEmpty(salary.EmployeeName))

                  {

                      var perfRecord = performanceData.FirstOrDefault(x => x.Jks == empId);
                      var consRecord = consumptionList.FirstOrDefault(x => x.Jks == empId);
                      if (perfRecord != null) salary.EmployeeName = perfRecord.Jksxm;
                      else if (consRecord != null) salary.EmployeeName = consRecord.Jksxm;

                  }

  
                  // 填充门店ID (从业务数据获取，因为 User 表的 OrganizeId 未必是门店)
                  var perfStore = performanceData.FirstOrDefault(x => x.Jks == empId && !string.IsNullOrEmpty(x.StoreId));
                  var consStore = consumptionList.FirstOrDefault(x => x.Jks == empId && !string.IsNullOrEmpty(x.StoreId));
  
                  if (perfStore != null) salary.StoreId = perfStore.StoreId;
                  else if (consStore != null) salary.StoreId = consStore.StoreId;
  
                  // 如果业务数据没门店，尝试使用 User.Mdid
                  if (string.IsNullOrEmpty(salary.StoreId) && !string.IsNullOrEmpty(userMdid))

                  {

                      if (storeDict.ContainsKey(userMdid))
                      {
                          salary.StoreId = userMdid;
                      }

                  }
  

                  // 填充门店名称及分类信息
                  if (!string.IsNullOrEmpty(salary.StoreId) && storeDict.ContainsKey(salary.StoreId))
                  {
                      var store = storeDict[salary.StoreId];
                      salary.StoreName = store.Dm;
                      salary.StoreType = store.StoreType;
                      salary.StoreCategory = store.StoreCategory;
                  }
  
                  // 填充新店保护信息
                  if (!string.IsNullOrEmpty(salary.StoreId) && newStoreProtectionDict.ContainsKey(salary.StoreId))
                  {
                      var protection = newStoreProtectionDict[salary.StoreId];
                      salary.IsNewStore = "是";
                      salary.NewStoreProtectionStage = protection.Stage;
                  }
                  else

                  {

                      salary.IsNewStore = "否";
                      salary.NewStoreProtectionStage = 0;

                  }
  
                  // 2.1 计算个人业绩
                  var myPerf = performanceData.Where(x => x.Jks == empId).ToList();

                  salary.BasePerformance = myPerf.Where(x => (x.PerformanceType ?? "").Trim() == "基础业绩").Sum(x => decimal.Parse(x.Jksyj ?? "0"));
                  salary.CooperationPerformance = myPerf.Where(x => (x.PerformanceType ?? "").Trim() == "合作业绩").Sum(x => decimal.Parse(x.Jksyj ?? "0"));

                  salary.TotalPerformance = myPerf.Sum(x => decimal.Parse(x.Jksyj ?? "0"));
  

                  // 扣除退款
                  var myRefunds = refundList.Where(x => x.Jks == empId).ToList();
                  if (myRefunds.Any())
                  {
                      decimal totalRefund = myRefunds.Sum(x => x.Jksyj ?? 0);
                      decimal baseRefund = myRefunds.Where(x => (x.PerformanceType ?? "").Trim() == "基础业绩").Sum(x => x.Jksyj ?? 0);
                      decimal cooperationRefund = myRefunds.Where(x => (x.PerformanceType ?? "").Trim() == "合作业绩").Sum(x => x.Jksyj ?? 0);
  
                      // 如果退款记录未标记类型，且总退款大于0，则可能需要处理（当前暂不处理未分类退款的明细扣除，仅扣除总额）
                      // 修正：如果PerformanceType为空，应当从总业绩扣除。若要从Base或Coop扣除，需确认业务规则。
                      // 假设：如果未分类，暂时不从Base/Coop扣（或者按比例扣？）。
                      // 根据现有数据，有部分是null。
                      // 安全起见，TotalPerformance 减去 totalRefund。
                      // Base 和 Coop 减去各自明确标识的部分。
  
                      salary.TotalPerformance -= totalRefund;
                      salary.BasePerformance -= baseRefund;
                      salary.CooperationPerformance -= cooperationRefund;
                  }
  

                  // 新客与升单业绩

                  salary.NewCustomerPerformance = myPerf.Where(x => string.Equals(x.Sfskdd, "是")).Sum(x => decimal.Parse(x.Jksyj ?? "0"));
                  salary.UpgradePerformance = myPerf.Where(x => string.Equals(x.Sfskdd, "否")).Sum(x => decimal.Parse(x.Jksyj ?? "0"));

                  // 2.1.1 填充额外计算数据
                  if (extraCalculationDict.ContainsKey(empId))
                  {
                      var extraData = extraCalculationDict[empId];
                      salary.BaseRewardPerformance = extraData.BaseRewardPerformance;
                      salary.CooperationRewardPerformance = extraData.CooperationRewardPerformance;
                      salary.OtherPerformanceAdd = extraData.OtherPerformanceAdd;
                      salary.OtherPerformanceSubtract = extraData.OtherPerformanceSubtract;
                      salary.UpgradeCustomerCount = extraData.UpgradeCustomerCount;
                      salary.NewCustomerConversionRate = extraData.NewCustomerConversionRate;

                      salary.NewCustomerPerformance = extraData.NewCustomerPerformance;
                      salary.UpgradePerformance = extraData.UpgradePerformance;

  
                      // 调整总业绩：总业绩 = 基础业绩 + 合作业绩 + 基础奖励业绩 - 合作奖励业绩 + 其他业绩加 - 其他业绩减
                      // 注意：合作奖励业绩是"负奖励"概念，正数表示减少，负数表示增加

                      // 确保后续计算（包括金三角战队业绩）使用的是调整后的总业绩

                      salary.TotalPerformance += salary.BaseRewardPerformance;
                      salary.TotalPerformance -= salary.CooperationRewardPerformance; // 合作奖励业绩是负奖励，需要减去

                      salary.TotalPerformance += salary.OtherPerformanceAdd;
                      salary.TotalPerformance -= salary.OtherPerformanceSubtract;

                  }
  
                  // 2.1.2 计算实际基础业绩和实际合作业绩
                  // 定义新店相关变量，供后续多处使用
                  bool isNewStore = salary.IsNewStore == "是";
                  int newStoreStage = salary.NewStoreProtectionStage;
  
                  // 实际基础业绩 = 基础业绩 - 基础奖励业绩 + 其他业绩加 - 其他业绩减
                  decimal actualBasePerformance = salary.BasePerformance
                      - salary.BaseRewardPerformance
                      + salary.OtherPerformanceAdd
                      - salary.OtherPerformanceSubtract;
  
                  // 新店额外调整：根据阶段扣除新客业绩或升单业绩
                  if (isNewStore)
                  {
                      if (newStoreStage == 1)
                      {
                          // 第一阶段：扣除新客业绩
                          actualBasePerformance -= salary.NewCustomerPerformance;
                      }
                      else if (newStoreStage == 2)
                      {
                          // 第二阶段：扣除升单业绩
                          actualBasePerformance -= salary.UpgradePerformance;
                      }
                  }
  
                  salary.ActualBasePerformance = actualBasePerformance;
  
                  // 实际合作业绩 = 合作业绩 - 合作奖励业绩

                  // 注意：合作奖励业绩是"负奖励"概念，正数表示减少，负数表示增加
                  // 例如：40000 表示减少合作业绩 40000，-20000 表示增加合作业绩 20000

                  salary.ActualCooperationPerformance = salary.CooperationPerformance - salary.CooperationRewardPerformance;
  

                  // 2.2 计算消耗和项目数
                  var myCons = consumptionList.Where(x => x.Jks == empId).ToList();
                  salary.Consumption = myCons.Sum(x => x.Jksyj ?? 0);
                  salary.ProjectCount = myCons.Sum(x => x.KdpxNumber ?? 0);
                  salary.HandworkFee = myCons.Sum(x => x.LaborCost ?? 0); // 使用 F_LaborCost
  
                  // 2.3 考勤数据
                  var myAtt = attendanceList.FirstOrDefault(x => x.UserId == empId);
                  salary.WorkingDays = myAtt?.WorkDays ?? 0;
                  salary.LeaveDays = myAtt?.LeaveDays ?? 0;
  

                  // 计算日均消耗和日均项目数 (用于底薪计算)
                  // 逻辑: 总消耗/在店天数, 总项目数/在店天数
                  if (salary.WorkingDays > 0)
                  {
                      salary.DailyAverageConsumption = salary.Consumption / salary.WorkingDays;
                      salary.DailyAverageProjectCount = salary.ProjectCount / salary.WorkingDays;
                  }
                  else
                  {
                      salary.DailyAverageConsumption = 0;
                      salary.DailyAverageProjectCount = 0;
                  }
  

                  // 2.4 到店人头
                  var myHeadcount = headcountList.FirstOrDefault(x => x.PersonId == empId);
                  salary.CustomerCount = myHeadcount?.Count ?? 0;
  
                  // 2.5 战队信息 (初始)
                  var myTeam = teamMembers.FirstOrDefault(x => x.UserId == empId);

                  // 初始判断岗位：如果是战队队长(IsLeader=1)则是顾问，否则是健康师
                  // 注意：这里先根据战队设置判断，后续考勤不足21天会降级
                  if (myTeam != null && myTeam.IsLeader == 1)
                  {
                      salary.Position = "顾问";
                  }
                  else if (string.IsNullOrEmpty(salary.Position)) // 如果BASE_USER没岗位，且不是队长，默认为健康师
                  {
                      salary.Position = "健康师";
                  }
  

                  if (myTeam != null)
                  {
                      salary.GoldTriangleId = myTeam.TeamId;

                      salary.GoldTriangleTeam = myTeam.TeamName ?? "个人";
                  }
                  else
                  {
                      salary.GoldTriangleTeam = "个人";
                  }
  
                  // 2.6 门店总业绩
                  if (!string.IsNullOrEmpty(salary.StoreId))
                  {
                      decimal billing = storeBillingDict.ContainsKey(salary.StoreId) ? storeBillingDict[salary.StoreId] : 0;
                      decimal refund = storeRefundDict.ContainsKey(salary.StoreId) ? storeRefundDict[salary.StoreId] : 0;
                      salary.StoreTotalPerformance = billing - refund;

                  }
  
                  employeeStats[empId] = salary;
              }
  
              // 3. 处理战队逻辑 (考勤规则)

              // 规则：若出勤天数 < 20天，则该健康师不计入战队，按单人计算。

  
              // 按战队分组
              var teamGroups = employeeStats.Values
                  .Where(x => !string.IsNullOrEmpty(x.GoldTriangleId))
                  .GroupBy(x => x.GoldTriangleId)
                  .ToList();
  
              foreach (var group in teamGroups)
              {
                  var validMembers = new List<LqSalaryStatisticsEntity>();
                  var invalidMembers = new List<LqSalaryStatisticsEntity>();
  
                  foreach (var member in group)
                  {

                      if (member.WorkingDays >= 20)

                      {
                          validMembers.Add(member);
                      }
                      else
                      {
                          invalidMembers.Add(member);
                      }
                  }
  

                  // 对于无效成员，移除战队标识，视为单人，并重置岗位为健康师

                  foreach (var member in invalidMembers)
                  {
                      member.GoldTriangleId = null;

                      member.GoldTriangleTeam = "个人";
                      member.Position = "健康师"; // 降级为健康师

                  }
  

                  // 计算有效战队的总业绩和总消耗

                  var teamTotalPerformance = validMembers.Sum(x => x.TotalPerformance);

                  var teamTotalConsumption = validMembers.Sum(x => x.Consumption);

                  // 更新有效成员的战队业绩和战队总消耗

                  foreach (var member in validMembers)
                  {
                      member.TeamPerformance = teamTotalPerformance;

                      member.TeamTotalConsumption = teamTotalConsumption;

                  }
              }
  

              // 补充处理：对于没有战队ID的（个人，或被剔除的），战队业绩等于个人总业绩
              foreach (var salary in employeeStats.Values)
              {
                  if (string.IsNullOrEmpty(salary.GoldTriangleId))
                  {
                      salary.TeamPerformance = salary.TotalPerformance;
                  }
              }
  

              // 4. 计算薪资 (底薪 & 提成)
              foreach (var salary in employeeStats.Values)
              {

                  // 定义新店相关变量，供底薪和提成计算使用
                  bool isNewStore = salary.IsNewStore == "是";
                  int newStoreStage = salary.NewStoreProtectionStage;
  

                  // 4.1 底薪计算

                  // 4.1 底薪计算
                  // 传入当月天数用于计算标准日均
                  int daysInMonth = DateTime.DaysInMonth(year, month);
                  salary.HealthCoachBaseSalary = CalculateBaseSalary(
                      salary.DailyAverageConsumption,
                      salary.DailyAverageProjectCount,
                      daysInMonth,

                      salary.WorkingDays,

                      isNewStore);

  
                  // 4.2 提成计算

                  // 业绩门槛: 战队成员个人总业绩 <= 6000 无提成 (需按日均计算)
                  // 规则：战队成员日均业绩 <= 6000 / 当月天数 -> 无提成
                  decimal memberThreshold = 6000m;
                  if (daysInMonth > 0 && salary.WorkingDays > 0)
                  {
                      memberThreshold = (6000m / daysInMonth) * salary.WorkingDays;
                  }
  
                  if (!string.IsNullOrEmpty(salary.GoldTriangleId) && salary.TotalPerformance < memberThreshold) // 修正为小于校验

                  {
                      salary.TotalCommission = 0;
                      salary.BasePerformanceCommission = 0;
                      salary.CooperationPerformanceCommission = 0;
                      salary.ConsultantCommission = 0;

                      salary.NewCustomerPerformanceCommission = 0;
                      salary.UpgradePerformanceCommission = 0;

                  }
                  else
                  {
                      // 确定提成点
                      decimal commissionPoint = 0;
  
                      if (!string.IsNullOrEmpty(salary.GoldTriangleId))
                      {
                          // 是战队成员
                          // 获取战队人数 (注意：这里应该是有效战队人数)
                          var teamMemberCount = employeeStats.Values.Count(x => x.GoldTriangleId == salary.GoldTriangleId);

                          // 注意：提成点按原始基础业绩计算，不是实际基础业绩

                          // 战队成员不按日均考核提成点，只考核个人门槛
                          commissionPoint = GetTeamCommissionPoint(teamMemberCount, salary.TeamPerformance, daysInMonth, salary.WorkingDays);

                      }
                      else
                      {
                          // 单人 (或被剔除出战队)

                          // 注意：提成点按原始总业绩计算

                          // 单人按日均考核提成点
                          commissionPoint = GetTeamCommissionPoint(1, salary.TotalPerformance, daysInMonth, salary.WorkingDays);