KPI / fw-morax

  package cn.fw.morax.service.biz.eval;
  
  import cn.fw.common.exception.BusinessException;

  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.eval.*;

  import cn.fw.morax.domain.db.kpi.*;
  import cn.fw.morax.domain.dto.eval.EvalGroupIndicatorRankDTO;

  import cn.fw.morax.domain.dto.eval.EvalUserRankDTO;

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

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

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

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

  import cn.fw.morax.domain.vo.kpi.IndicatorUserValueVO;
  import cn.fw.morax.domain.vo.kpi.KpiIndicatorRankStaffVO;
  import cn.fw.morax.domain.vo.kpi.KpiIndicatorRankVO;

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

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

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

  import com.alibaba.fastjson.JSON;

  import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

  import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  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.math.RoundingMode;
  import java.text.DecimalFormat;
  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;
  
  @Service
  @Slf4j
  @RequiredArgsConstructor
  public class EvalGroupPoolService {
  
      private final EvalGroupIndicatorPreconditionLaddersService evalGroupIndicatorPreconditionLaddersService;

      private final EvalGroupRewardPreconditionHitLogService evalGroupRewardPreconditionHitLogService;

      private final EvalGroupIndicatorPreconditionService evalGroupIndicatorPreconditionService;

      private final EvalGroupIndicatorTargetHitLogService evalGroupIndicatorTargetHitLogService;

      private final EvalGroupRewardTargetHitLogService evalGroupRewardTargetHitLogService;

      private final EvalGroupRewardPreconditionService evalGroupRewardPreconditionService;

      private final EvalGroupIndicatorLaddersService evalGroupIndicatorLaddersService;

      private final EvalGroupIndicatorHitLogService evalGroupIndicatorHitLogService;
      private final EvalPoolIndicatorDetailService evalPoolIndicatorDetailService;

      private final EvalGroupIndicatorParamService evalGroupIndicatorParamService;
      private final EvalGroupRewardLaddersService evalGroupRewardLaddersService;

      private final EvalPoolRewardDetailService evalPoolRewardDetailService;

      private final EvalGroupRewardParamService evalGroupRewardParamService;

      private final EvalGroupRewardRankLogService evalGroupRewardRankLogService;

      private final EvalGroupRewardHitLogService evalGroupRewardHitLogService;

      private final IndicatorUserValueService indicatorUserValueService;
      private final EvalIndicatorValueService evalIndicatorValueService;

      private final EvalGroupUserService evalGroupUserService;

      private final EvalGroupRewardService evalGroupRewardService;

      private final EvalGroupRankStageService evalGroupRankStageService;
      private final EvalGroupRankService evalGroupRankService;

      private final EvalGroupService evalGroupService;

      private final EvalUserPoolService evalUserPoolService;

      private final EvalShopPoolService evalShopPoolService;

      private final CommonService commonService;
      private final EvalService evalService;

  
      /**
       * 查询考评详情
       *

       * @return
       */

      public EvalShopPoolVO queryShopPoolDetail(final Long poolId) {
          EvalShopPool evalShopPool = evalShopPoolService.getById(poolId);
          if (PublicUtil.isEmpty(evalShopPool)) {
              throw new BusinessException("人员考评数据不存在");
          }
          return shopPoolDetail(evalShopPool);
      }
  
      public EvalShopPoolVO shopPoolDetail(EvalShopPool pool) {
          EvalShopPoolVO evalShopPoolVO = PublicUtil.copy(pool, EvalShopPoolVO.class);

          evalShopPoolVO.convertScoreRatio();

  
          LocalDate dataDate = evalShopPoolVO.getDataDate();
  
          this.setShopIndicatorDetails(evalShopPoolVO, dataDate);
          this.setShopRewardDetails(evalShopPoolVO, dataDate);
          evalShopPoolVO.setDataDate(dataDate);
  
          Eval eval = evalService.getById(pool.getEvalId());
          BV.notNull(pool, "考评池不存在");
          evalShopPoolVO.setEvalType(eval.getType());
  
          return evalShopPoolVO;
      }
  
      /**
       * 查询考评详情
       *
       * @return
       */

      public List<EvalUserRankStageVO> queryRankStagePools(EvalUserRankDTO dto) {
          final Long userId = dto.getUserId();
          final Long postId = dto.getPostId();
          final Long shopId = dto.getShopId();
          final Long evalGroupRankId = dto.getEvalGroupRankId();

          List<EvalUserPool> pools = evalUserPoolService.list(Wrappers.<EvalUserPool>lambdaQuery()

                  .eq(EvalUserPool::getPostId, postId)
                  .eq(EvalUserPool::getShopId, shopId)

                  .eq(EvalUserPool::getUserId, userId)
                  .eq(EvalUserPool::getEvalGroupRankId, evalGroupRankId)
                  .eq(EvalUserPool::getYn, Boolean.TRUE)
                  .orderByDesc(EvalUserPool::getScoreRatio)
          );

          Map<Long, List<EvalUserPool>> stagePoolMap = pools.stream().collect(Collectors.groupingBy(EvalUserPool::getEvalGroupRankStageId));
          List<Long> evalGroupRankStageIds = pools.stream().map(EvalUserPool::getEvalGroupRankStageId).collect(Collectors.toList());

  
          List<EvalGroupRankStage> stages = evalGroupRankStageService.list(Wrappers.<EvalGroupRankStage>lambdaQuery()

                  .in(EvalGroupRankStage::getId, evalGroupRankStageIds)

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

                  .orderByAsc(EvalGroupRankStage::getBeginTime)

          );
  

          List<EvalUserRankStageVO> stageVos = PublicUtil.copyList(stages, EvalUserRankStageVO.class);
          for (EvalUserRankStageVO stageVO : stageVos) {
              List<EvalUserPool> rankPools = stagePoolMap.get(stageVO.getId());
              if (PublicUtil.isNotEmpty(rankPools)) {
                  EvalUserPool stagePool = rankPools.get(0);

                  EvalUserPoolVO evalUserPoolVO = this.poolDetail(stagePool);

                  this.setRewardPunish(evalUserPoolVO);

                  stageVO.setPool(evalUserPoolVO);
              }

          }

          return stageVos;

      }
  

      public EvalUserPoolVO poolDetail(EvalUserPool pool) {
          EvalUserPoolVO evalUserPoolVO = PublicUtil.copy(pool, EvalUserPoolVO.class);

          evalUserPoolVO.convertScoreRatio();

  
          LocalDate localDate = getPoolLastData(evalUserPoolVO);
  

          this.setIndicatorDetails(evalUserPoolVO, localDate);
          this.setRewardDetails(evalUserPoolVO, localDate);
          this.setIgnore(evalUserPoolVO);

          evalUserPoolVO.setDataDate(localDate);

          return evalUserPoolVO;
      }
  

      public void setRewardPunish(EvalUserPoolVO evalUserPoolVO) {
          evalUserPoolVO.setRewardScore(BigDecimal.ZERO);
          evalUserPoolVO.setPunishScore(BigDecimal.ZERO);
          evalUserPoolVO.setOriginScore(evalUserPoolVO.getScore());
      }
  

      public void setIgnore(EvalUserPoolVO pool) {
          EvalGroupUser evalGroupUser = evalGroupUserService.getMonthLastData(pool.getEvalGroupId(), pool.getUserId(), pool.getMonthly());
          if (PublicUtil.isEmpty(evalGroupUser)) {
              log.error("考评人员数据未找到，{}", JSON.toJSONString(pool));
              pool.setInclusion(Boolean.TRUE);
              return;
          }
          //不纳入绩效计算 并且 绩效组人员不为空
          pool.setInclusion(Boolean.FALSE.equals(evalGroupUser.getIgnored()));
          pool.setIgnoreCause(evalGroupUser.getIgnoreCause());
  
      }
  

      public void setIndicatorDetails(EvalUserPoolVO pool, LocalDate localDate) {
          Long evalGroupId = pool.getEvalGroupId();
          Long poolId = pool.getId();
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");
  

          List<EvalPoolIndicatorDetailVO> indicatorDetails = evalPoolIndicatorDetailService.getStaffIndicatorValues(poolId, evalGroupId, localDate);

  
          BigDecimal totalScore = BigDecimal.ZERO;
          BigDecimal staffScore = BigDecimal.ZERO;
          BigDecimal baseScore;
          for (EvalPoolIndicatorDetailVO indicatorValueVO : indicatorDetails) {
              baseScore = new BigDecimal(indicatorValueVO.getBaseScore());
              totalScore = totalScore.add(baseScore);
              staffScore = staffScore.add(indicatorValueVO.getScore());
  
              indicatorValueVO.setScoreFormat(decimalFormat.format(indicatorValueVO.getScore()));

              if (BigDecimal.ZERO.compareTo(indicatorValueVO.getScore()) == 0 || BigDecimal.ZERO.compareTo(baseScore) == 0) {
                  indicatorValueVO.setScoreRatioFormat("0");

                  continue;

              }

              BigDecimal indicatorScoreRatio = indicatorValueVO.getScore().divide(baseScore, 2, RoundingMode.DOWN).multiply(Constant.ONE_HUNDRED);
              indicatorValueVO.setScoreRatioFormat(decimalFormat.format(indicatorScoreRatio));
          }

          BigDecimal staffScoreRatio = (BigDecimal.ZERO.compareTo(totalScore) == 0) ? BigDecimal.ZERO :
                  staffScore.divide(totalScore, 2, RoundingMode.DOWN).multiply(Constant.ONE_HUNDRED);

          pool.setScoreRatioFormat(decimalFormat.format(staffScoreRatio));
          pool.setIndicators(indicatorDetails);

          pool.setScoreRatio(staffScoreRatio);
          pool.setTotalScore(totalScore);

      }
  

      public void setShopIndicatorDetails(EvalShopPoolVO pool, LocalDate localDate) {
          Long evalGroupId = pool.getEvalGroupId();
          Long poolId = pool.getId();
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");
  

          List<EvalPoolIndicatorDetailVO> indicatorDetails = evalPoolIndicatorDetailService.getShopIndicatorValues(poolId, evalGroupId, localDate);

  
          BigDecimal totalScore = BigDecimal.ZERO;
          BigDecimal staffScore = BigDecimal.ZERO;
          BigDecimal baseScore;
          for (EvalPoolIndicatorDetailVO indicatorValueVO : indicatorDetails) {
              baseScore = new BigDecimal(indicatorValueVO.getBaseScore());
              totalScore = totalScore.add(baseScore);
              staffScore = staffScore.add(indicatorValueVO.getScore());
  
              indicatorValueVO.setScoreFormat(decimalFormat.format(indicatorValueVO.getScore()));
              BigDecimal indicatorScoreRatio = indicatorValueVO.getScore().divide(baseScore, 2, RoundingMode.DOWN).multiply(Constant.ONE_HUNDRED);
              indicatorValueVO.setScoreRatioFormat(decimalFormat.format(indicatorScoreRatio));
          }

          pool.setScoreRatioFormat(decimalFormat.format(pool.getScoreRatio()));

          pool.setIndicators(indicatorDetails);

          pool.setTotalScore(totalScore);
      }
  

      public void setRewardDetails(EvalUserPoolVO pool, LocalDate localDate) {
          Long evalGroupId = pool.getEvalGroupId();
          Long poolId = pool.getId();
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");
  

          List<EvalPoolRewardDetailVO> rewardValues = evalPoolRewardDetailService.getStaffRewardValues(poolId, evalGroupId, localDate);

  
          BigDecimal totalReward = BigDecimal.ZERO;
          for (EvalPoolRewardDetailVO rewardValue : rewardValues) {
              totalReward = totalReward.add(rewardValue.getAmount());
          }
  
          pool.setReward(totalReward);
          pool.setRewards(rewardValues);
      }
  

      public void setShopRewardDetails(EvalShopPoolVO pool, LocalDate localDate) {
          Long evalGroupId = pool.getEvalGroupId();
          Long poolId = pool.getId();
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");
  
          List<EvalPoolRewardDetailVO> rewardValues = evalPoolRewardDetailService.getStaffRewardValues(poolId, evalGroupId, localDate);
  
          BigDecimal totalReward = BigDecimal.ZERO;
          for (EvalPoolRewardDetailVO rewardValue : rewardValues) {
              totalReward = totalReward.add(rewardValue.getAmount());
          }
  
          pool.setReward(totalReward);
          pool.setRewards(rewardValues);
      }
  

  
      /**
       * 查询用户绩效池
       *
       * @param userId
       * @param yearMonth
       * @return
       */

      public EvalPoolVO evalPoolSelector(Long userId, YearMonth yearMonth) {

          List<EvalUserPool> pools = userEvalPool(userId, yearMonth);
          if (CollectionUtils.isEmpty(pools)) {

              return null;

          }

          String userName = pools.stream().findFirst().map(EvalUserPool::getUserName).orElse("");

          List<EvalSelectorVO> selectors = new ArrayList<>();

          EvalPoolVO evalPoolVO = new EvalPoolVO(userId, userName, selectors);

          Map<Long, String> rankNameMap = this.getRankNameMap(pools);
          Map<String, List<EvalUserPool>> shopPostMap = pools.stream().collect(Collectors.groupingBy(pool -> pool.getShopName() + "(" + pool.getPostName() + ")"));
          //门店、岗位维度
          for (Map.Entry<String, List<EvalUserPool>> shopPostEntry : shopPostMap.entrySet()) {

              List<EvalUserGroupRankVO> ranks = new ArrayList<>();

              List<EvalUserPool> shopPostPools = shopPostEntry.getValue();
              Long shopId = shopPostPools.stream().findFirst().map(EvalUserPool::getShopId).get();
              Long postId = shopPostPools.stream().findFirst().map(EvalUserPool::getPostId).get();
              Map<Long, List<EvalUserPool>> rankPools = shopPostPools.stream().collect(Collectors.groupingBy(EvalUserPool::getEvalGroupRankId));
              //排名维度

              for (Map.Entry<Long, List<EvalUserPool>> rankEntry : rankPools.entrySet()) {

                  List<EvalUserPool> userRankPools = rankEntry.getValue();
                  double averageKpiScoreRatio = userRankPools.stream()
                          .mapToDouble(r -> Optional.ofNullable(r.getScoreRatio()).orElse(BigDecimal.ZERO).doubleValue())
                          .average()
                          .orElse(0);
                  BigDecimal reward = userRankPools.stream().map(EvalUserPool::getReward).reduce(BigDecimal.ZERO, BigDecimal::add);
                  EvalUserGroupRankVO rank = new EvalUserGroupRankVO();
                  rank.setEvalGroupRankName(rankNameMap.getOrDefault(rankEntry.getKey(), ""));
                  rank.setScoreRatio(new BigDecimal(averageKpiScoreRatio).multiply(Constant.ONE_HUNDRED));
                  rank.setReward(reward);

                  rank.setEvalGroupRankId(rankEntry.getKey());

                  ranks.add(rank);
              }
              EvalSelectorVO evalSelectorVO = new EvalSelectorVO(shopPostEntry.getKey(), ranks);

              evalSelectorVO.setShopId(shopId);
              evalSelectorVO.setPostId(postId);

              selectors.add(evalSelectorVO);
          }

          return evalPoolVO;

      }
  
      public Map<Long, String> getRankNameMap(List<EvalUserPool> pools) {
          List<Long> evalGroupRankIds = pools.stream().map(EvalUserPool::getEvalGroupRankId).distinct().collect(Collectors.toList());
          List<EvalGroupRank> evalGroupRanks = evalGroupRankService.list(Wrappers.<EvalGroupRank>lambdaQuery()
                  .in(EvalGroupRank::getId, evalGroupRankIds)
                  .eq(EvalGroupRank::getYn, Boolean.TRUE)
          );
          if (PublicUtil.isEmpty(evalGroupRanks)) {
              return new HashMap<>();

          }

          return evalGroupRanks.stream().collect(Collectors.toMap(EvalGroupRank::getId, EvalGroupRank::getName, (v1, v2) -> v1));

      }
  

      /**
       * 查询用户绩效池
       *
       * @param userId
       * @param yearMonth
       * @return
       */
  //    public Set<SelectorVO> evalPoolSelector(Long userId, YearMonth yearMonth) {
  //        List<EvalUserPool> pools = userEvalPool(userId, yearMonth);
  //        if (CollectionUtils.isEmpty(pools)) {
  //            return new HashSet<>();
  //        }
  //        return pools.stream().map(r -> SelectorVO.whit(r.getId(), r.getPostName(),  r.getShopName() + "")).collect(Collectors.toSet());
  //    }
  

      /**
       * 查询用户月度绩效池列表
       *
       * @param userId    用户id
       * @param yearMonth 月度
       * @return 返回结果
       */
      public List<EvalUserPool> userEvalPool(final Long userId, final YearMonth yearMonth) {
          List<EvalUserPool> pools = evalUserPoolService.list(Wrappers.<EvalUserPool>lambdaQuery()
                  .eq(EvalUserPool::getUserId, userId)
                  .eq(EvalUserPool::getMonthly, yearMonth)
                  .eq(EvalUserPool::getYn, Boolean.TRUE)
                  .orderByDesc(EvalUserPool::getCreateTime)
          );
          if (CollectionUtils.isEmpty(pools)) {
              return new ArrayList<>();
          }
          return pools;
      }
  
      /**
       * 获取绩效池详情最近日期
       *
       * @param pool
       * @return
       */
      public LocalDate getPoolLastData(EvalUserPoolVO pool) {
          List<EvalGroupUser> users = evalGroupUserService.list(Wrappers.<EvalGroupUser>lambdaQuery()
                  .eq(EvalGroupUser::getEvalGroupId, pool.getEvalGroupId())
                  .eq(EvalGroupUser::getYn, Boolean.TRUE)
                  .orderByDesc(EvalGroupUser::getDataDate)
          );
  
          BV.isNotEmpty(users, "考评组为空");
  
          return users.stream().findFirst().get().getDataDate();
      }
  

      public EvalPoolIndicatorDetailVO staffHitIndicatorDetail(Long evalPoolId, Long evalGroupIndicatorId, LocalDate dataDate) {
          EvalUserPool pool = evalUserPoolService.getById(evalPoolId);

          if (PublicUtil.isEmpty(pool)) {
              return null;
          }

          Long userId = pool.getUserId();
          return getHitIndicatorDetail(evalPoolId, EvalScopeEnum.STAFF, userId, evalGroupIndicatorId, dataDate);
      }
  
      public EvalPoolIndicatorDetailVO shopHitIndicatorDetail(Long evalPoolId, Long evalGroupIndicatorId, LocalDate dataDate) {
          EvalShopPool pool = evalShopPoolService.getById(evalPoolId);

          if (PublicUtil.isEmpty(pool)) {
              return null;
          }
  //        BV.notNull(pool, "考评池不存在");

          Long userId = pool.getShopId();
          return getHitIndicatorDetail(evalPoolId, EvalScopeEnum.SHOP, userId, evalGroupIndicatorId, dataDate);
      }

      /**
       * 员工考评得分详情
       *
       * @param evalPoolId
       * @param evalGroupIndicatorId
       * @return
       */

      public EvalPoolIndicatorDetailVO getHitIndicatorDetail(Long evalPoolId, EvalScopeEnum scopeType, Long referId, Long evalGroupIndicatorId, LocalDate dataDate) {

          EvalPoolIndicatorDetailVO indicatorDetail = evalPoolIndicatorDetailService.getIndicatorValue(evalPoolId, scopeType, evalGroupIndicatorId, dataDate);

          BV.notNull(indicatorDetail, "考评指标明细不存在");

  
          //命中记录

          Optional<EvalGroupIndicatorHitLog> hitLog = evalGroupIndicatorHitLogService.getHitLog(evalGroupIndicatorId,

                  evalPoolId, scopeType, dataDate);

          indicatorDetail.setHitLadderValue(hitLog.map(EvalGroupIndicatorHitLog::getHitLadderValue).orElse(BigDecimal.ZERO));
          indicatorDetail.setHitCommissionValue(hitLog.map(EvalGroupIndicatorHitLog::getHitCommissionValue).orElse(BigDecimal.ZERO));

          Long hitLadderId = hitLog.map(EvalGroupIndicatorHitLog::getEvalGroupIndicatorLaddersId).orElse(0L);

          //阶梯

          if (ScoreWayEnum.LADDER.equals(indicatorDetail.getScoreWay())) {

              indicatorDetail.setLadders(getIndicatorLadders(evalGroupIndicatorId, hitLadderId, indicatorDetail.getLaddersType()));

          }
  

          //参数
          Map<ParamTypeEnum, List<EvalGroupIndicatorParamVO>> paramMap = this.getEvalGroupIndicatorParamMap(evalGroupIndicatorId,

                  referId, evalPoolId, scopeType, dataDate);

          indicatorDetail.setLadderParams(paramMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));
          indicatorDetail.setCommissionParams(paramMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));
  
  
          //条件

          List<EvalGroupIndicatorPreconditionVO> preconditionVOS = this.getHitPreconditionVo(evalGroupIndicatorId,

                  referId, evalPoolId, scopeType, dataDate);

          indicatorDetail.setConds(preconditionVOS);

  
          //处理百分数
          processPercent(indicatorDetail);
          return indicatorDetail;
      }
  
      public List<EvalGroupIndicatorPreconditionVO> getHitPreconditionVo(Long evalGroupIndicatorId,
                                                                         Long referId,
                                                                         Long evalPoolId,
                                                                         EvalScopeEnum scopeType,
                                                                         LocalDate dataDate) {

          List<EvalGroupIndicatorPreconditionVO> preconditionVOS = evalGroupIndicatorPreconditionService.getConds(evalPoolId, scopeType, evalGroupIndicatorId, dataDate);

          for (EvalGroupIndicatorPreconditionVO preconditionVO : preconditionVOS) {
              //有目标记录
              if (! TargetTypeEnum.NO.equals(preconditionVO.getTargetType())) {
                  EvalGroupIndicatorTargetHitLog evalGroupIndicatorTargetHitLog = evalGroupIndicatorTargetHitLogService.getOne(Wrappers.<EvalGroupIndicatorTargetHitLog>lambdaQuery()
                          .eq(EvalGroupIndicatorTargetHitLog::getReferId, preconditionVO.getId())
                          .eq(EvalGroupIndicatorTargetHitLog::getTargetType, IndicatorTypeEnum.PRE)
                          .eq(EvalGroupIndicatorTargetHitLog::getDataDate, dataDate)
                          .eq(EvalGroupIndicatorTargetHitLog::getPoolId, evalPoolId)

                          .eq(EvalGroupIndicatorTargetHitLog::getScopeType, scopeType)

                          .eq(EvalGroupIndicatorTargetHitLog::getYn, Boolean.TRUE)
                  );
                  Optional<EvalGroupIndicatorTargetHitLog> targetHitLog = Optional.ofNullable(evalGroupIndicatorTargetHitLog);
                  preconditionVO.setReachValue(targetHitLog.map(EvalGroupIndicatorTargetHitLog::getReachValue).orElse(BigDecimal.ZERO));
                  preconditionVO.setIndicatorValue(targetHitLog.map(EvalGroupIndicatorTargetHitLog::getValue).orElse(BigDecimal.ZERO));

              } else {

                  BigDecimal indicatorOriginValue = queryUserOriginValue(preconditionVO.getCode(), referId, scopeType, dataDate, preconditionVO.getCodeType());

                  preconditionVO.setIndicatorValue(indicatorOriginValue);

              }
  
              //条件阶梯
              List<EvalGroupIndicatorPreconditionLaddersVO> preconditionLaddersVOS = evalGroupIndicatorPreconditionLaddersService.getVOS(
                      preconditionVO.getId(), preconditionVO.getTargetType(), preconditionVO.getDataType());

              Long hitLaddersId = preconditionVO.getHitLaddersId();

              for (EvalGroupIndicatorPreconditionLaddersVO preconditionLaddersVO : preconditionLaddersVOS) {

                  if (PublicUtil.isNotEmpty(hitLaddersId) && preconditionLaddersVO.getId().equals(hitLaddersId)) {

                      preconditionLaddersVO.setHit(Boolean.TRUE);
                  }
              }
              preconditionVO.setLadders(preconditionLaddersVOS);
          }

          return preconditionVOS;

      }
  

      public List<EvalGroupIndicatorLaddersVO>  getIndicatorLadders(Long evalGroupIndicatorId, Long hitLadderId, DataTypeEnum laddersType) {
          List<EvalGroupIndicatorLadders> ladders = evalGroupIndicatorLaddersService.list(Wrappers.<EvalGroupIndicatorLadders>lambdaQuery()
                  .eq(EvalGroupIndicatorLadders::getEvalGroupIndicatorId, evalGroupIndicatorId)
                  .eq(EvalGroupIndicatorLadders::getYn, Boolean.TRUE)
                  .orderByAsc(EvalGroupIndicatorLadders::getLower)
          );
          BV.isNotEmpty(ladders, "阶梯配置为空");
          List<EvalGroupIndicatorLaddersVO> laddersVOS = PublicUtil.copyList(ladders, EvalGroupIndicatorLaddersVO.class);
  
          for (EvalGroupIndicatorLaddersVO laddersVO : laddersVOS) {
              laddersVO.setHit(hitLadderId.equals(laddersVO.getId()) ? Boolean.TRUE : Boolean.FALSE);
              laddersVO.convertLadderToPercent(laddersType);
          }
          return laddersVOS;
      }
  

      public void processPercent(EvalPoolIndicatorDetailVO detail) {
          //提成
          for (EvalGroupIndicatorParamVO paramVO : Optional.ofNullable(detail.getCommissionParams()).orElse(new ArrayList<>())) {
              //指标原始值
              if (DataTypeEnum.RATIO.equals(paramVO.getDataType())) {
                  paramVO.setIndicatorValue(Optional.ofNullable(paramVO.getIndicatorValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
              //有目标
              if (! TargetTypeEnum.NO.equals(paramVO.getTargetType())) {
                  paramVO.setReachValue(Optional.ofNullable(paramVO.getReachValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
          }
  
          for (EvalGroupIndicatorParamVO paramVO : Optional.ofNullable(detail.getLadderParams()).orElse(new ArrayList<>())) {
              //指标原始值
              if (DataTypeEnum.RATIO.equals(paramVO.getDataType())) {
                  paramVO.setIndicatorValue(Optional.ofNullable(paramVO.getIndicatorValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
              //有目标
              if (! TargetTypeEnum.NO.equals(paramVO.getTargetType())) {
                  paramVO.setReachValue(Optional.ofNullable(paramVO.getReachValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
          }
  
          for (EvalGroupIndicatorPreconditionVO preconditionVO : Optional.ofNullable(detail.getConds()).orElse(new ArrayList<>())) {
              //指标原始值
              if (DataTypeEnum.RATIO.equals(preconditionVO.getDataType())) {
                  preconditionVO.setIndicatorValue(Optional.ofNullable(preconditionVO.getIndicatorValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
              //有目标
              if (! TargetTypeEnum.NO.equals(preconditionVO.getTargetType())) {
                  preconditionVO.setReachValue(Optional.ofNullable(preconditionVO.getReachValue()).orElse(BigDecimal.ZERO).multiply(Constant.ONE_HUNDRED));
              }
          }

      }
  
  
      /**
       * 获取绩效参数
       *
       * @param evalGroupIndicatorId
       * @param dataDate
       * @return
       */
      public Map<ParamTypeEnum, List<EvalGroupIndicatorParamVO>> getEvalGroupIndicatorParamMap(Long evalGroupIndicatorId,

                                                                                               Long referId,
                                                                                               Long evalPoolId,
                                                                                               EvalScopeEnum scopeType,

                                                                                               LocalDate dataDate) {

          List<EvalGroupIndicatorParamVO> paramVos = evalGroupIndicatorParamService.getParamVos(evalGroupIndicatorId);

          Map<Long, EvalGroupIndicatorTargetHitLog> paramTargetHitLogMap = this.getParamHitMap(evalPoolId,
                  scopeType, dataDate, paramVos);

  
          for (EvalGroupIndicatorParamVO paramVO : paramVos) {
              String code = paramVO.getCode();
              Long paramId = paramVO.getId();
              //无目标

  //            if (TargetTypeEnum.NO.equals(paramVO.getTargetType())) {
  //                BigDecimal indicatorOriginValue = queryUserOriginValue(code, referId, scopeType,dataDate, paramVO.getCodeType());
  //                paramVO.setIndicatorValue(indicatorOriginValue);
  //                continue;
  //            }

  
              //有目标
              Optional<EvalGroupIndicatorTargetHitLog> hitLogOptional = Optional.ofNullable(paramTargetHitLogMap.get(paramId));
              paramVO.setIndicatorValue(hitLogOptional.map(EvalGroupIndicatorTargetHitLog::getValue).orElse(BigDecimal.ZERO));
              paramVO.setReachValue(hitLogOptional.map(EvalGroupIndicatorTargetHitLog::getReachValue).orElse(BigDecimal.ZERO));

              paramVO.setExtraReachValue(hitLogOptional.map(EvalGroupIndicatorTargetHitLog::getReachValue).orElse(BigDecimal.ZERO));
              paramVO.setUseTarget(hitLogOptional.map(EvalGroupIndicatorTargetHitLog::getUseTarget).orElse(EvalUseTargetEnum.NO));

          }
  
          Map<ParamTypeEnum, List<EvalGroupIndicatorParamVO>> indicatorParamMap = paramVos.stream()
                  .collect(Collectors.groupingBy(EvalGroupIndicatorParamVO::getParamType));
          return indicatorParamMap;
      }
  

      public Map<Long, EvalGroupIndicatorTargetHitLog> getParamHitMap(Long poolId,
                                                                      EvalScopeEnum scopeType,
                                                                      LocalDate dataDate,
                                                                      List<EvalGroupIndicatorParamVO> paramVos) {

  //        List<Long> hasTargetParamIds = paramVos.stream()
  //                .filter(param -> (! TargetTypeEnum.NO.equals(param.getTargetType())))
  //                .map(EvalGroupIndicatorParamVO::getId).collect(Collectors.toList());

  
          Map<Long, EvalGroupIndicatorTargetHitLog> paramTargetHitLogMap = new HashMap<>();

          List<EvalGroupIndicatorTargetHitLog> targetHitLogs = evalGroupIndicatorTargetHitLogService.list(Wrappers.<EvalGroupIndicatorTargetHitLog>lambdaQuery()
  //                .in(EvalGroupIndicatorTargetHitLog::getReferId, hasTargetParamIds)
                  .in(EvalGroupIndicatorTargetHitLog::getTargetType, IndicatorTypeEnum.EXAMINE)
                  .eq(EvalGroupIndicatorTargetHitLog::getDataDate, dataDate)
                  .eq(EvalGroupIndicatorTargetHitLog::getPoolId, poolId)
                  .eq(EvalGroupIndicatorTargetHitLog::getScopeType, scopeType)
                  .eq(EvalGroupIndicatorTargetHitLog::getYn, Boolean.TRUE)
          );
          paramTargetHitLogMap = targetHitLogs.stream()
                  .collect(Collectors.toMap(EvalGroupIndicatorTargetHitLog::getReferId, Function.identity(), (v1, v2) -> v1));

          return paramTargetHitLogMap;
      }

      public BigDecimal queryUserOriginValue(String code, Long referId, EvalScopeEnum scopeType, LocalDate dataDate, IndicatorCodeTypeEnum codeType) {
          DimensionTypeEnum dimensionType = (EvalScopeEnum.STAFF.equals(scopeType)) ? DimensionTypeEnum.STAFF : DimensionTypeEnum.SHOP;

          //无目标
          if (IndicatorCodeTypeEnum.INDICATOR.equals(codeType)) {

              LambdaQueryWrapper<IndicatorUserValue> queryWrapper = Wrappers.<IndicatorUserValue>lambdaQuery();
              if (EvalScopeEnum.STAFF.equals(scopeType)) {
                  queryWrapper.eq(IndicatorUserValue::getUserId, referId);
              } else {
                  queryWrapper.eq(IndicatorUserValue::getShopId, referId);
              }
              IndicatorUserValue indicatorUserValue = indicatorUserValueService.getOne(queryWrapper
                              .eq(IndicatorUserValue::getIndicatorCode, code)

                              .eq(IndicatorUserValue::getDataDate, dataDate)

                              .eq(IndicatorUserValue::getDimensionType, dimensionType)

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

                      , Boolean.FALSE
              );
              BigDecimal indicatorOriginValue = commonService.queryIndicatorValue(code, indicatorUserValue);
              return indicatorOriginValue;
          } else {

  
              EvalIndicatorValue evalIndicatorValue = evalIndicatorValueService.queryLastValue(referId,
                      dimensionType, code, dataDate);

              BigDecimal indicatorOriginValue = commonService.queryEvalIndicatorValue(code, evalIndicatorValue);
              return indicatorOriginValue;

          }

      }
  

      public EvalPoolRewardDetailVO staffHitRewardDetail(Long evalPoolId, Long evalGroupRewardId, LocalDate dataDate) {
          EvalUserPool pool = evalUserPoolService.getById(evalPoolId);
          BV.notNull(pool, "考评池不存在");
          Long userId = pool.getUserId();
          return getHitRewardDetail(evalPoolId, EvalScopeEnum.STAFF, userId, evalGroupRewardId, dataDate);
      }
  
      public EvalPoolRewardDetailVO shopHitRewardDetail(Long evalPoolId, Long evalGroupRewardId, LocalDate dataDate) {
          EvalShopPool pool = evalShopPoolService.getById(evalPoolId);
          BV.notNull(pool, "考评池不存在");
          Long referId = pool.getShopId();
          return getHitRewardDetail(evalPoolId, EvalScopeEnum.SHOP, referId, evalGroupRewardId, dataDate);
      }
  

      /**

       * 奖惩详情

       *
       * @param evalPoolId
       * @param evalGroupRewardId
       * @param dataDate
       * @return
       */

      public EvalPoolRewardDetailVO getHitRewardDetail(Long evalPoolId, EvalScopeEnum scopeType, Long referId,  Long evalGroupRewardId, LocalDate dataDate) {

          EvalPoolRewardDetailVO reward = evalPoolRewardDetailService.getStaffRewardValue(evalPoolId, evalGroupRewardId, dataDate);

          BV.notNull(reward, "考评奖惩明细不存在");

          //命中记录

          Optional<EvalGroupRewardHitLog> hitLog = this.getRewardHitLog(evalGroupRewardId, evalPoolId, scopeType, dataDate);

          reward.setHitLadderValue(hitLog.map(EvalGroupRewardHitLog::getHitLadderValue).orElse(BigDecimal.ZERO));
          reward.setHitCommissionValue(hitLog.map(EvalGroupRewardHitLog::getHitCommissionValue).orElse(BigDecimal.ZERO));

          reward.setProportionValue(hitLog.map(EvalGroupRewardHitLog::getProportionValue).orElse(BigDecimal.ZERO));

          Long hitLadderId = hitLog.map(EvalGroupRewardHitLog::getEvalGroupRewardLaddersId).orElse(0L);
  

          //参数
          Map<ParamTypeEnum, List<EvalGroupRewardParamVO>> rewardParamMap = this.getEvalGroupRewardParamMap(evalGroupRewardId,

                  evalPoolId, scopeType, referId, dataDate);

          reward.setLadderParams(rewardParamMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));
          reward.setCommissionParams(rewardParamMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));
  

          //阶梯
          reward.setLadders(this.getLadderVos(reward, hitLadderId));
  

          //条件

          reward.setConds(getConds(evalPoolId, scopeType, referId, evalGroupRewardId, dataDate));

  
          //处理百分数
          processRewardPercent(reward);
          return reward;
      }
  

      public Optional<EvalGroupRewardHitLog> getRewardHitLog(Long evalGroupRewardId, Long evalPoolId, EvalScopeEnum scopeType, LocalDate dataDate) {
          EvalGroupRewardHitLog indicatorHitLog = evalGroupRewardHitLogService.getOne(Wrappers.<EvalGroupRewardHitLog>lambdaQuery()
                  .eq(EvalGroupRewardHitLog::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardHitLog::getDataDate, dataDate)
                  .eq(EvalGroupRewardHitLog::getPoolId, evalPoolId)
                  .eq(EvalGroupRewardHitLog::getScopeType, scopeType)
                  .eq(EvalGroupRewardHitLog::getYn, Boolean.TRUE)
          );
          return Optional.ofNullable(indicatorHitLog);
      }
  

      public List<EvalGroupRewardPreconditionVO> getConds(Long poolId, EvalScopeEnum scopeType, Long referId,  Long evalGroupRewardId, LocalDate dataDate) {

          List<EvalGroupRewardPrecondition> preconditions = evalGroupRewardPreconditionService.list(Wrappers.<EvalGroupRewardPrecondition>lambdaQuery()
                  .eq(EvalGroupRewardPrecondition::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardPrecondition::getYn, Boolean.TRUE)
                  .orderByAsc(EvalGroupRewardPrecondition::getSort)
          );
          List<EvalGroupRewardPreconditionVO> preconditionVos = PublicUtil.copyList(preconditions, EvalGroupRewardPreconditionVO.class);
          for (EvalGroupRewardPreconditionVO precondition : preconditionVos) {
              if (TargetTypeEnum.NO.equals(precondition.getTargetType())) {

                  LambdaQueryWrapper<IndicatorUserValue> queryWrapper = Wrappers.<IndicatorUserValue>lambdaQuery()
                          .in(IndicatorUserValue::getIndicatorCode, precondition.getCode())
                          .eq(IndicatorUserValue::getDataDate, dataDate)
                          .eq(IndicatorUserValue::getYn, Boolean.TRUE);
                  if (EvalScopeEnum.STAFF.equals(scopeType)) {
                      queryWrapper.eq(IndicatorUserValue::getUserId, referId);
                  } else {
                      queryWrapper.eq(IndicatorUserValue::getShopId, referId);
                  }
                  IndicatorUserValue indicatorUserValue = indicatorUserValueService.getOne(queryWrapper, Boolean.FALSE);

                  BigDecimal indicatorOriginValue = commonService.queryIndicatorValue(precondition.getCode(), indicatorUserValue);
                  precondition.setIndicatorValue(indicatorOriginValue);