KPI / fw-morax

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

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

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

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

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

  import cn.fw.morax.domain.dto.kpi.KpiGroupIndicatorRankDTO;
  import cn.fw.morax.domain.enums.*;

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

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

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

  import com.alibaba.fastjson.JSON;

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

  import com.google.common.collect.Lists;

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

  import org.springframework.stereotype.Service;

  import java.math.BigDecimal;

  import java.time.LocalDate;

  import java.time.YearMonth;

  import java.util.*;
  import java.util.function.Function;

  import java.util.stream.Collectors;

  
  import static cn.fw.common.businessvalidator.Validator.BV;
  
  @RequiredArgsConstructor
  @Service
  @Slf4j
  public class KpiGroupIndicatorBizService {
  
      private final KpiGroupIndicatorLaddersService kpiGroupIndicatorLaddersService;
      private final KpiGroupIndicatorService kpiGroupIndicatorService;

      private final KpiGroupIndicatorHitLogService kpiGroupIndicatorHitLogService;

      private final KpiGroupIndicatorParamService kpiGroupIndicatorParamService;
      private final KpiGroupIndicatorPreconditionService kpiGroupIndicatorPreconditionService;

      private final KpiGroupIndicatorTargetHitLogService kpiGroupIndicatorTargetHitLogService;
      private final KpiGroupIndicatorPreconditionLaddersService kpiGroupIndicatorPreconditionLaddersService;

      private final KpiPoolIndicatorValueService kpiPoolIndicatorValueService;

      private final IndicatorUserValueService indicatorUserValueService;

      private final KpiGroupUserService kpiGroupUserService;
      private final IndicatorsService indicatorsService;

      private final KpiGroupService kpiGroupService;

      private final CommonService commonService;

      private final KpiPoolService kpiPoolService;

  
      /**
       * 绩效组指标详情

       *

       * @param kpiIndicatorId
       * @return
       */

      public KpiGroupIndicatorVO kpiGroupIndicatorDetail(Long kpiIndicatorId) {

          KpiGroupIndicator kpiGroupIndicator = kpiGroupIndicatorService.getById(kpiIndicatorId);

          BV.isNull(kpiGroupIndicator, "绩效指标配置不存在，请重试");

          KpiGroupIndicatorVO kpiGroupIndicatorVo = PublicUtil.copy(kpiGroupIndicator, KpiGroupIndicatorVO.class);

  
          List<KpiGroupIndicatorLadders> kpiGroupIndicatorLadders = kpiGroupIndicatorLaddersService.list(Wrappers.<KpiGroupIndicatorLadders>lambdaQuery()
                  .eq(KpiGroupIndicatorLadders::getKpiGroupIndicatorId, kpiIndicatorId)

                  .eq(KpiGroupIndicatorLadders::getYn, Boolean.TRUE)

          );
          if (PublicUtil.isNotEmpty(kpiGroupIndicatorLadders)) {

              List<KpiGroupIndicatorLaddersVO> indicatorLaddersVos = PublicUtil.copyList(kpiGroupIndicatorLadders, KpiGroupIndicatorLaddersVO.class);

              kpiGroupIndicatorVo.setIndicatorLadders(indicatorLaddersVos);

          }
          return kpiGroupIndicatorVo;
      }

  
      /**
       * 获取正在使用指标的绩效组

       *

       * @param indicatorCode

       * @return
       */

      public List<KpiGroup> getKpiGroupByIndicatorCode(String indicatorCode) {
          List<KpiGroupIndicatorParam> kpiGroupIndicatorParams = kpiGroupIndicatorParamService.list(Wrappers.<KpiGroupIndicatorParam>lambdaQuery()
                  .eq(KpiGroupIndicatorParam::getIndicatorCode, indicatorCode)
                  .eq(KpiGroupIndicatorParam::getYn, Boolean.TRUE)
          );
          List<KpiGroupIndicatorPrecondition> preconditions = kpiGroupIndicatorPreconditionService.list(Wrappers.<KpiGroupIndicatorPrecondition>lambdaQuery()
                  .eq(KpiGroupIndicatorPrecondition::getIndicatorCode, indicatorCode)
                  .eq(KpiGroupIndicatorPrecondition::getYn, Boolean.TRUE)
          );
          Set<Long> kpiGroupIds = new HashSet<>();
          if (PublicUtil.isNotEmpty(kpiGroupIndicatorParams)) {
              kpiGroupIds.addAll(kpiGroupIndicatorParams.stream().map(KpiGroupIndicatorParam::getKpiGroupId).collect(Collectors.toSet()));
          }
          if (PublicUtil.isNotEmpty(preconditions)) {
              kpiGroupIds.addAll(preconditions.stream().map(KpiGroupIndicatorPrecondition::getKpiGroupId).collect(Collectors.toSet()));
          }
  
          if (PublicUtil.isEmpty(kpiGroupIds)) {
              return new ArrayList<>();
          }

          List<SettingStatusEnum> status = new ArrayList<SettingStatusEnum>() {{

              add(SettingStatusEnum.APPROVING);
              add(SettingStatusEnum.BE_EFFECTIVE);

              add(SettingStatusEnum.EFFECTIVE);
          }};

          List<KpiGroup> kpiGroups = kpiGroupService.list(Wrappers.<KpiGroup>lambdaQuery()

                  .in(KpiGroup::getId, kpiGroupIds)

                  .in(KpiGroup::getStatus, status)
                  .eq(KpiGroup::getYn, Boolean.TRUE)
          );

          return kpiGroups;

      }
  

      /**

       * 绩效项目阶梯详情
       *
       * @param kpiPoolId
       * @param kpiGroupIndicatorId
       * @param yearMonth
       * @return
       */
      public KpiGroupIndicatorDetailVO getHitIndicatorLadder(Long kpiPoolId, Long kpiGroupIndicatorId, YearMonth yearMonth) {
  
          KpiPool kpiPool = kpiPoolService.getById(kpiPoolId);
          BV.notNull(kpiPool, "绩效池不存在");
          LocalDate localDate = this.getPoolLastData(kpiPool);
          Long userId = kpiPool.getUserId();
          KpiGroupIndicator kpiGroupIndicator = kpiGroupIndicatorService.getById(kpiGroupIndicatorId);
          BV.notNull(kpiGroupIndicator, "指标不存在");
          KpiGroup kpiGroup = kpiGroupService.getAllDataById(kpiGroupIndicator.getKpiGroupId());
          BV.notNull(kpiGroup, "绩效组不存在");
  
          KpiGroupIndicatorDetailVO detailVO = new KpiGroupIndicatorDetailVO();
  

          this.setIndicatorsVo(kpiGroupIndicatorId, userId, localDate, detailVO);

          detailVO.setKpiGroupId(kpiGroup.getId());

          detailVO.setKpiTime(localDate.atTime(23, 59, 59));
          detailVO.setPostId(kpiGroup.getPostId());
          detailVO.setPostName(kpiGroup.getPostName());
          detailVO.setKpiGroupShopIds(kpiGroup.getShopIds());
          detailVO.setKpiGroupShopNames(kpiGroup.getShopNames());
          return detailVO;
  
      }
  
      /**
       * 获取绩效池详情最近日期
       *
       * @param kpiPool
       * @return
       */
      public LocalDate getPoolLastData(KpiPool kpiPool) {
          KpiGroupUser kpiGroupUser = kpiGroupUserService.getMonthLastData(kpiPool.getKgc(), kpiPool.getUserId(), kpiPool.getMonthly());
          if (PublicUtil.isEmpty(kpiGroupUser)) {
              log.error("员工绩效池：{}，不存在绩效组人员", JSON.toJSONString(kpiPool));
              return PublicUtil.getYesterdayOrEndOfMonthDay(kpiPool.getMonthly());
          }
          return kpiGroupUser.getDataDate();
      }
  
      /**

       * 设置指标
       *
       * @param
       */

      public void setIndicatorsVo(Long kpiGroupIndicatorId, Long userId, LocalDate localDate, KpiGroupIndicatorDetailVO detailVO) {

  
          KpiGroupIndicator kpiGroupIndicator = kpiGroupIndicatorService.getById(kpiGroupIndicatorId);

          BV.notNull(kpiGroupIndicator, "绩效组指标不存在");

          detailVO.setScoreWay(kpiGroupIndicator.getScoreWay());
          detailVO.setBaseScore(kpiGroupIndicator.getBaseScore());
          detailVO.setParamAlias(kpiGroupIndicator.getParamAlias());

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

          //命中记录

          KpiGroupIndicatorHitLog kpiGroupIndicatorHitLog = kpiGroupIndicatorHitLogService.getOne(Wrappers.<KpiGroupIndicatorHitLog>lambdaQuery()
                  .eq(KpiGroupIndicatorHitLog::getKpiGroupIndicatorId, kpiGroupIndicatorId)
                  .eq(KpiGroupIndicatorHitLog::getDataDate, localDate)
                  .eq(KpiGroupIndicatorHitLog::getUserId, userId)
                  .eq(KpiGroupIndicatorHitLog::getYn, Boolean.TRUE)
          );

  
          if (ScoreWayEnum.LADDER.equals(kpiGroupIndicator.getScoreWay())) {
              Long hitKpiIndicatorLaddersId = kpiGroupIndicatorHitLog.getKpiGroupIndicatorLaddersId();

              List<KpiGroupIndicatorLaddersVO> ladderVos = kpiGroupIndicatorLaddersService.getVos(kpiGroupIndicatorId, kpiGroupIndicator.getLaddersType());
              for (KpiGroupIndicatorLaddersVO laddersVO : ladderVos) {

                  if (PublicUtil.isNotEmpty(hitKpiIndicatorLaddersId)) {

                      laddersVO.setHit((hitKpiIndicatorLaddersId.equals(laddersVO.getId()) ? Boolean.TRUE : Boolean.FALSE));

                  }

              }
              detailVO.setLadders(ladderVos);

          }
  

          if (PublicUtil.isNotEmpty(kpiGroupIndicatorHitLog) && DataTypeEnum.RATIO.equals(kpiGroupIndicator.getLaddersType())) {

              detailVO.setParamsValue(kpiGroupIndicatorHitLog.getKpiValue().multiply(Constant.ONE_HUNDRED));
          }

          //参数
          Map<ParamTypeEnum, List<KpiGroupIndicatorParamVO>> paramMap = this.getKpiGroupIndicatorParamMap(kpiGroupIndicatorId, userId, localDate);

          detailVO.setLadderParams(paramMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));
          detailVO.setCommissionParams(paramMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));

  
          //条件
          List<KpiGroupIndicatorPreconditionVO> preconditionVOS = kpiGroupIndicatorPreconditionService.getHitVos(kpiGroupIndicatorId, userId, localDate);

          detailVO.setConds(preconditionVOS);

          for (KpiGroupIndicatorPreconditionVO preconditionVO : preconditionVOS) {
              //条件目标记录

              if (! TargetTypeEnum.NO.equals(preconditionVO.getTargetType())) {

                  KpiGroupIndicatorTargetHitLog kpiGroupIndicatorTargetHitLog = kpiGroupIndicatorTargetHitLogService.getOne(Wrappers.<KpiGroupIndicatorTargetHitLog>lambdaQuery()

                          .eq(KpiGroupIndicatorTargetHitLog::getReferId, preconditionVO.getId())

                          .eq(KpiGroupIndicatorTargetHitLog::getTargetType, IndicatorTypeEnum.PRE)

                          .eq(KpiGroupIndicatorTargetHitLog::getDataDate, localDate)
                          .eq(KpiGroupIndicatorTargetHitLog::getUserId, userId)
                          .eq(KpiGroupIndicatorTargetHitLog::getYn, Boolean.TRUE)
                  );

                  preconditionVO.processTargetPercent(kpiGroupIndicatorTargetHitLog);
              } else {
                  //无条件目标记录
                  preconditionVO.processNoTargetPercent();

              }
  
              //条件阶梯

              List<KpiGroupIndicatorPreconditionLaddersVO> preconditionLaddersVOS = kpiGroupIndicatorPreconditionLaddersService.getVOS(
                      preconditionVO.getId(), preconditionVO.getTargetType(), preconditionVO.getDataType());

              for (KpiGroupIndicatorPreconditionLaddersVO preconditionLaddersVO : preconditionLaddersVOS) {
                  if (PublicUtil.isNotEmpty(preconditionVO.getHitLaddersId()) && preconditionLaddersVO.getId().equals(preconditionVO.getHitLaddersId())) {
                      preconditionLaddersVO.setHit(Boolean.TRUE);

                  }

              }
              preconditionVO.setCondLadders(preconditionLaddersVOS);
          }
  

      }
  

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

      public Map<ParamTypeEnum, List<KpiGroupIndicatorParamVO>> getKpiGroupIndicatorParamMap(Long kpiGroupIndicatorId, Long userId, LocalDate localDate) {
  

          List<KpiGroupIndicatorParamVO> paramVos = kpiGroupIndicatorParamService.getKpiGroupIndicatorParamVos(kpiGroupIndicatorId);

          List<String> indicatorCodes = paramVos.stream()

                  .filter(param -> TargetTypeEnum.NO.equals(param.getTargetType()))

                  .map(KpiGroupIndicatorParamVO::getIndicatorCode).collect(Collectors.toList());

          Map<String, IndicatorUserValue> indicatorCodeValueMap = new HashMap<>();
          if (PublicUtil.isNotEmpty(indicatorCodes)) {
              List<IndicatorUserValue> indicatorUserValues = indicatorUserValueService.list(Wrappers.<IndicatorUserValue>lambdaQuery()
                      .in(IndicatorUserValue::getIndicatorCode, indicatorCodes)
                      .eq(IndicatorUserValue::getDataDate, localDate)
                      .eq(IndicatorUserValue::getUserId, userId)
                      .eq(IndicatorUserValue::getYn, Boolean.TRUE)
              );
              indicatorCodeValueMap = indicatorUserValues.stream()
                      .collect(Collectors.toMap(IndicatorUserValue::getIndicatorCode, Function.identity(), (v1, v2) -> v1));
          }

          List<Long> paramIds = paramVos.stream()

                  .filter(param -> !TargetTypeEnum.NO.equals(param.getTargetType()))

                  .map(KpiGroupIndicatorParamVO::getId).collect(Collectors.toList());

          Map<Long, KpiGroupIndicatorTargetHitLog> paramTargetHitLogMap = new HashMap<>();
          if (PublicUtil.isNotEmpty(paramIds)) {

              List<KpiGroupIndicatorTargetHitLog> targetHitLogs = kpiGroupIndicatorTargetHitLogService.list(Wrappers.<KpiGroupIndicatorTargetHitLog>lambdaQuery()

                      .in(KpiGroupIndicatorTargetHitLog::getReferId, paramIds)
                      .eq(KpiGroupIndicatorTargetHitLog::getDataDate, localDate)
                      .eq(KpiGroupIndicatorTargetHitLog::getUserId, userId)
                      .eq(KpiGroupIndicatorTargetHitLog::getYn, Boolean.TRUE)
              );

              paramTargetHitLogMap = targetHitLogs.stream()

                      .collect(Collectors.toMap(KpiGroupIndicatorTargetHitLog::getReferId, Function.identity(), (v1, v2) -> v1));
          }

          for (KpiGroupIndicatorParamVO paramVO : paramVos) {

              //有目标

              if (paramTargetHitLogMap.containsKey(paramVO.getId())) {
                  KpiGroupIndicatorTargetHitLog targetHitLog = paramTargetHitLogMap.get(paramVO.getId());

                  if (DataTypeEnum.RATIO.equals(paramVO.getDataType())) {
                      paramVO.setIndicatorValue(targetHitLog.getValue().multiply(Constant.ONE_HUNDRED));

                  } else {
                      paramVO.setIndicatorValue(targetHitLog.getValue());

                  }

                  paramVO.setReachValue(targetHitLog.getReachValue().multiply(Constant.ONE_HUNDRED));

                  continue;
              }
  
              //无目标
              if (indicatorCodeValueMap.containsKey(paramVO.getIndicatorCode())) {

                  IndicatorUserValue indicatorUserValue = indicatorCodeValueMap.get(paramVO.getIndicatorCode());

                  BigDecimal indicatorOriginValue = commonService.queryIndicatorValue(paramVO.getIndicatorCode(), indicatorUserValue);

                  switch (indicatorUserValue.getValueType()) {
                      case WORK_AGE:
                      case QUANTITY: {

                          paramVO.setIndicatorValue(indicatorOriginValue);

                          break;
                      }
                      case RATIO: {

                          paramVO.setIndicatorValue(indicatorOriginValue.multiply(Constant.ONE_HUNDRED));

                          break;
                      }
                  }

              }

          }
  

          Map<ParamTypeEnum, List<KpiGroupIndicatorParamVO>> indicatorParamMap = paramVos.stream()

                  .collect(Collectors.groupingBy(KpiGroupIndicatorParamVO::getParamType));
  
          return indicatorParamMap;
      }

      /**
       * 查询指标排名
       *
       * @param dto
       * @return
       */

      public KpiIndicatorRankVO queryKpiIndicatorRank(KpiGroupIndicatorRankDTO dto) {
  

          LocalDate localDate = PublicUtil.getYesterdayOrEndOfMonthDay(dto.getMonthly());
          List<KpiPool> pools = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                  .eq(KpiPool::getKpiGroupId, dto.getKpiGroupId())
                  .eq(KpiPool::getMonthly, YearMonth.from(localDate))

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

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

          Long referId = null;

          BigDecimal targetValue = null;
          String indicatorCode = null;
          TargetTypeEnum targetType = null;
          TargetCalcTypeEnum targetCalcType = null;

          IndicatorTypeEnum indicatorTypeEnum = null;

          if (PublicUtil.isNotEmpty(dto.getKpiGroupIndicatorParamId())) {

              referId = dto.getKpiGroupIndicatorParamId();
              indicatorTypeEnum = IndicatorTypeEnum.EXAMINE;
              KpiGroupIndicatorParam param = kpiGroupIndicatorParamService.getById(dto.getKpiGroupIndicatorParamId());
              BV.isTrue(PublicUtil.isNotEmpty(param), "绩效组指标参数不存在");
              indicatorCode = param.getIndicatorCode();
              targetType = param.getTargetType();
              targetValue = param.getTargetValue();
              targetCalcType = param.getTargetCalcType();
  
          } else {
              referId = dto.getKpiGroupIndicatorPreconditionId();
              indicatorTypeEnum = IndicatorTypeEnum.PRE;
              KpiGroupIndicatorPrecondition precondition = kpiGroupIndicatorPreconditionService.getById(dto.getKpiGroupIndicatorPreconditionId());
              BV.isTrue(PublicUtil.isNotEmpty(precondition), "绩效组指标条件不存在");
              indicatorCode = precondition.getIndicatorCode();
              targetType = precondition.getTargetType();
              targetValue = precondition.getTargetValue();
              targetCalcType = precondition.getTargetCalcType();

          }
  

  
          Indicators indicators = indicatorsService.queryByCode(indicatorCode, Boolean.FALSE);
          BV.isTrue(PublicUtil.isNotEmpty(indicators), "指标不存在");
  

          KpiIndicatorRankVO kpiIndicatorRankVO = KpiIndicatorRankVO.builder()

                  .indicatorName(indicators.getIndicatorName())
                  .indicatorCode(indicators.getIndicatorCode())
                  .dataType(indicators.getDataType())

                  .targetType(targetType)

                  .deadlineDate(DateUtil.localDate2Date(localDate))
                  .build();

          if (PublicUtil.isEmpty(pools)) {

              log.error("绩效指标查无数据，指标：[{}] [{}] [{}]", indicatorCode, dto.getKpiGroupId(), localDate);

              return kpiIndicatorRankVO;
          }

          //无目标指标排名

          if (TargetTypeEnum.NO.equals(targetType)) {

              kpiIndicatorRankVO.setStaffs(getNoTargetIndicatorRanks(indicatorCode, localDate, pools));

              return kpiIndicatorRankVO;
          }
  

          //有目标指标排名

          kpiIndicatorRankVO.setStaffs(getTargetIndicatorRanks(referId, localDate, pools, indicatorTypeEnum, indicators));

          kpiIndicatorRankVO.setTargetValue((TargetTypeEnum.RATIO.equals(targetType) ? targetValue.multiply(Constant.ONE_HUNDRED) : targetValue));

          kpiIndicatorRankVO.setTargetCalcType(targetCalcType);
          return kpiIndicatorRankVO;
      }

      /**
       * 无目标指标排名
       *
       * @param indicatorCode
       * @param localDate
       * @param pools
       * @return
       */
      public List<KpiIndicatorRankStaffVO> getNoTargetIndicatorRanks(String indicatorCode, LocalDate localDate, List<KpiPool> pools) {
          Set<Long> userIds = pools.stream().map(KpiPool::getUserId).collect(Collectors.toSet());

          List<IndicatorUserValueVO> indicatorUserValues = indicatorUserValueService.getStaffReportData(indicatorCode, YearMonth.from(localDate), userIds);

          Map<Long, IndicatorUserValueVO> indicatorUserValueMap = indicatorUserValues.stream()
                  .collect(Collectors.toMap(IndicatorUserValueVO::getUserId, Function.identity(), (v1, v2) -> v1));
  
          List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorUserValues.size());
          for (KpiPool kpiPool : pools) {
              KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();
  
              rankStaffVO.setUserId(kpiPool.getUserId());
              rankStaffVO.setUserName(kpiPool.getUserName());
              rankStaffVO.setPostId(kpiPool.getPostId());
              rankStaffVO.setPostName(kpiPool.getPostName());
              rankStaffVO.setShopId(kpiPool.getShopId());
              rankStaffVO.setShopName(kpiPool.getShopName());
              rankStaffVO.setInclusion(kpiPool.getInclusion());
  
              if (indicatorUserValueMap.containsKey(kpiPool.getUserId())) {
                  IndicatorUserValueVO indicatorUserValueVO = indicatorUserValueMap.get(kpiPool.getUserId());
                  rankStaffVO.setOriginValue(commonService.queryIndicatorValueVO(indicatorCode, indicatorUserValueVO));
  
              }
              staffRanks.add(rankStaffVO);
          }
          Collections.sort(staffRanks);

          calcRank(staffRanks);

          return staffRanks;

      }

  
      /**
       * 有目标指标排名
       *
       * @param referId
       * @param localDate
       * @param pools
       * @param indicatorTypeEnum
       * @return
       */
      public List<KpiIndicatorRankStaffVO> getTargetIndicatorRanks(Long referId,
                                                                   LocalDate localDate,
                                                                   List<KpiPool> pools,
                                                                   IndicatorTypeEnum indicatorTypeEnum,

                                                                   Indicators indicators) {

          Set<Long> userIds = pools.stream().map(KpiPool::getUserId).collect(Collectors.toSet());
          List<KpiGroupIndicatorTargetHitLogVO> indicatorTargetHitLogs = kpiGroupIndicatorTargetHitLogService.getIndicatorData(referId,
                  YearMonth.from(localDate), indicatorTypeEnum, userIds);
  
          Map<Long, KpiGroupIndicatorTargetHitLogVO> indicatorTargetMap = indicatorTargetHitLogs.stream()
                  .collect(Collectors.toMap(KpiGroupIndicatorTargetHitLogVO::getUserId, Function.identity(), (v1, v2) -> v1));
  
          List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorTargetMap.size());
          for (KpiPool kpiPool : pools) {
              KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();
  
              rankStaffVO.setUserId(kpiPool.getUserId());
              rankStaffVO.setUserName(kpiPool.getUserName());
              rankStaffVO.setPostId(kpiPool.getPostId());
              rankStaffVO.setPostName(kpiPool.getPostName());
              rankStaffVO.setShopId(kpiPool.getShopId());
              rankStaffVO.setShopName(kpiPool.getShopName());
              rankStaffVO.setInclusion(kpiPool.getInclusion());
  
              if (indicatorTargetMap.containsKey(kpiPool.getUserId())) {
                  KpiGroupIndicatorTargetHitLogVO targetHitLogVO = indicatorTargetMap.get(kpiPool.getUserId());

                  rankStaffVO.setOriginValue(targetHitLogVO.getValue());
                  rankStaffVO.setReachValue(targetHitLogVO.getReachValue());

                  rankStaffVO.convertReportValueToPercent(indicators.getDataType());

              }
              staffRanks.add(rankStaffVO);
          }
  
          Collections.sort(staffRanks);

          calcRank(staffRanks);

          return staffRanks;
      }
  

      /**
       * 设置排名序号
       *
       * @return
       */
      public void calcRank(List<KpiIndicatorRankStaffVO> staffs) {

          int rank = 1;

          Optional<BigDecimal> lastIndicatorValueOp = staffs.stream()
                  .filter(staff -> Boolean.TRUE.equals(staff.getInclusion()))
                  .findFirst().map(KpiIndicatorRankStaffVO::getOriginValue);
          if (Boolean.FALSE.equals(lastIndicatorValueOp.isPresent())) {
              return;
          }
          BigDecimal lastIndicatorValue = lastIndicatorValueOp.get();

          for (KpiIndicatorRankStaffVO staff : staffs) {

              if (! staff.getInclusion()) {
                  continue;
              }

              //原始值为空，无排名
              if (PublicUtil.isEmpty(staff.getOriginValue())) {

                  continue;
              }
              if (lastIndicatorValue.compareTo(staff.getOriginValue()) != 0) {

                  rank++;
              }
              staff.setIndicatorRank(rank);
              lastIndicatorValue = staff.getOriginValue();
          }
  
      }
  

  }