KPI / fw-morax

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

  import cn.fw.common.exception.BusinessException;

  import cn.fw.common.web.annotation.DisLock;

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

  import cn.fw.morax.common.utils.DateUtil;
  import cn.fw.morax.common.utils.MessageFormatUtil;

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

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

  import cn.fw.morax.domain.bo.kpi.KpiGroupCalculableBO;

  import cn.fw.morax.domain.bo.kpi.KpiGroupCalculableRankBO;

  import cn.fw.morax.domain.bo.kpi.KpiRankCalculableBO;

  import cn.fw.morax.domain.bo.kpi.KpiStarLadderBO;

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

  import cn.fw.morax.domain.dto.kpi.KpiGroupRankConfigQueryDTO;

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

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

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

  import com.alibaba.fastjson.JSON;

  import com.alibaba.fastjson.JSONObject;

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

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

  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.data.redis.core.BoundZSetOperations;

  import org.springframework.data.redis.core.ListOperations;
  import org.springframework.data.redis.core.StringRedisTemplate;

  import org.springframework.lang.NonNull;

  import org.springframework.stereotype.Service;

  import org.springframework.transaction.annotation.Transactional;

  import java.math.BigDecimal;
  import java.math.RoundingMode;

  import java.text.DecimalFormat;

  import java.time.LocalDate;
  import java.time.YearMonth;

  import java.util.*;

  import java.util.stream.Collectors;

  import static cn.fw.common.businessvalidator.Validator.BV;

  import static cn.fw.morax.common.utils.MessageFormatUtil.MessageFormatTransfer;

  
  /**
   * 绩效池业务处理服务
   *
   * @author kurisu
   */

  @RequiredArgsConstructor
  @Service
  @Slf4j
  public class KpiPoolBizService {
  

      private final KpiPoolService kpiPoolService;

      private final KpiGroupService kpiGroupService;

      private final KpiStarRuleService kpiStarRuleService;

      private final KpiGroupRankService kpiGroupRankService;
      private final StringRedisTemplate stringRedisTemplate;

      private final KpiGroupUserService kpiGroupUserService;

      private final KpiRewardPointService kpiRewardPointService;

      private final KpiStarLaddersService kpiStarLaddersService;
      private final KpiGroupIndicatorService kpiGroupIndicatorService;

      private final KpiGroupIndicatorHitLogService kpiGroupIndicatorHitLogService;

      private final KpiPoolIndicatorValueService kpiPoolIndicatorValueService;
      private final KpiGroupRankStarLaddersService kpiGroupRankStarLaddersService;

      private final KpiGroupIndicatorLaddersService kpiGroupIndicatorLaddersService;

      private final KpiAssessPenaltyStaffService kpiAssessPenaltyStaffService;

      private final KpiAssessPenaltyService kpiAssessPenaltyService;

      private final ReportKpiRankService reportKpiRankService;

      @Value("${spring.cache.custom.global-prefix}:calculate-scoring-rate:kpi-group")
      @Getter
      private String calcuScoringRateKey;
  

      @Value("${spring.cache.custom.global-prefix}:calculate-star-level:kpi-group")
      @Getter
      private String calcuStarKey;

      @Value("${spring.cache.custom.global-prefix}:scoring-rate:short-key")
      @Getter
      private String prefixShortKey;
  

      /**
       * 计算绩效组得分率
       */
      public void calcuScoringRate() {
          ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
          List<String> errList = new ArrayList<>();

          String jsonStr;
          while ((jsonStr = listOps.leftPop(getCalcuScoringRateKey())) != null) {
              if (StringUtils.isEmpty(jsonStr)) {
                  continue;
              }
              KpiGroupCalculableBO calculableBO = JSONObject.parseObject(jsonStr, KpiGroupCalculableBO.class);
              if (Objects.isNull(calculableBO)) {

                  continue;
              }

              try {

                  calcuScoringRate(calculableBO);

              } catch (Exception ex) {

                  log.error("计算绩效组得分率失败：[{}]", jsonStr, ex);
                  errList.add(jsonStr);

              }
          }
          if (!CollectionUtils.isEmpty(errList)) {
              listOps.rightPushAll(getCalcuScoringRateKey(), errList);
          }
      }
  
      /**
       * 计算绩效组得分率
       *

       * @param bo 绩效组信息和日期

       */

      @Transactional(rollbackFor = Exception.class)
      public void calcuScoringRate(final KpiGroupCalculableBO bo) {
          Long kpiGroupId = bo.getKpiGroupId();
          LocalDate localDate = bo.getLocalDate();

          KpiGroup kpiGroup = kpiGroupService.getById(kpiGroupId);
          BV.notNull(kpiGroup, () -> "绩效组配置不存在");

          List<KpiPool> poolList = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                  .eq(KpiPool::getKpiGroupId, kpiGroupId)
                  .eq(KpiPool::getMonthly, YearMonth.from(localDate))

                  .eq(KpiPool::getYn, Boolean.TRUE)
          );

          if (CollectionUtils.isEmpty(poolList)) {

              log.error("绩效池查无数据：[{}] [{}]", kpiGroupId, localDate);

              return;
          }

          List<KpiGroupIndicator> indicators = kpiGroupIndicatorService.list(Wrappers.<KpiGroupIndicator>lambdaQuery()
                  .eq(KpiGroupIndicator::getKpiGroupId, kpiGroupId)
                  .eq(KpiGroupIndicator::getYn, Boolean.TRUE)
          );

          final BigDecimal totalScore = indicators.stream().map(indicator -> BigDecimal.valueOf(indicator.getBaseScore()))

                  .reduce(BigDecimal.ZERO, BigDecimal::add);

          KpiStarRule starRule = kpiStarRuleService.getOne(Wrappers.<KpiStarRule>lambdaQuery()
                          .eq(KpiStarRule::getGroupId, kpiGroup.getGroupId())
                          .eq(KpiStarRule::getYn, Boolean.TRUE)
                  , Boolean.FALSE);
          BV.notNull(starRule, () -> "星级规则配置不存在");
          int rollMonth = Optional.ofNullable(starRule.getRollMonth()).orElse(3);
  

          for (KpiPool pool : poolList) {
              BigDecimal kpiScore = Optional.ofNullable(pool.getKpiScore()).orElse(BigDecimal.ZERO);
              BigDecimal kpiScoreRatio = kpiScore.divide(totalScore, 4, RoundingMode.HALF_UP);
              pool.setKpiScoreRatio(kpiScoreRatio);

              calcAverageRatio(pool,rollMonth);

          }
          kpiPoolService.updateBatchById(poolList);

      }
  

      /**
       * 计算绩效组人员星级
       */

      public void calcuStarLevel() {

          ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
          List<String> errList = new ArrayList<>();
          String jsonStr;
          while ((jsonStr = listOps.leftPop(getCalcuStarKey())) != null) {
              if (StringUtils.isValid(jsonStr)) {

                  KpiGroupCalculableRankBO calculableBO = JSONObject.parseObject(jsonStr, KpiGroupCalculableRankBO.class);

                  if (Objects.nonNull(calculableBO)) {
                      try {
                          calcuStarLevel(calculableBO);
                      } catch (Exception ex) {

                          log.error("计算绩效星级失败：[{}]", jsonStr, ex);

                          errList.add(jsonStr);
                      }
                  }
              }
          }
          if (!CollectionUtils.isEmpty(errList)) {
              listOps.rightPushAll(getCalcuStarKey(), errList);
          }
      }
  
  
      /**

       * 计算星级、排名

       *
       * @param bo
       */

      @Transactional(rollbackFor = Exception.class)

      public void calcuStarLevel(KpiGroupCalculableRankBO bo) {
          final List<Long> kpiGroupIds = bo.getKpiGroupIds();

          final LocalDate localDate = bo.getLocalDate();

          final BigDecimal revokedScoreRatio = bo.getRevokedScoreRatio();

          List<KpiGroup> kpiGroups = kpiGroupService.listByIds(kpiGroupIds);
          BV.notNull(kpiGroups, () -> "绩效组配置不能为空");
  

          KpiRankCalculableBO calculableBO = getStarConfig(bo, kpiGroups);
          StarEvaluationEnum starEvaluationType = calculableBO.getStarEvaluationType();

          // 查询绩效组下所有人的绩效池信息

          List<KpiPool> poolList = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()

                  .in(KpiPool::getKpiGroupId, kpiGroupIds)

                  .eq(KpiPool::getMonthly, YearMonth.from(localDate))
                  .eq(KpiPool::getYn, Boolean.TRUE)
          );

          if (CollectionUtils.isEmpty(poolList)) {
              return;
          }
  

          if (StarEvaluationEnum.SCORING_RATE.equals(starEvaluationType)) {
              for (KpiPool kpiPool : poolList) {
                  if (!Boolean.TRUE.equals(kpiPool.getInclusion())) {
                      kpiPool.setStarLevel(StarLevelEnum.C);

                      kpiPool.setActualStar(StarLevelEnum.C);

                      continue;
                  }

                  calcRatioStarLevel(kpiPool, calculableBO.getStarLadders());

              }
          } else if (StarEvaluationEnum.PERSONNEL_RATE.equals(starEvaluationType)) {

              calcRateStarLevel(kpiGroups, poolList, calculableBO);

          }
  

          if (Objects.nonNull(revokedScoreRatio) && BigDecimal.ZERO.compareTo(revokedScoreRatio) < 0) {
              for (KpiPool pool : poolList) {
                  BigDecimal kpiScore = pool.getKpiScore();
                  StarLevelEnum actualStar = pool.getActualStar();
                  if (kpiScore.compareTo(revokedScoreRatio) >= 0 && StarLevelEnum.D.equals(actualStar)) {
                      pool.setActualStar(StarLevelEnum.C);
                  }
              }
          }

          //计算排名
          calcRank(poolList);

          calcActualRank(bo, poolList, kpiGroupIds);
  

          kpiPoolService.updateBatchById(poolList);
      }

      /**
       * 按绩效得分率
       */

      private void calcRatioStarLevel(KpiPool kpiPool, List<KpiStarLadderBO> startLadders) {
          final BigDecimal average = kpiPool.getAverageKpiScoreRatio();

          KpiStarLadderBO ladder = startLadders.stream()

                  .filter(r -> average.compareTo(r.getLower()) >= 0)
                  .filter(a -> average.compareTo(a.getUpper()) < 0)
                  .findFirst()
                  .orElseThrow(() -> new BusinessException("未找到对应阶梯值"));
  

          kpiPool.setStarLevel(ladder.getLevel());
          kpiPool.setActualStar(ladder.getLevel());

      }

      /**
       * 按人员数量
       */

      private void calcRateStarLevel(List<KpiGroup> kpiGroups, List<KpiPool> poolList, KpiRankCalculableBO calculableBO) {

          List<KpiStarLadderBO> startLadders = calculableBO.getStarLadders();
          BigDecimal revokedScoreRatio = calculableBO.getRevokedScoreRatio();

          String kgcStr = kpiGroups.stream().map(KpiGroup::getKgc).collect(Collectors.joining("-"));
          String key = getShortKey(kgcStr);
          BoundZSetOperations<String, String> zSetOps = stringRedisTemplate.boundZSetOps(key);
          stringRedisTemplate.expireAt(key, DateUtil.localDate2Date(LocalDate.now().plusDays(1L)));

          for (KpiPool kpiPool : poolList) {
              if (!Boolean.TRUE.equals(kpiPool.getInclusion())) {
                  kpiPool.setStarLevel(StarLevelEnum.C);

                  kpiPool.setActualStar(StarLevelEnum.C);

                  continue;
              }

              zSetOps.add(kpiPool.getId().toString(), kpiPool.getAverageKpiScoreRatio().doubleValue());

          }

          Map<StarLevelEnum, KpiStarLadderBO> map = new HashMap<>(StarLevelEnum.values().length);
          for (KpiStarLadderBO ladder : startLadders) {

              map.put(ladder.getLevel(), ladder);
          }
  

          Map<String, StarLevelEnum> starLevelSetMap = calcPersonRateStarLevel(zSetOps, map, poolList, revokedScoreRatio);

          if (!CollectionUtils.isEmpty(starLevelSetMap)) {
              for (KpiPool pool : poolList) {
                  if (!Boolean.TRUE.equals(pool.getInclusion())) {
                      continue;
                  }
                  Long poolId = pool.getId();

                  StarLevelEnum starLevel = Optional.ofNullable(starLevelSetMap.get(String.valueOf(poolId))).orElse(StarLevelEnum.C);
                  pool.setStarLevel(starLevel);
                  pool.setActualStar(starLevel);

              }
          }

          stringRedisTemplate.delete(key);

      }
  
      /**
       * 按人数百分比计算等级
       *
       * @param zSetOps
       * @param map
       */

      private Map<String, StarLevelEnum> calcPersonRateStarLevel(BoundZSetOperations<String, String> zSetOps,
                                                                 Map<StarLevelEnum, KpiStarLadderBO> map,
                                                                 List<KpiPool> pools, BigDecimal revokedScoreRatio) {

          final Long personCount = zSetOps.size();
          if (Objects.isNull(personCount) || Objects.equals(personCount, 0L)) {
              return null;
          }
          Map<String, StarLevelEnum> levelIdMap = new HashMap<>();
  

          KpiStarLadderBO aladder = map.get(StarLevelEnum.A);

          BV.notNull(aladder, () -> "星级A阶梯配置不存在");
          BigDecimal upper = aladder.getUpper();
          int ai = upper.multiply(BigDecimal.valueOf(personCount)).divide(BigDecimal.ONE, 0, RoundingMode.FLOOR).intValue();
          if (ai > 0) {
              assembleLevelIdMap(levelIdMap, StarLevelEnum.A, zSetOps.reverseRange(0, ai - 1));
  
          }
  

          KpiStarLadderBO bladder = map.get(StarLevelEnum.B);

          BV.notNull(bladder, () -> "星级B阶梯配置不存在");
          BigDecimal bupper = bladder.getUpper();
          int bi = bupper.multiply(BigDecimal.valueOf(personCount)).divide(BigDecimal.ONE, 0, RoundingMode.FLOOR).intValue();
          if (bi > ai) {
              assembleLevelIdMap(levelIdMap, StarLevelEnum.B, zSetOps.reverseRange(ai, bi - 1));
          }
  

          KpiStarLadderBO dladder = map.get(StarLevelEnum.D);

          BV.notNull(dladder, () -> "星级D阶梯配置不存在");
          BigDecimal lower = dladder.getLower();
          int di = lower.multiply(BigDecimal.valueOf(personCount)).divide(BigDecimal.ONE, 0, RoundingMode.CEILING).intValue();
          if (di < personCount) {

              Set<String> poolIds = zSetOps.reverseRange(di, -1);
              if (PublicUtil.isEmpty(revokedScoreRatio) || (BigDecimal.ZERO.compareTo(revokedScoreRatio) == 0)) {
                  assembleLevelIdMap(levelIdMap, StarLevelEnum.D, poolIds);
              } else {
                  Map<String, BigDecimal> poolMap = pools.stream().collect(Collectors.toMap(pool -> pool.getId().toString(), KpiPool::getAverageKpiScoreRatio));
                  Set<String> notRevokedIds = poolIds.stream().filter(poolId ->

                          poolMap.get(poolId).compareTo(revokedScoreRatio) < 0

                  ).collect(Collectors.toSet());
                  assembleLevelIdMap(levelIdMap, StarLevelEnum.D, notRevokedIds);
              }

          }

          return levelIdMap;
      }
  
      /**
       * 计算滚动月份平均得分率
       *
       * @param kpiPool
       * @param rollMonth
       * @return
       */

      private void calcAverageRatio(KpiPool kpiPool, int rollMonth) {

          //未纳入绩效考核人员也计算平均得分率,返回当月绩效完成率
          if (Boolean.FALSE.equals(kpiPool.getInclusion())) {

              kpiPool.setAverageKpiScoreRatio(Optional.ofNullable(kpiPool.getKpiScoreRatio()).orElse(BigDecimal.ZERO));
              kpiPool.setLastOneKpiScoreRatio(BigDecimal.ZERO);
              kpiPool.setLastTwoKpiScoreRatio(BigDecimal.ZERO);
              return;

          }

          List<KpiPool> poolList = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()

                  .eq(KpiPool::getUserId, kpiPool.getUserId())
                  .eq(KpiPool::getPostId, kpiPool.getPostId())

                  .eq(KpiPool::getInclusion, Boolean.TRUE)
                  .le(KpiPool::getCreateTime, kpiPool.getCreateTime())
                  .eq(KpiPool::getYn, Boolean.TRUE)
                  .orderByDesc(KpiPool::getCreateTime)
                  .last(MessageFormatUtil.MessageFormatTransfer(" limit  {0}", rollMonth))
          );

          double averageKpiScoreRatio = poolList.stream()

                  .mapToDouble(r -> Optional.ofNullable(r.getKpiScoreRatio()).orElse(BigDecimal.ZERO).doubleValue())
                  .average()
                  .orElse(0);

          kpiPool.setAverageKpiScoreRatio(BigDecimal.valueOf(averageKpiScoreRatio));
          YearMonth lastMonth = kpiPool.getMonthly().minusMonths(1);
          YearMonth preTwoMonth = kpiPool.getMonthly().minusMonths(2);
          BigDecimal lastMonthRatio = poolList.stream()
                  .filter(pool -> lastMonth.compareTo(pool.getMonthly()) == 0).findFirst()
                  .map(KpiPool::getKpiScoreRatio).orElse(BigDecimal.ZERO);
          BigDecimal preTwoMonthRatio = poolList.stream()
                  .filter(pool -> preTwoMonth.compareTo(pool.getMonthly()) == 0).findFirst()
                  .map(KpiPool::getKpiScoreRatio).orElse(BigDecimal.ZERO);
          kpiPool.setLastOneKpiScoreRatio(lastMonthRatio);
          kpiPool.setLastTwoKpiScoreRatio(preTwoMonthRatio);

      }
  

  
      /**
       * 计算排名
       *
       * @param poolList
       */
      public void calcRank(List<KpiPool> poolList) {
          if (PublicUtil.isEmpty(poolList)) {
              return;
          }
          List<KpiPool> pools = poolList.stream()

                  .filter(pool -> Boolean.TRUE.equals(pool.getInclusion()))

                  .sorted(Comparator.comparing(KpiPool::getAverageKpiScoreRatio, BigDecimal::compareTo).reversed())

                  .collect(Collectors.toList());
  

          int rank = 1;

          BigDecimal lastKpiScoreRatio = null;
          for (KpiPool pool : pools) {

              if (PublicUtil.isNotEmpty(lastKpiScoreRatio) && (lastKpiScoreRatio.compareTo(pool.getAverageKpiScoreRatio()) != 0)) {

                  rank++;

              }

              pool.setRank(rank);

              lastKpiScoreRatio = pool.getAverageKpiScoreRatio();

          }

  
          //本月绩效排名
          List<KpiPool> pools2 = poolList.stream()
                  .filter(pool -> Boolean.TRUE.equals(pool.getInclusion()))
                  .sorted(Comparator.comparing(KpiPool::getKpiScoreRatio, BigDecimal::compareTo).reversed())
                  .collect(Collectors.toList());
  
          int rank2 = 1;
          BigDecimal lastKpiScoreRatio2 = null;
          for (KpiPool pool : pools2) {
              if (PublicUtil.isNotEmpty(lastKpiScoreRatio2) && (lastKpiScoreRatio2.compareTo(pool.getKpiScoreRatio()) != 0)) {
                  rank2++;
              }
              pool.setMonthRank(rank2);
              lastKpiScoreRatio2 = pool.getKpiScoreRatio();
          }

      }
  

      /**

       * 计算转正保护期、正式员工排名排名
       *
       * @param poolList
       */
      public void calcActualRank(KpiGroupCalculableRankBO bo, List<KpiPool> poolList, List<Long> kpiGroupIds) {
          if (Boolean.FALSE.equals(bo.getFinalCalc()) || PublicUtil.isEmpty(poolList)) {
              return;
          }
          LocalDate localDate = bo.getLocalDate();
          List<KpiGroupUser> turnPositiveUsers = kpiGroupUserService.list(Wrappers.<KpiGroupUser>lambdaQuery()
                  .in(KpiGroupUser::getKpiGroupId, kpiGroupIds)
                  .eq(KpiGroupUser::getIgnored, Boolean.TRUE)
                  .eq(KpiGroupUser::getIgnoreCause, KpiIgnoreCauseEnum.TURN_POSITIVE_AFTER)
                  .eq(KpiGroupUser::getDataDate, localDate)
                  .eq(KpiGroupUser::getYn, Boolean.TRUE)
          );
          Set<Long> turnPositiveUserIds = turnPositiveUsers.stream().map(KpiGroupUser::getUserId).collect(Collectors.toSet());
          //转正保护期员工一起排名
          List<KpiPool> pools = poolList.stream()
                  .filter(pool -> {
                      return Boolean.TRUE.equals(pool.getInclusion()) || (turnPositiveUserIds.contains(pool.getUserId()));
                  })
                  .sorted(Comparator.comparing(KpiPool::getAverageKpiScoreRatio, BigDecimal::compareTo).reversed())
                  .collect(Collectors.toList());
  
          int rank = 1;
          BigDecimal lastKpiScoreRatio = null;
          for (KpiPool pool : pools) {
              if (PublicUtil.isNotEmpty(lastKpiScoreRatio) && (lastKpiScoreRatio.compareTo(pool.getAverageKpiScoreRatio()) != 0)) {
                  rank++;
              }
              pool.setAssessRank(rank);
              lastKpiScoreRatio = pool.getAverageKpiScoreRatio();
          }
      }
  
      /**

       * 生成排序key
       *

       * @param key

       * @return
       */

      private String getShortKey(@NonNull String key) {
          return String.format("%s:%s", getPrefixShortKey(), key);

      }
  
  
      /**
       * 组装id对应等级
       *
       * @param levelIdMap
       * @param level
       * @param ids
       */
      private void assembleLevelIdMap(Map<String, StarLevelEnum> levelIdMap, StarLevelEnum level, Set<String> ids) {
          if (CollectionUtils.isNotEmpty(ids)) {
              for (String s : ids) {
                  levelIdMap.put(s, level);
              }
          }
      }

  
      /**
       * 失效用户所有绩效池
       * 不参与滚动计算平均三个月绩效得分率,不纳入D级次数计算。场景：
       * 1， 用户申请重新计算绩效考核
       * 2. 调岗
       * 3. 待岗
       *
       * @param userId
       */
      @Transactional(rollbackFor = Exception.class)

      public void invalidKpiPool(KpiGroup originKpiGroup, Long userId, LocalDate anticipatedDate) {
          KpiGroupUser groupUser = kpiGroupUserService.getOne(Wrappers.<KpiGroupUser>lambdaQuery()
                  .eq(KpiGroupUser::getKgc, originKpiGroup.getKgc())
                  .eq(KpiGroupUser::getUserId, userId)
                  .eq(KpiGroupUser::getDataDate, LocalDate.now())
                  .eq(KpiGroupUser::getYn, Boolean.TRUE)
          );
          if (PublicUtil.isNotEmpty(groupUser)) {
              groupUser.setIgnored(Boolean.TRUE);
              if (PublicUtil.isNotEmpty(anticipatedDate)) {
                  groupUser.setAnticipatedDate(anticipatedDate);
              }
              groupUser.setIgnoreCause(KpiIgnoreCauseEnum.TRANSFER_NEW_POSITION_AFTER);
              groupUser.setIgnoreCauseDesc(KpiIgnoreCauseEnum.TRANSFER_NEW_POSITION_AFTER.getName());
              kpiGroupUserService.updateById(groupUser);
          }
  
          kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()

                  .set(KpiPool::getInclusion, Boolean.FALSE)

                  .set(KpiPool::getRank, null)

                  .eq(KpiPool::getUserId, userId)

                  .eq(KpiPool::getMonthly, YearMonth.now())

                  .eq(KpiPool::getInclusion, Boolean.TRUE)
          );

      }
  
      /**
       * 失效用户所有绩效得分率。场景：
       * 1， 用户申请重新计算绩效考核
       * 2. 调岗
       * 3. 待岗
       *
       * @param userId
       */
      @Transactional(rollbackFor = Exception.class)
      public void adjustmentKpiPool(Long userId, StarLevelEnum starLevelEnum, YearMonth yearMonth) {
          Boolean result = kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()
                  .set(KpiPool::getActualStar, starLevelEnum)
                  .eq(KpiPool::getUserId, userId)
                  .eq(KpiPool::getMonthly, yearMonth)
          );
          BV.isTrue(result, "绩效池是否纳入绩效计算修改失败");
      }
  

      /**
       * 查询薪酬池详情
       *
       * @param poolId 薪酬池id
       * @return 薪酬池详情
       */

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

          KpiPool pool = kpiPoolService.getById(poolId);

  //        boolean flag = Objects.nonNull(pool) && Boolean.TRUE.equals(pool.getYn());
  //        BV.isTrue(flag, () -> "该人员绩效数据不存在");

          if (PublicUtil.isEmpty(pool)) {

              return null;
          }

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

              List<KpiPool> list = userSalaryPool(pool.getUserId(), yearMonth);

  //            BV.isNotEmpty(list, () -> "人员薪酬数据不存在");
              if (PublicUtil.isEmpty(list)) {
                  return null;
              }

              pool = list.get(0);
          }

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

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

          List<KpiPool> list = userSalaryPool(userId, yearMonth);

  //        BV.isNotEmpty(list, () -> "人员薪酬数据不存在");
          if (PublicUtil.isEmpty(list)) {
              return null;
          }

          KpiPool kpiPool = list.get(0);
          return getPoolDetail(kpiPool);
      }
  
      /**
       * 绩效池详情构建
       *
       * @param kpiPool
       * @return
       */
      private KpiPoolDetailVO getPoolDetail(KpiPool kpiPool) {
          Long userId = kpiPool.getUserId();
          Long kpiPoolId = kpiPool.getId();

          Long kpiGroupId = kpiPool.getKpiGroupId();

          KpiPoolDetailVO kpiPoolDetailVo = PublicUtil.copy(kpiPool, KpiPoolDetailVO.class);

          //奖惩绩效分

  //        this.processRewardPoint(kpiPool, kpiPoolDetailVo);

          //近一年绩效情况

          List<KpiPool> kpiPools = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()

                  .ge(KpiPool::getMonthly, kpiPool.getMonthly().minusMonths(12L))

                  .eq(KpiPool::getUserId, userId)
                  .eq(KpiPool::getInclusion, Boolean.TRUE)
                  .eq(KpiPool::getYn, Boolean.TRUE)

                  .orderByDesc(KpiPool::getMonthly)

          );

          if (PublicUtil.isNotEmpty(kpiPools)) {

              List<KpiPoolDetailVO> kpis = PublicUtil.copyList(kpiPools, KpiPoolDetailVO.class);

              kpis.stream().forEach(KpiPoolDetailVO::convertToPercent);

              kpiPoolDetailVo.setKpis(kpis);

          }

          buildPoolData(kpiPool, kpiPoolDetailVo);
          LocalDate dataDate = LocalDate.from(kpiPoolDetailVo.getEndTime());

          kpiPoolDetailVo.setTotalScore(this.getKpiGroupIndicatorTotalScore(kpiGroupId));

          kpiPoolDetailVo.setKpiScoreRatio(kpiPoolDetailVo.getKpiScoreRatio().multiply(Constant.ONE_HUNDRED));

          this.setRewardPunish(kpiPool, kpiPoolDetailVo);

          this.setIndicatorVos(kpiPoolId, kpiGroupId, dataDate, kpiPoolDetailVo);
          this.setAssess(kpiPoolDetailVo);
          return kpiPoolDetailVo;
      }
  

      public void setRewardPunish(KpiPool pool, KpiPoolDetailVO kpiPoolDetailVO) {
          List<KpiRewardPoint> rewardPoints = kpiRewardPointService.list(Wrappers.<KpiRewardPoint>lambdaQuery()
                  .eq(KpiRewardPoint::getUserId, pool.getUserId())
                  .eq(KpiRewardPoint::getPostId, pool.getPostId())
                  .eq(KpiRewardPoint::getShopId, pool.getShopId())
                  .eq(KpiRewardPoint::getMonthly, pool.getMonthly())

                  .le(KpiRewardPoint::getCreateTime, kpiPoolDetailVO.getEndTime())

                  .eq(KpiRewardPoint::getGroupId, pool.getGroupId())
          );

  
          //计算分数时将
          BigDecimal rewardScore = BigDecimal.ZERO;
          BigDecimal punishScore = BigDecimal.ZERO;
          for (KpiRewardPoint point : rewardPoints) {
              if (BigDecimal.ZERO.compareTo(point.getScorePoint()) > 0) {
                  punishScore = punishScore.add(point.getScorePoint());
              } else {
                  rewardScore = rewardScore.add(point.getScorePoint());
              }
          }
          //奖励分正数、惩罚分负数，减去奖惩分数，得到原始分数

          BigDecimal originKpiScore = pool.getKpiScore().subtract(rewardScore).subtract(punishScore);

          if (BigDecimal.ZERO.compareTo(originKpiScore) > 0) {
              originKpiScore = BigDecimal.ZERO;
          }

          kpiPoolDetailVO.setRewardScore(rewardScore);
          kpiPoolDetailVO.setPunishScore(punishScore.abs());

          kpiPoolDetailVO.setRealKpiScore(pool.getKpiScore());
          kpiPoolDetailVO.setOriginKpiScore(originKpiScore);

          kpiPoolDetailVO.setRewards(new ArrayList<>());
          kpiPoolDetailVO.setPunishments(new ArrayList<>());
          rewardPoints.stream().forEach(point -> {
              KpiRewardPointVO pointVO = PublicUtil.copy(point, KpiRewardPointVO.class);
              pointVO.setExpectation(Boolean.FALSE);
              if (point.getScorePoint().compareTo(BigDecimal.ZERO) > 0) {
                  kpiPoolDetailVO.getRewards().add(pointVO);
              }
              if (point.getScorePoint().compareTo(BigDecimal.ZERO) < 0) {

                  pointVO.setScorePoint(pointVO.getScorePoint().abs());

                  kpiPoolDetailVO.getPunishments().add(pointVO);
              }
          });
      }
  

      public void setIndicatorVos(Long kpiPoolId, Long kpiGroupId, LocalDate dataDate, KpiPoolDetailVO kpiPoolDetailVo) {
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");

          List<KpiPoolIndicatorValueVO> indicatorValueVOS = kpiPoolIndicatorValueService.getStaffIndicatorValue(kpiPoolId, kpiGroupId, dataDate);

          for (KpiPoolIndicatorValueVO indicatorValueVO : indicatorValueVOS) {

              indicatorValueVO.setIndicatorScoreFormat(decimalFormat.format(indicatorValueVO.getIndicatorScore()));