KPI / fw-morax

  package cn.fw.morax.service.biz.eval;
  
  import cn.fw.common.exception.BusinessException;
  import cn.fw.morax.common.config.FlowVal;
  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.enums.*;

  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.rpc.approval.FlowApproveRpc;
  import cn.fw.morax.service.biz.ApprovalBizService;

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

  import cn.fw.morax.service.biz.kpi.KpiGroupUserBizService;
  import cn.fw.morax.service.data.ApprovalRecordService;
  import cn.fw.morax.service.data.SettingDraftService;
  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 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 EvalUserPoolVO queryPoolDetail(final Long poolId) {
          EvalUserPool evalUserPool = evalUserPoolService.getById(poolId);
          if (PublicUtil.isEmpty(evalUserPool)) {
              throw new BusinessException("人员考评数据不存在");
          }

          return poolDetail(evalUserPool);

      }
  
      /**
       * 查询考评详情
       *

       * @param userId
       * @param yearMonth
       * @return
       */
      public EvalUserPoolVO queryUserPoolDetail(final Long userId, final YearMonth yearMonth) {
          List<EvalUserPool> pools = userEvalPool(userId, yearMonth);
  
          if (PublicUtil.isEmpty(pools)) {
              throw new BusinessException("人员考评数据不存在");
          }
          EvalUserPool evalUserPool = pools.get(0);

          return poolDetail(evalUserPool);
      }
  
      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);

  
          Eval eval = evalService.getById(pool.getEvalId());
          BV.notNull(pool, "考评池不存在");
          evalUserPoolVO.setEvalType(eval.getType());
  

          return evalUserPoolVO;
      }
  

      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()));
              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 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);
          BV.notNull(pool, "考评池不存在");
          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);
          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));
          }
  
          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<>();
          if (PublicUtil.isNotEmpty(hasTargetParamIds)) {
              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);

                  precondition.setHit(indicatorOriginValue.compareTo(precondition.getCondValue()) >= 0);

              } else {
                  EvalGroupRewardTargetHitLog targetHitLog = evalGroupRewardTargetHitLogService.getOne(Wrappers.<EvalGroupRewardTargetHitLog>lambdaQuery()
                          .in(EvalGroupRewardTargetHitLog::getReferId, precondition.getId())
                          .eq(EvalGroupRewardTargetHitLog::getDataDate, dataDate)
                          .eq(EvalGroupRewardTargetHitLog::getPoolId, poolId)

                          .eq(EvalGroupRewardTargetHitLog::getScopeType, scopeType)

                          .eq(EvalGroupRewardTargetHitLog::getYn, Boolean.TRUE),
                          Boolean.FALSE
                  );
                  Optional<EvalGroupRewardTargetHitLog> hitLog = Optional.ofNullable(targetHitLog);
                  precondition.setIndicatorValue(hitLog.map(EvalGroupRewardTargetHitLog::getValue).orElse(BigDecimal.ZERO));
                  precondition.setReachValue(hitLog.map(EvalGroupRewardTargetHitLog::getReachValue).orElse(BigDecimal.ZERO));

                  precondition.setHit(precondition.getReachValue().compareTo(precondition.getCondValue()) >= 0);
              }
              if (ConditionTypeEnum.RANK.equals(precondition.getCondType())) {
                  EvalGroupRewardPreconditionHitLog preconditionHitLog = evalGroupRewardPreconditionHitLogService.getOne(Wrappers.<EvalGroupRewardPreconditionHitLog>lambdaQuery()
                                  .eq(EvalGroupRewardPreconditionHitLog::getPreconditionId, precondition.getId())
                                  .eq(EvalGroupRewardPreconditionHitLog::getDataDate, dataDate)
                                  .eq(EvalGroupRewardPreconditionHitLog::getPoolId, poolId)
                                  .eq(EvalGroupRewardPreconditionHitLog::getScopeType, scopeType)
                                  .eq(EvalGroupRewardPreconditionHitLog::getYn, Boolean.TRUE)
                          , Boolean.FALSE
                  );
                  if (PublicUtil.isNotEmpty(preconditionHitLog)) {
                      Optional<EvalGroupRewardPreconditionHitLog> condOption = Optional.ofNullable(preconditionHitLog);
                      precondition.setRankCondValue(condOption.map(EvalGroupRewardPreconditionHitLog::getCondValue).orElse(BigDecimal.ZERO));
                      precondition.setRank(condOption.map(EvalGroupRewardPreconditionHitLog::getRank).orElse(0));
                      precondition.setHit(precondition.getRankCondValue().intValue() >= precondition.getRank());
                  }

              }

          }
          return preconditionVos;
      }
  

  
      public List<EvalGroupRewardLaddersVO> getLadderVos(EvalPoolRewardDetailVO reward, Long hitLadderId) {
          List<EvalGroupRewardLadders> rewardLadders = evalGroupRewardLaddersService.list(Wrappers.<EvalGroupRewardLadders>lambdaQuery()
                  .eq(EvalGroupRewardLadders::getEvalGroupRewardId, reward.getEvalGroupRewardId())
                  .eq(EvalGroupRewardLadders::getYn, Boolean.TRUE)
          );
          List<EvalGroupRewardLaddersVO> rewardLaddersVOS = new ArrayList<>();

          for (EvalGroupRewardLadders rewardLadder : rewardLadders) {
              EvalGroupRewardLaddersVO rewardLaddersVO = PublicUtil.copy(rewardLadder, EvalGroupRewardLaddersVO.class);
              rewardLaddersVO.processPercent(reward.getCalMethod(), reward.getRankType(), reward.getLaddersType());
              rewardLaddersVO.setHit(hitLadderId.equals(rewardLadder.getId()) ? Boolean.TRUE : Boolean.FALSE);
              rewardLaddersVOS.add(rewardLaddersVO);
          }
          return rewardLaddersVOS;
      }
  

      public Map<ParamTypeEnum, List<EvalGroupRewardParamVO>> getEvalGroupRewardParamMap(Long evalGroupRewardId,

                                                                                         Long evalPoolId,
                                                                                         EvalScopeEnum scopeType,
                                                                                         Long referId,
                                                                                         LocalDate dataDate) {

  
          List<EvalGroupRewardParam> params = evalGroupRewardParamService.list(Wrappers.<EvalGroupRewardParam>lambdaQuery()
                  .eq(EvalGroupRewardParam::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardParam::getYn, Boolean.TRUE)
          );
          List<EvalGroupRewardParamVO> paramVos = PublicUtil.copyList(params, EvalGroupRewardParamVO.class);
  
          List<Long> hasTargetParamIds = paramVos.stream()
                  .filter(param -> (! TargetTypeEnum.NO.equals(param.getTargetType())))
                  .map(EvalGroupRewardParamVO::getId).collect(Collectors.toList());
          Map<Long, EvalGroupRewardTargetHitLog> paramTargetHitLogMap = new HashMap<>();
  
          if (PublicUtil.isNotEmpty(hasTargetParamIds)) {
              List<EvalGroupRewardTargetHitLog> targetHitLogs = evalGroupRewardTargetHitLogService.list(Wrappers.<EvalGroupRewardTargetHitLog>lambdaQuery()
                      .in(EvalGroupRewardTargetHitLog::getReferId, hasTargetParamIds)
                      .eq(EvalGroupRewardTargetHitLog::getDataDate, dataDate)
                      .eq(EvalGroupRewardTargetHitLog::getPoolId, evalPoolId)

                      .eq(EvalGroupRewardTargetHitLog::getScopeType, scopeType)

                      .eq(EvalGroupRewardTargetHitLog::getYn, Boolean.TRUE)
              );
              paramTargetHitLogMap = targetHitLogs.stream()
                      .collect(Collectors.toMap(EvalGroupRewardTargetHitLog::getReferId, Function.identity(), (v1, v2) -> v1));
          }
  
          for (EvalGroupRewardParamVO paramVO : paramVos) {
              paramVO.convertToPercent();
              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<EvalGroupRewardTargetHitLog> hitLogOptional = Optional.ofNullable(paramTargetHitLogMap.get(paramId));
              paramVO.setIndicatorValue(hitLogOptional.map(EvalGroupRewardTargetHitLog::getValue).orElse(BigDecimal.ZERO));
              paramVO.setReachValue(hitLogOptional.map(EvalGroupRewardTargetHitLog::getReachValue).orElse(BigDecimal.ZERO));
          }
  
          Map<ParamTypeEnum, List<EvalGroupRewardParamVO>> indicatorParamMap = paramVos.stream()
                  .collect(Collectors.groupingBy(EvalGroupRewardParamVO::getParamType));
          return indicatorParamMap;
      }
  
      public void processRewardPercent(EvalPoolRewardDetailVO detail) {

          if (PublicUtil.isNotEmpty(detail.getProportionValue())) {
              detail.setProportionValue(detail.getProportionValue().multiply(Constant.ONE_HUNDRED));
          }

          //提成
          for (EvalGroupRewardParamVO 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 (EvalGroupRewardParamVO 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 (EvalGroupRewardPreconditionVO preconditionVO : Optional.ofNullable(detail.getConds()).orElse(new ArrayList<>())) {
              //指标原始值