KPI / fw-morax

  package cn.fw.morax.service.biz.salary;
  

  import cn.fw.common.data.mybatis.pagination.PageData;

  import cn.fw.common.page.AppPage;

  import cn.fw.common.web.auth.LoginAuthBean;

  import cn.fw.morax.common.constant.Constant;

  import cn.fw.morax.common.utils.PublicUtil;

  import cn.fw.morax.common.utils.StringUtils;

  import cn.fw.morax.common.utils.ThreadPoolUtil;

  import cn.fw.morax.domain.db.kpi.*;

  import cn.fw.morax.domain.db.salary.*;

  import cn.fw.morax.domain.dto.query.PaySalaryQueryDTO;

  import cn.fw.morax.domain.dto.query.SalaryPoolQueryDTO;

  import cn.fw.morax.domain.enums.*;

  import cn.fw.morax.domain.vo.SelectorVO;

  import cn.fw.morax.domain.vo.salary.*;

  import cn.fw.morax.rpc.erp.ErpRpcService;

  import cn.fw.morax.service.biz.CommonService;

  import cn.fw.morax.service.data.kpi.IndicatorUserValueService;

  import cn.fw.morax.service.data.salary.*;

  import com.alibaba.fastjson.JSON;

  import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  import com.baomidou.mybatisplus.core.toolkit.Wrappers;

  import com.google.common.collect.Lists;

  import lombok.Getter;

  import lombok.RequiredArgsConstructor;
  import lombok.extern.slf4j.Slf4j;

  import org.springframework.beans.factory.annotation.Value;

  import org.springframework.cache.annotation.Cacheable;

  import org.springframework.stereotype.Service;

  import javax.servlet.http.HttpServletRequest;

  import javax.servlet.http.HttpServletResponse;
  import java.math.BigDecimal;

  import java.time.LocalDate;

  import java.time.YearMonth;

  import java.time.temporal.TemporalAdjusters;

  import java.util.*;

  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.ThreadPoolExecutor;

  import java.util.function.Function;

  import java.util.stream.Collectors;
  
  import static cn.fw.common.businessvalidator.Validator.BV;
  

  /**
   * @author : kurisu
   * @version : 1.0
   * @className : SalaryPoolBizService
   * @description : 薪酬池业务service
   * @date : 2022-05-05 11:10
   */
  @Service
  @Slf4j
  @RequiredArgsConstructor
  public class SalaryPoolBizService {

      private final SalaryGroupProjectSettinService salaryGroupProjectSettinService;

      private final SalaryGroupProjectService salaryGroupProjectService;

      private final SalaryGeneralSettinService salaryGeneralSettinService;

      private final SalaryGroupProjectHitLogService salaryGroupProjectHitLogService;

      private final SalaryPoolDetailService salaryPoolDetailService;

      private final SalaryGroupProjectPreconditionService salaryGroupProjectPreconditionService;
      private final SalaryGroupProjectParamService salaryGroupProjectParamService;
      private final SalaryGroupProjectTargetHitLogService salaryGroupProjectTargetHitLogService;
      private final IndicatorUserValueService indicatorUserValueService;

      private final SalaryGroupUserService salaryGroupUserService;

      private final SalaryPoolService salaryPoolService;

      private final CommonService commonService;

      private final ErpRpcService erpRpcService;

      @Value("${special-indicator-code.work-age}")
      @Getter
      private String workAgeCode;
      @Value("${special-indicator-code.base-salary}")
      @Getter
      private String baseSalaryCode;
  

      /**
       * 查询薪酬池
       *

       * @param queryDTO 查询条件
       * @return 薪酬池列表
       */
      public AppPage<SalaryPoolVO> queryPool(final SalaryPoolQueryDTO queryDTO) {

          SalaryGeneralSettin settin = salaryGeneralSettinService.getOne(Wrappers.<SalaryGeneralSettin>lambdaQuery()
                          .eq(SalaryGeneralSettin::getGroupId, queryDTO.getGroupId())
                          .eq(SalaryGeneralSettin::getYn, Boolean.TRUE)
                  , Boolean.FALSE);
          if (Objects.nonNull(settin)) {
              Boolean leaderVisibility = settin.getLeaderVisibility();
              BV.isTrue(leaderVisibility, () -> "本集团不允许管理层查看员工薪资， 请联系集团管理员开通");
          }

          if (PublicUtil.isNotEmpty(queryDTO.getManagerUserId())) {
              queryDTO.setManagerStaffList(commonService.queryManageStaffIds(queryDTO.getManagerUserId(), queryDTO.getMonthly()));
          } else {
              queryDTO.setManagerStaffList(commonService.queryManageStaffIds(queryDTO.getCurrentUserId(), queryDTO.getMonthly()));
          }

          prepareParams(queryDTO);

          log.info("薪酬池查询参数：{}", JSON.toJSONString(queryDTO));

          AppPage<SalaryPoolVO> page = AppPage.empty(queryDTO);
          long total = salaryPoolService.queryPagePoolTotal(queryDTO);
          if (total > 0) {
              page.setTotal(total);
              List<SalaryPoolVO> salaryPoolList = salaryPoolService.queryPagePool(queryDTO);
              page.setData(salaryPoolList);
          }
          return page;
      }
  
      /**
       * 查询薪酬池详情
       *
       * @param poolId 薪酬池id
       * @return 薪酬池详情
       */

      public StaffSalaryVO queryPoolDetail(final Long poolId, final YearMonth yearMonth) {

          SalaryPool pool = salaryPoolService.getById(poolId);
          boolean flag = Objects.nonNull(pool) && Boolean.TRUE.equals(pool.getYn());
          BV.isTrue(flag, () -> "该人员薪酬数据不存在");

          if (PublicUtil.isNotEmpty(yearMonth) && (!yearMonth.equals(pool.getMonthly()))) {

              List<SalaryPool> list = userSalaryPool(pool.getUserId(), yearMonth);
              BV.isNotEmpty(list, () -> "人员薪酬数据不存在");
              pool = list.get(0);
          }

          return getPoolDetail(pool);
      }
  
      /**
       * 查询薪酬池详情
       *
       * @param userId    用户id
       * @param yearMonth 月度
       * @return 薪酬池详情
       */

      public StaffSalaryVO queryUserPoolDetail(final Long userId, final YearMonth yearMonth) {

          List<SalaryPool> list = userSalaryPool(userId, yearMonth);
          BV.isNotEmpty(list, () -> "人员薪酬数据不存在");
          SalaryPool salaryPool = list.get(0);
          return getPoolDetail(salaryPool);
      }
  
      /**
       * 查询薪酬池选项
       *
       * @param userId    用户id
       * @param yearMonth 月度
       * @return 薪酬池选项

       */

      public Set<SelectorVO> salaryPoolSelector(final Long userId, final YearMonth yearMonth) {
          List<SalaryPool> list = userSalaryPool(userId, yearMonth);
          if (CollectionUtils.isEmpty(list)) {
              return new HashSet<>();
          }
          return list.stream().map(r -> SelectorVO.whit(r.getId(), r.getShopName(), r.getPostName())).collect(Collectors.toSet());

      }

  
      /**
       * 查询用户月度薪酬池列表
       *
       * @param userId    用户id
       * @param yearMonth 月度
       * @return 返回结果
       */
      @Cacheable(cacheNames = "salary", key = "':user:pool:'+ #yearMonth.toString() +':'+ #userId", unless = "#result.size() < 1")
      public List<SalaryPool> userSalaryPool(final Long userId, final YearMonth yearMonth) {
          List<SalaryPool> list = salaryPoolService.list(Wrappers.<SalaryPool>lambdaQuery()
                  .eq(SalaryPool::getUserId, userId)
                  .eq(SalaryPool::getMonthly, yearMonth)
                  .eq(SalaryPool::getYn, Boolean.TRUE)
                  .orderByDesc(SalaryPool::getId)
          );
          if (CollectionUtils.isEmpty(list)) {
              return new ArrayList<>();
          }
          return list;
      }
  
      /**
       * 查询详情
       *
       * @param pool 薪酬池
       * @return 详情
       */

      private StaffSalaryVO getPoolDetail(SalaryPool pool) {

          StaffSalaryVO vo = this.convertToSalaryVO(pool);

          buildPoolData(pool, vo);

          LocalDate dataDate = LocalDate.from(vo.getEndTime());

          List<SalaryPoolDetailVO> salaryDetailList = salaryPoolDetailService.queryByPoolId(pool.getId(), pool.getSalaryGroupId(), dataDate);
          BV.isNotEmpty(salaryDetailList, () -> "该人员薪酬数据不存在");

          Map<SalaryTypeEnum, List<SalaryPoolDetailVO>> salaryTypeMap = salaryDetailList.stream().collect(Collectors.groupingBy(SalaryPoolDetailVO::getType));
          for (Map.Entry<SalaryTypeEnum, List<SalaryPoolDetailVO>> salaryDetail : salaryTypeMap.entrySet()) {
              detailClassification(vo, salaryDetail.getKey(), salaryDetail.getValue());

          }

          Collections.sort(vo.getIncome());
          Collections.sort(vo.getDeduct());

          return vo;
      }
  

      /**

       * 查询薪酬开始日期，结束日期
       *
       * @param salaryPool
       * @return
       */
      public void buildPoolData(SalaryPool salaryPool, StaffSalaryVO vo) {
          SalaryGroupUser salaryGroupUser = salaryGroupUserService.getMonthLastData(salaryPool.getSgc(),
                  salaryPool.getUserId(), salaryPool.getMonthly());
          if (PublicUtil.isEmpty(salaryGroupUser)) {
              log.error("员工薪酬池：{}，不存在绩效组人员数据", JSON.toJSONString(salaryPool));

              vo.setEndTime(PublicUtil.getYesterdayOrEndOfMonthDay(salaryPool.getMonthly()).atTime(23, 59, 59));
              vo.setStartTime(salaryPool.getMonthly().atDay(1).atTime(00, 00, 00));

              return;
          }

          vo.setEndTime(salaryGroupUser.getDataDate().atTime(23, 59, 59));

          SalaryGroupUser firstSalaryGroupUser = salaryGroupUserService.getMonthFirstData(salaryPool.getSgc(),
                  salaryPool.getUserId(), salaryPool.getMonthly());

          vo.setStartTime(firstSalaryGroupUser.getDataDate().atTime(00, 00, 00));

      }
  
      /**
       * 查询薪酬结束日期

       *
       * @param salaryPool
       * @return
       */
      public LocalDate getPoolLastData(SalaryPool salaryPool) {
          SalaryGroupUser salaryGroupUser = salaryGroupUserService.getMonthLastData(salaryPool.getSgc(),
                  salaryPool.getUserId(), salaryPool.getMonthly());
          if (PublicUtil.isEmpty(salaryGroupUser)) {
              log.error("员工薪酬池：{}，不存在绩效组人员数据", JSON.toJSONString(salaryPool));
              return PublicUtil.getYesterdayOrEndOfMonthDay(salaryPool.getMonthly());
          }
          return salaryGroupUser.getDataDate();
      }
  
      /**

       * 详情分类
       *
       * @param vo
       * @param type
       * @param list
       */

      private void detailClassification(StaffSalaryVO vo, SalaryTypeEnum type, List<SalaryPoolDetailVO> list) {

          if (CollectionUtils.isEmpty(list)) {

              return;
          }

          summarySalaryRewards(vo, type, list);

          BigDecimal income = BigDecimal.ZERO;

          BigDecimal salaryTypeAmount = BigDecimal.ZERO;

          if (type.isPlus()) {

              List<IncomeProjectVO> incomes = Lists.newArrayList();

              for (SalaryPoolDetailVO detail : list) {

                  income = income.add(detail.getActualSalaryAmount());

                  salaryTypeAmount = salaryTypeAmount.add(detail.getSalaryAmount());

                  IncomeProjectVO incomeProjectVO = this.convertToIncomeVO(detail);
                  incomeProjectVO.setBaseWage(this.checkIsBaseWage(detail.getSalaryGroupProjectId()));
                  incomes.add(incomeProjectVO);

              }

              vo.getIncome().add(new IncomeVO(type, salaryTypeAmount, incomes));

          } else {
              List<DeductProjectVO> deducts = Lists.newArrayList();
              for (SalaryPoolDetailVO detail : list) {

                  salaryTypeAmount = salaryTypeAmount.add(detail.getSalaryAmount());

                  deducts.add(this.convertToDeductVO(detail));

              }

              vo.getDeduct().add(new DeductVO(type, salaryTypeAmount, deducts));

          }

          vo.setTotalWages(vo.getTotalWages().add(income));

      }
  
  

      /**
       * 准备分页参数
       *
       * @param queryVO
       */

      private void prepareParams(SalaryPoolQueryDTO queryVO) {
          if (Objects.isNull(queryVO.getMonthly())) {
              queryVO.setMonthly(YearMonth.now());
          }
          if (Objects.nonNull(queryVO.getOrder()) && StringUtils.isValid(queryVO.getOrderAtt())) {
              StringBuilder sb = new StringBuilder(" order by ");
              sb.append(StringUtils.toColumnName(queryVO.getOrderAtt()).toLowerCase());
              if (queryVO.getOrder() == 1) {
                  sb.append(" asc ");
              } else {
                  sb.append(" desc ");
              }
              queryVO.setOrderString(sb.toString());
          }

          if (PublicUtil.isEmpty(queryVO.getQueryStaffs()) && PublicUtil.isNotEmpty(queryVO.getQueryStaffs())) {

              List<Long> queryStaffIds = Arrays.stream(queryVO.getQueryStaffs().split(",")).map(Long::parseLong).collect(Collectors.toList());
              queryVO.getManagerStaffList().retainAll(queryStaffIds);
          }

      }
  

      /**
       * 获取员工薪酬
       *
       * @param staffIds
       * @param shopIds
       * @param yearMonth
       * @return
       */

      public List<StaffSalaryDetailVO> getStaffsSalary(List<Long> staffIds, List<Long> shopIds, YearMonth yearMonth) {

          List<SalaryPool> pools = salaryPoolService.list(Wrappers.<SalaryPool>lambdaQuery()

                  .in(PublicUtil.isNotEmpty(staffIds), SalaryPool::getUserId, staffIds)

                  .in(PublicUtil.isNotEmpty(shopIds), SalaryPool::getShopId, shopIds)
                  .eq(SalaryPool::getMonthly, yearMonth)
                  .eq(SalaryPool::getYn, Boolean.TRUE)
          );
          if (PublicUtil.isEmpty(pools)) {
              return new ArrayList<>();
          }

          List<StaffSalaryDetailVO> staffSalaryVos = Lists.newArrayListWithCapacity(pools.size());

          List<Long> poolIds = pools.stream().map(SalaryPool::getId).collect(Collectors.toList());
          List<SalaryPoolDetail> poolDetails = salaryPoolDetailService.list(Wrappers.<SalaryPoolDetail>lambdaQuery()
                  .in(SalaryPoolDetail::getSalaryPoolId, poolIds)
                  .eq(SalaryPoolDetail::getYn, Boolean.TRUE)
          );
          Map<Long, List<SalaryPoolDetail>> poolDetailMap = poolDetails.stream().collect(Collectors.groupingBy(SalaryPoolDetail::getSalaryPoolId));

          StaffSalaryDetailVO staffSalaryVo = null;

          for (SalaryPool salaryPool : pools) {

              staffSalaryVo = this.convertVo(salaryPool, poolDetailMap);

              staffSalaryVos.add(staffSalaryVo);
          }
          return staffSalaryVos;
      }
  
      /**

       * 汇总数据
       *
       * @param vo
       * @param type
       * @param list
       */
      private void summarySalaryRewards(StaffSalaryVO vo, SalaryTypeEnum type, List<SalaryPoolDetailVO> list) {
  
          switch (type) {

              case NECESSARY: {

                  BigDecimal socialSecurity = list.stream()
                          .map(SalaryPoolDetailVO::getActualSalaryAmount)
                          .reduce(BigDecimal.ZERO, BigDecimal::add);
                  vo.setSocialSecurity(socialSecurity);
                  break;
              }

              case AWARD: {

                  BigDecimal paidRewards = list.stream()
                          .map(SalaryPoolDetailVO::getProcessedAmount)
                          .reduce(BigDecimal.ZERO, BigDecimal::add);
                  vo.setPaidRewards(paidRewards);
                  break;
              }

              case PENALTY: {

                  BigDecimal paidRewards = list.stream()

                          .map(detail -> {
                              return detail.getActualSalaryAmount().subtract(detail.getProcessedAmount());
                          })

                          .reduce(BigDecimal.ZERO, BigDecimal::add);
                  vo.setNoPaidPunishRewards(paidRewards);
                  break;
              }
  
  
          }
      }
  
      /**

       * 转换为收入对象
       *
       * @param detail
       * @return
       */
      private IncomeProjectVO convertToIncomeVO(SalaryPoolDetailVO detail) {
          IncomeProjectVO incomeProjectVO = new IncomeProjectVO();

          if (PublicUtil.isNotEmpty(detail.getSalaryGroupProjectId())) {
              incomeProjectVO.setSalaryGroupProjectId(detail.getSalaryGroupProjectId());
              incomeProjectVO.setSalaryGroupProjectName(detail.getSalaryGroupProjectName());

          }

          incomeProjectVO.setSalaryType(detail.getType());

          incomeProjectVO.setCalMethod(detail.getCalMethod());

          incomeProjectVO.setTotalAmount(detail.getSalaryAmount());

          incomeProjectVO.setSendAmount(detail.getProcessedAmount());
          incomeProjectVO.setNoSendAmount(detail.getActualSalaryAmount());

          return incomeProjectVO;
      }
  
      /**
       * 转换为支出对象
       *
       * @param detail
       * @return
       */
      private DeductProjectVO convertToDeductVO(SalaryPoolDetailVO detail) {
          DeductProjectVO deductProjectVO = new DeductProjectVO();

          if (PublicUtil.isNotEmpty(detail.getSalaryGroupProjectId())) {
              deductProjectVO.setSalaryGroupProjectId(detail.getSalaryGroupProjectId());
              deductProjectVO.setSalaryGroupProjectName(detail.getSalaryGroupProjectName());

          }

          deductProjectVO.setSalaryType(detail.getType());

          deductProjectVO.setCalMethod(detail.getCalMethod());

          deductProjectVO.setTotalAmount(detail.getSalaryAmount());
          deductProjectVO.setPaidAmount(detail.getProcessedAmount());

          deductProjectVO.setNoPaidAmount(detail.getActualSalaryAmount());

          return deductProjectVO;
      }
  
      /**
       * 转换为员工薪酬vo
       *
       * @param pool
       * @return
       */
      private StaffSalaryVO convertToSalaryVO(SalaryPool pool) {
          StaffSalaryVO vo = new StaffSalaryVO();
          vo.setSalaryPoolId(pool.getId());
          vo.setUserId(pool.getUserId());
          vo.setUserName(pool.getUserName());
          vo.setMonthly(pool.getMonthly());
          vo.setPostId(pool.getPostId());
          vo.setPostName(pool.getPostName());
          vo.setShopId(pool.getShopId());
          vo.setShopName(pool.getShopName());
          vo.setWages(pool.getReward());
          vo.setStarLevel(pool.getStarLevel());

  
          vo.setTotalWages(BigDecimal.ZERO);
          vo.setIncome(new LinkedList<>());
          vo.setDeduct(new LinkedList<>());

          return vo;
      }
  
      /**

       * 转换为vo
       *
       * @param salaryPool
       * @param poolDetailMap
       * @return
       */

      private StaffSalaryDetailVO convertVo(SalaryPool salaryPool, Map<Long, List<SalaryPoolDetail>> poolDetailMap) {

          Long userId = salaryPool.getUserId();

          Long poolId = salaryPool.getId();

          StaffSalaryDetailVO staffSalaryVo = new StaffSalaryDetailVO();

          staffSalaryVo.setId(salaryPool.getId());
          staffSalaryVo.setSalaryGroupId(salaryPool.getSalaryGroupId());
          staffSalaryVo.setUserId(userId);
          staffSalaryVo.setUserName(salaryPool.getUserName());
          staffSalaryVo.setPostId(salaryPool.getPostId());
          staffSalaryVo.setPostName(salaryPool.getPostName());
          staffSalaryVo.setShopId(salaryPool.getShopId());
          staffSalaryVo.setShopName(salaryPool.getShopName());
          staffSalaryVo.setStarLevel(salaryPool.getStarLevel());
          staffSalaryVo.setWages(salaryPool.getReward());
          staffSalaryVo.setMonthly(salaryPool.getMonthly());

          staffSalaryVo.setMonthlyStr(salaryPool.getMonthly().toString());
  
          staffSalaryVo.setAward(BigDecimal.ZERO);
          staffSalaryVo.setRoyalties(BigDecimal.ZERO);
          staffSalaryVo.setSubsidy(BigDecimal.ZERO);
          staffSalaryVo.setNecessary(BigDecimal.ZERO);
          staffSalaryVo.setPenalty(BigDecimal.ZERO);

          if (!poolDetailMap.containsKey(poolId)) {

              return staffSalaryVo;
          }

          List<SalaryPoolDetail> staffSalaryDetails = poolDetailMap.get(poolId);

          for (SalaryPoolDetail salaryDetail : staffSalaryDetails) {
              BigDecimal amount = salaryDetail.getSalaryAmount();
              switch (salaryDetail.getType()) {
                  case AWARD: {

                      staffSalaryVo.setAward(staffSalaryVo.getAward().add(amount));

                      break;
                  }
                  case ROYALTIES: {

                      staffSalaryVo.setRoyalties(staffSalaryVo.getRoyalties().add(amount));

                      break;
                  }
                  case SUBSIDY: {

                      staffSalaryVo.setSubsidy(staffSalaryVo.getSubsidy().add(amount));

                      break;
                  }
                  case NECESSARY: {

                      staffSalaryVo.setNecessary(staffSalaryVo.getNecessary().add(amount));

                      break;
                  }
                  case PENALTY: {

                      staffSalaryVo.setPenalty(staffSalaryVo.getPenalty().add(amount));

                      break;
                  }
              }
          }
          return staffSalaryVo;
      }
  
      /**

       * 下载员工excel文件
       *

       * @param currentUser
       * @param yearMonth
       * @param request

       * @param response
       */

      public void downloadStaffsSalary(LoginAuthBean currentUser, YearMonth yearMonth, HttpServletRequest request, HttpServletResponse response) {
          BV.isTrue(erpRpcService.hasRole(currentUser.getUserId(), Constant.ROLE_CODE_WAGE_PAYMENT), "员工没有工资发放角色");
          List<Long> shopIds = erpRpcService.queryUserRoleShopIds(currentUser.getUserId(), Constant.ROLE_CODE_WAGE_PAYMENT);
          List<StaffSalaryDetailVO> staffSalaryDetailVOS = this.getStaffsSalary(null, shopIds, yearMonth);

          String fileName = "工资清单.xlsx";

          String encodeFileName = CommonService.getEncodeName(request, fileName);

          CommonService.downloadExcel(response, staffSalaryDetailVOS, encodeFileName, StaffSalaryDetailVO.class);

      }
  

      /**

       * 查询员工工资
       *

       * @param dto

       * @return
       */

      public AppPage<StaffSalaryInfoVO> getStaffsWages(PaySalaryQueryDTO dto) {

          if (!erpRpcService.hasRole(dto.getUserId(), Constant.ROLE_CODE_WAGE_PAYMENT)) {

              return new AppPage<>();
          }
  //        BV.isTrue(erpRpcService.hasRole(dto.getUserId(), Constant.ROLE_CODE_WAGE_PAYMENT), "员工没有工资发放角色");

          List<Long> shopIds = erpRpcService.queryUserRoleShopIds(dto.getUserId(), Constant.ROLE_CODE_WAGE_PAYMENT);

          if (PublicUtil.isEmpty(shopIds)) {

              return new AppPage<>();

          }

          PageData<SalaryPool> pageData = salaryPoolService.page(new PageData<>(dto.getCurrent(), dto.getPageSize()),
                  Wrappers.<SalaryPool>lambdaQuery()
                          .in(PublicUtil.isNotEmpty(shopIds), SalaryPool::getShopId, shopIds)
                          .eq(SalaryPool::getMonthly, dto.getYearMonth())
                          .eq(SalaryPool::getYn, Boolean.TRUE)
          );
          return PublicUtil.toPage(pageData, salaryPool -> {
              StaffSalaryInfoVO salaryInfoVO = PublicUtil.copy(salaryPool, StaffSalaryInfoVO.class);
              return salaryInfoVO;
          });

      }
  
      /**

       * 绩效项目阶梯详情
       *
       * @param salaryPoolId

       * @param salaryGroupProjectId

       * @param yearMonth
       * @return
       */

      public SalaryGroupIndicatorDetailVO getHitProjectSetting(Long salaryPoolId, Long salaryGroupProjectId, YearMonth yearMonth) {

          SalaryPool pool = salaryPoolService.getById(salaryPoolId);
          BV.notNull(pool, "薪酬池不存在");

          Long userId = pool.getUserId();
          LocalDate localDate = getPoolLastData(pool);

          SalaryGroupIndicatorDetailVO detailVO = new SalaryGroupIndicatorDetailVO();

          SalaryGroupProject salaryGroupProject = salaryGroupProjectService.getById(salaryGroupProjectId);

          BV.notNull(salaryGroupProject, "薪酬项目不存在");

          if (PublicUtil.isNotEmpty(salaryGroupProject.getLaddersType())) {
              detailVO.setLaddersType(salaryGroupProject.getLaddersType());
          }

  
  
          CountDownLatch countDownLatch = new CountDownLatch(3);
  
          ThreadPoolExecutor threadPool = ThreadPoolUtil.getInstance().getThreadPool();
  
          threadPool.execute(() -> this.setSalaryGroupProjectParam(salaryGroupProjectId, userId, localDate, detailVO, countDownLatch));
          threadPool.execute(() -> this.setSalaryGroupProjectPreconditionHitVos(salaryGroupProjectId, userId, localDate, detailVO, countDownLatch));
          threadPool.execute(() -> this.setSalaryGroupProjectSetting(salaryGroupProject, userId, localDate, detailVO, countDownLatch));
  
          detailVO.setName(salaryGroupProject.getName());
          detailVO.setLadderParamAlias(salaryGroupProject.getLadderParamAlias());
          detailVO.setCommissionParamAlias(salaryGroupProject.getCommissionParamAlias());
          detailVO.setPreconditionAlias(salaryGroupProject.getPreconditionAlias());
          detailVO.setCalMethod(salaryGroupProject.getCalMethod());
          detailVO.setBeginDate(localDate.with(TemporalAdjusters.firstDayOfMonth()).atStartOfDay());
          detailVO.setEndDate(localDate.atTime(23, 59, 59));
          try {
              countDownLatch.await();
          } catch (InterruptedException e) {
              log.error("绩效项目阶梯详情查询失败 -> salaryPoolId: [{}], salaryGroupProjectId: [{}], msg: [{}]",
                      salaryPoolId, salaryGroupProjectId, e);
          }
          return detailVO;
      }
  
      /**
       * 设置阶梯
       *
       * @param salaryGroupProject
       * @param userId
       * @param localDate
       * @param detailVO
       * @param countDownLatch
       */
      public void setSalaryGroupProjectSetting(SalaryGroupProject salaryGroupProject, Long userId, LocalDate localDate,
                                               SalaryGroupIndicatorDetailVO detailVO,
                                               CountDownLatch countDownLatch) {
          Long salaryGroupProjectId = salaryGroupProject.getId();

          List<SalaryGroupProjectSettin> settings = salaryGroupProjectSettinService.list(Wrappers.<SalaryGroupProjectSettin>lambdaQuery()
                  .eq(SalaryGroupProjectSettin::getSalaryGroupProjectId, salaryGroupProjectId)
                  .eq(SalaryGroupProjectSettin::getYn, Boolean.TRUE)
                  .orderByAsc(SalaryGroupProjectSettin::getId)
          );

          List<SalaryGroupProjectHitLog> salaryProjectHitLogs = salaryGroupProjectHitLogService.list(Wrappers.<SalaryGroupProjectHitLog>lambdaQuery()
                  .eq(SalaryGroupProjectHitLog::getUserId, userId)
                  .eq(SalaryGroupProjectHitLog::getSalaryGroupProjectId, salaryGroupProjectId)
                  .eq(SalaryGroupProjectHitLog::getDataDate, localDate)
                  .eq(SalaryGroupProjectHitLog::getYn, Boolean.TRUE)
          );

          //固定提成 车系

          switch (salaryGroupProject.getCalMethod()) {
              case CAR_SERIES: {
                  this.setCarSeriesProjectDetail(salaryProjectHitLogs, settings, detailVO);
                  break;

              }

              case LADDER:
              case FIXATION:
              case STAR: {
                  this.setProjectDetail(salaryProjectHitLogs, settings, detailVO);
                  break;

              }

          }

          countDownLatch.countDown();

      }
  

      /**

       * 设置车系详情
       *
       * @param salaryProjectHitLogs
       * @param settings
       * @param detailVO
       */
      private void setProjectDetail(List<SalaryGroupProjectHitLog> salaryProjectHitLogs, List<SalaryGroupProjectSettin> settings, SalaryGroupIndicatorDetailVO detailVO) {
  
          if (PublicUtil.isEmpty(salaryProjectHitLogs)) {
              detailVO.setSettings(settings.stream().map(setting -> {
                  return PublicUtil.copy(setting, SalaryGroupProjectSettinVO.class);
              }).collect(Collectors.toList()));
              detailVO.setSalaryValue(new BigDecimal("0"));
              return;
          }
  
          SalaryGroupProjectHitLog salaryProjectHitLog = salaryProjectHitLogs.stream().findFirst().get();
          Long hitSettingId = salaryProjectHitLog.getSalaryGroupProjectSettinId();
  

          Boolean ratio = PublicUtil.isNotEmpty(detailVO.getLaddersType()) && DataTypeEnum.RATIO.equals(detailVO.getLaddersType());

          detailVO.setSettings(settings.stream().map(setting -> {
              SalaryGroupProjectSettinVO settingVO = PublicUtil.copy(setting, SalaryGroupProjectSettinVO.class);
              settingVO.setHit((hitSettingId.equals(settingVO.getId()) ? Boolean.TRUE : Boolean.FALSE));

              if (hitSettingId.equals(settingVO.getId())) {
                  settingVO.setHitCommissionValue(salaryProjectHitLog.getHitCommissionValue());

                  settingVO.setHitLadderValue(salaryProjectHitLog.getHitLadderValue());

              }

              if (ratio) {
                  settingVO.processPercent();
              }

              return settingVO;
          }).collect(Collectors.toList()));
          detailVO.setSalaryValue(salaryProjectHitLog.getSalaryValue());

          if (PublicUtil.isEmpty(detailVO.getStarLevel())) {
              detailVO.setStarLevel(detailVO.getStarLevel());
          }

  
      }
  
      /**
       * 设置车系详情
       *
       * @param salaryProjectHitLogs
       * @param settings
       * @param detailVO
       */
      private void setCarSeriesProjectDetail(List<SalaryGroupProjectHitLog> salaryProjectHitLogs, List<SalaryGroupProjectSettin> settings, SalaryGroupIndicatorDetailVO detailVO) {
  
          Map<Long, SalaryGroupProjectHitLog> hitMap = new HashMap<>();
          if (PublicUtil.isNotEmpty(salaryProjectHitLogs)) {
              hitMap = salaryProjectHitLogs.stream().collect(
                      Collectors.toMap(SalaryGroupProjectHitLog::getSalaryGroupProjectSettinId, Function.identity(), (v1, v2) -> v1));
          }
          BigDecimal totalSalaryValue = new BigDecimal("0");
          List<SalaryGroupProjectSettinVO> settingVos = new ArrayList<>();
          for (SalaryGroupProjectSettin setting : settings) {
              SalaryGroupProjectSettinVO settingVO = PublicUtil.copy(setting, SalaryGroupProjectSettinVO.class);
              if (hitMap.containsKey(setting.getId())) {
                  SalaryGroupProjectHitLog hitLog = hitMap.get(setting.getId());

                  if (PublicUtil.isNotEmpty(hitLog)) {

                      totalSalaryValue = totalSalaryValue.add(hitLog.getSalaryValue());

                      settingVO.setHit(Boolean.TRUE);

                      settingVO.setSalaryValue(hitLog.getSalaryValue());
                      settingVO.setHitCommissionValue(hitLog.getHitCommissionValue());

                  }
              }
              settingVos.add(settingVO);
          }
          detailVO.setSettings(settingVos);
          detailVO.setSalaryValue(totalSalaryValue);
      }
  
      /**

       * 获取绩效参数
       *
       * @param salaryGroupProjectId
       * @param userId
       * @param localDate
       * @return
       */

      public void setSalaryGroupProjectParam(Long salaryGroupProjectId, Long userId, LocalDate localDate,
                                             SalaryGroupIndicatorDetailVO detailVO,
                                             CountDownLatch countDownLatch) {

          List<SalaryGroupProjectParamVO> params = salaryGroupProjectParamService.getSalaryGroupProjectParamVO(salaryGroupProjectId);

          if (PublicUtil.isEmpty(params)) {

              countDownLatch.countDown();
              return ;

          }

  
          List<Long> targetParamIds = params.stream()
                  .filter(param -> ! TargetTypeEnum.NO.equals(param.getTargetType()))

                  .map(SalaryGroupProjectParamVO::getId).collect(Collectors.toList());
          Map<Long, SalaryGroupProjectTargetHitLog> paramTargetHitLogMap = new HashMap<>();
          if (PublicUtil.isNotEmpty(targetParamIds)) {
              List<SalaryGroupProjectTargetHitLog> targetHitLogs = salaryGroupProjectTargetHitLogService.list(Wrappers.<SalaryGroupProjectTargetHitLog>lambdaQuery()
                      .in(SalaryGroupProjectTargetHitLog::getReferId, targetParamIds)