KPI / fw-morax

  package cn.fw.morax.service.biz.calculator.eval.reward;
  

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

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

  import cn.fw.morax.domain.bo.eval.EvalGroupUserShop;

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

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

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

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

  import cn.fw.morax.service.biz.calculator.Calculator;
  import cn.fw.morax.service.data.eval.*;

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

  import com.alibaba.fastjson.JSON;

  import com.alibaba.fastjson.JSONObject;

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

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

  import com.google.common.collect.Lists;

  import lombok.Getter;

  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Autowired;

  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.data.redis.core.BoundZSetOperations;
  import org.springframework.data.redis.core.StringRedisTemplate;

  import org.springframework.data.redis.core.ZSetOperations;

  import org.springframework.transaction.annotation.Transactional;

  import org.springframework.util.CollectionUtils;

  
  import java.math.BigDecimal;

  import java.math.RoundingMode;

  import java.time.LocalDate;

  import java.time.LocalDateTime;
  import java.time.temporal.ChronoUnit;

  import java.util.*;

  import java.util.concurrent.atomic.AtomicInteger;

  import java.util.function.Consumer;

  import java.util.function.Function;
  import java.util.stream.Collectors;

  
  /**
   * 考评基础计算器
   *
   * @author : kurisu
   * @version : 2.0
   * @className : BaseCalculator
   * @description : 考评基础计算器
   * @date : 2022-12-26 14:17
   */
  @Slf4j

  public abstract class EvalRewardBaseCalculator implements Calculator<EvalGroupUserShop, EvalGroupReward, BigDecimal> {

  
      @Autowired

      protected EvalGroupRewardRankLogService evalGroupRewardRankLogService;
      @Autowired

      protected EvalGroupRewardHitLogService evalGroupRewardHitLogService;

      @Autowired

      protected EvalGroupRewardPreconditionHitLogService evalGroupRewardPreconditionHitLogService;
      @Autowired

      protected IndicatorUserValueService indicatorUserValueService;

      @Autowired
      protected EvalGroupRewardParamService evalGroupRewardParamService;
      @Autowired
      protected EvalGroupRewardPreconditionService evalGroupRewardPreconditionService;
      @Autowired
      protected EvalGroupRewardPreconditionHitLogService preconditionHitLogService;
      @Autowired
      protected EvalGroupRewardTargetHitLogService evalGroupRewardTargetHitLogService;

      @Autowired
      protected EvalIndicatorValueService evalIndicatorValueService;
      @Autowired
      protected EvalGroupRewardLaddersService evalGroupRewardLaddersService;

      @Autowired
      protected EvalGroupRewardService evalGroupRewardService;

      @Autowired
      private StringRedisTemplate stringRedisTemplate;

      @Autowired
      private CommonService commonService;

      @Value("${spring.cache.custom.global-prefix}:eval:reward:cond:rank")
      @Getter
      private String preconditionRank;

  
      /**
       * 获取设置类型
       *
       * @return
       */

      public abstract EvalRewardCalMethodEnum getCalMethod();

  
      /**
       * 查询前置条件
       *
       * @param evalGroupRewardId
       * @return
       */

      protected List<EvalGroupRewardPrecondition> queryPrecondition(Long evalGroupRewardId) {
          List<EvalGroupRewardPrecondition> preList = evalGroupRewardPreconditionService.list(Wrappers.<EvalGroupRewardPrecondition>lambdaQuery()
                  .eq(EvalGroupRewardPrecondition::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardPrecondition::getYn, Boolean.TRUE)
                  .orderByAsc(EvalGroupRewardPrecondition::getSort)
          );
          return Optional.ofNullable(preList).orElse(new ArrayList<>());
      }
  
      /**

       * 查询前置条件

       *
       * @param evalGroupRewardId
       * @return
       */

      protected List<EvalGroupRewardPrecondition> queryRankPrecondition(Long evalGroupRewardId) {
          List<EvalGroupRewardPrecondition> preList = evalGroupRewardPreconditionService.list(Wrappers.<EvalGroupRewardPrecondition>lambdaQuery()
                  .eq(EvalGroupRewardPrecondition::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardPrecondition::getCondType, ConditionTypeEnum.RANK)
                  .eq(EvalGroupRewardPrecondition::getYn, Boolean.TRUE)
                  .orderByAsc(EvalGroupRewardPrecondition::getSort)

          );

          return Optional.ofNullable(preList).orElse(new ArrayList<>());

      }
  

      /**
       * 查询考评指标详细配置
       *
       * @param evalGroupRewardId 考评组指标配置id
       * @return
       */
      protected List<EvalGroupRewardLadders> queryRewardLadders(final Long evalGroupRewardId) {
          List<EvalGroupRewardLadders> ladders = evalGroupRewardLaddersService.list(Wrappers.<EvalGroupRewardLadders>lambdaQuery()
                  .eq(EvalGroupRewardLadders::getEvalGroupRewardId, evalGroupRewardId)

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

          if (CollectionUtils.isEmpty(ladders)) {
              return Collections.emptyList();
          }
          return ladders;
      }
  
      /**
       * 校验前置条件
       *
       * @return
       */

      protected boolean examinePrecondition(EvalGroupUserShop userShop, List<EvalGroupRewardPrecondition> preconditions) {

          if (CollectionUtils.isEmpty(preconditions)) {
              return Boolean.TRUE;
          }
          for (EvalGroupRewardPrecondition precondition : preconditions) {

              if (ConditionTypeEnum.RANK.equals(precondition.getCondType())) {

                  return Optional.ofNullable(userShop.getMeetRankCondIds()).orElse(new ArrayList<>()).contains(precondition.getId());

              }

              String indicatorCode = precondition.getCode();

              final BigDecimal indicatorValue = queryValue(userShop, precondition.getCodeType(), indicatorCode).orElse(BigDecimal.ZERO);

              BigDecimal userValue = indicatorValue;
              TargetTypeEnum targetType = precondition.getTargetType();
              final BigDecimal condValue = precondition.getCondValue();
              if (!TargetTypeEnum.NO.equals(targetType)) {
                  TargetCalcTypeEnum targetCalcType = precondition.getTargetCalcType();
                  BigDecimal targetValue = precondition.getTargetValue();
                  userValue = calculateTargetValue(targetCalcType, targetValue, userValue);

                  saveTargetHitLog(userShop, precondition.getId(), IndicatorTypeEnum.PRE, indicatorValue, userValue);

              }
              if (userValue.compareTo(condValue) < 0) {
                  return Boolean.FALSE;
              }
          }
          return Boolean.TRUE;
      }
  

      @Override
      public void calculateRankPrecondition(List<EvalGroupUserShop> params, EvalGroupReward reward) {
          List<EvalGroupRewardPrecondition> rankPreconditions = queryRankPrecondition(reward.getId());
          examineRankPreconditions(params, rankPreconditions);
      }
  
      /**
       * 校验前置条件
       *
       * @return
       */

      @Transactional(rollbackFor = Exception.class)

      protected void examineRankPreconditions(List<EvalGroupUserShop> userShops, List<EvalGroupRewardPrecondition> preconditions) {
          if (CollectionUtils.isEmpty(preconditions)) {
              return;
          }
          for (EvalGroupRewardPrecondition precondition : preconditions) {

              final Long preconditionId = precondition.getId();

              final BigDecimal personCount = BigDecimal.valueOf(userShops.size());

              final BigDecimal condValue = precondition.getCondValue();

              final Integer startIndex = 0;

              final Integer endIndex = condValue.multiply(personCount).divide(BigDecimal.ONE, 0, RoundingMode.FLOOR).intValue() - 1;

              //计算排名
              List<EvalGroupRewardRankLog> rankLogs = calculateRankPreconditionValue(userShops, precondition);
              Collections.sort(rankLogs);
              commonService.calcRank(rankLogs);
              saveRankLogs(preconditionId, rankLogs, RankIndicatorTypeEnum.PRE);
              Map<Long, EvalGroupUserShop> poolUserShopMap = userShops.stream().collect(Collectors.toMap(EvalGroupUserShop::getPoolId,
                      Function.identity(), (v1, v2) -> v1));

  
              if (startIndex > endIndex) {
                  continue;
              }
  

              Integer _startIndex = startIndex, _endIndex = endIndex;;
              List<EvalGroupRewardRankLog> matchRankLogs = rankLogs.stream().filter(rankLog -> {
                  return rankLog.getRank() > _startIndex && rankLog.getRank() <= _endIndex;
              }).collect(Collectors.toList());

              updateHitRankLog(matchRankLogs);

              AtomicInteger rank = new AtomicInteger(0);

              for (EvalGroupRewardRankLog rankLog : matchRankLogs) {
                  EvalGroupUserShop userShop = poolUserShopMap.get(rankLog.getPoolId());

                  if (PublicUtil.isNotEmpty(userShop)) {
                      List<Long> meetRankCondIds = Optional.ofNullable(userShop.getMeetRankCondIds()).orElse(new ArrayList<>());

                      meetRankCondIds.add(preconditionId);
                      userShop.setMeetRankCondIds(meetRankCondIds);

                      savePreHitLog(userShop, precondition, log -> {

                          log.setReachValue(rankLog.getReachValue());

                          log.setCondValue(new BigDecimal(endIndex + 1));
                          log.setRank(rank.incrementAndGet());
                      });

                  }

              }

          }
      }
  

      /**
       * 查询提成指标项
       *
       * @param evalGroupRewardId
       * @param paramType
       * @return
       */
      protected List<EvalGroupRewardParam> queryProjectParam(final Long evalGroupRewardId, final ParamTypeEnum paramType) {
          List<EvalGroupRewardParam> params = evalGroupRewardParamService.list(Wrappers.<EvalGroupRewardParam>lambdaQuery()
                  .eq(EvalGroupRewardParam::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardParam::getParamType, paramType)
                  .eq(EvalGroupRewardParam::getYn, Boolean.TRUE)
          );
          if (CollectionUtils.isEmpty(params)) {
              return Collections.emptyList();
          }
          return params;
      }

      @Transactional(rollbackFor = Exception.class)

      protected void saveTargetHitLog(EvalGroupUserShop userShop, Long rewardReferId, IndicatorTypeEnum targetType, BigDecimal value, BigDecimal reachValue) {

          evalGroupRewardTargetHitLogService.remove(Wrappers.<EvalGroupRewardTargetHitLog>lambdaQuery()

                  .eq(EvalGroupRewardTargetHitLog::getPoolId, userShop.getPoolId())

                  .eq(EvalGroupRewardTargetHitLog::getScopeType, userShop.getScopeType())

                  .eq(EvalGroupRewardTargetHitLog::getReferId, rewardReferId)

                  .eq(EvalGroupRewardTargetHitLog::getTargetType, targetType)

                  .eq(EvalGroupRewardTargetHitLog::getDataDate, userShop.getDataDate())

          );
          EvalGroupRewardTargetHitLog log = new EvalGroupRewardTargetHitLog();

          log.setPoolId(userShop.getPoolId());

          log.setScopeType(userShop.getScopeType());

          log.setReferId(rewardReferId);

          log.setTargetType(targetType);
          log.setValue(value);
          log.setReachValue(reachValue);

          log.setDataDate(userShop.getDataDate());
          log.setGroupId(userShop.getGroupId());

          log.setYn(Boolean.TRUE);
          evalGroupRewardTargetHitLogService.save(log);
      }

      @Transactional(rollbackFor = Exception.class)

      protected void savePreHitLog(EvalGroupUserShop userShop, EvalGroupRewardPrecondition precondition, Consumer<EvalGroupRewardPreconditionHitLog> consumer) {
          evalGroupRewardPreconditionHitLogService.remove(Wrappers.<EvalGroupRewardPreconditionHitLog>lambdaQuery()
                  .eq(EvalGroupRewardPreconditionHitLog::getPoolId, userShop.getPoolId())
                  .eq(EvalGroupRewardPreconditionHitLog::getScopeType, userShop.getScopeType())
                  .eq(EvalGroupRewardPreconditionHitLog::getPreconditionId, precondition.getId())
                  .eq(EvalGroupRewardPreconditionHitLog::getDataDate, userShop.getDataDate())
          );
          EvalGroupRewardPreconditionHitLog log = new EvalGroupRewardPreconditionHitLog();
          log.setEvalGroupId(userShop.getEvalGroupId());
          log.setEvalGroupRewardId(precondition.getEvalGroupRewardId());
          log.setPoolId(userShop.getPoolId());
          log.setScopeType(userShop.getScopeType());
          log.setPreconditionId(precondition.getId());
          log.setDataDate(userShop.getDataDate());
          log.setGroupId(userShop.getGroupId());
          log.setYn(Boolean.TRUE);
          if (consumer != null) {
              consumer.accept(log);
          }
          evalGroupRewardPreconditionHitLogService.save(log);
      }
  

      /**
       * 查询指标值
       *
       * @param indicatorCode
       * @return
       */

      protected Optional<BigDecimal> queryValue(EvalGroupUserShop obj, IndicatorCodeTypeEnum codeType, String indicatorCode) {

          DimensionTypeEnum dimensionType = EvalScopeEnum.STAFF.equals(obj.getScopeType()) ? DimensionTypeEnum.STAFF : DimensionTypeEnum.SHOP;

          if (IndicatorCodeTypeEnum.INDICATOR.equals(codeType)) {
              LambdaQueryWrapper<IndicatorUserValue> queryWrapper = Wrappers.<IndicatorUserValue>lambdaQuery()
                      .eq(IndicatorUserValue::getIndicatorCode, indicatorCode)
                      .eq(IndicatorUserValue::getDataDate, obj.getDataDate())
                      .eq(IndicatorUserValue::getDimensionType, dimensionType)
                      .eq(IndicatorUserValue::getYn, Boolean.TRUE)
                      .eq(IndicatorUserValue::getGroupId, obj.getGroupId());
              if (EvalScopeEnum.STAFF.equals(obj.getScopeType())) {
                  queryWrapper.eq(IndicatorUserValue::getUserId, obj.getReferId());
              } else {
                  queryWrapper.eq(IndicatorUserValue::getShopId, obj.getReferId());
              }
              IndicatorUserValue indicatorUserValue = indicatorUserValueService.getOne(queryWrapper, Boolean.FALSE);

              return queryKpiIndicatorValue(indicatorUserValue);

          } else {

              EvalIndicatorValue evalIndicatorValue = evalIndicatorValueService.queryLastValue(obj.getReferId(),

                      dimensionType, indicatorCode, obj.getDataDate());

              return Optional.ofNullable(evalIndicatorValue).map(EvalIndicatorValue::getIndicatorValue);

          }

      }

      /**
       * 查询具体指标值
       *
       * @param indicatorUserValue
       * @return
       */
      protected Optional<BigDecimal> queryKpiIndicatorValue(IndicatorUserValue indicatorUserValue) {
          if (PublicUtil.isEmpty(indicatorUserValue) || PublicUtil.isEmpty(indicatorUserValue.getIndicatorValue())) {
              return Optional.empty();

          }

          BigDecimal value = BigDecimal.ZERO;

          try {

              JSONObject jsonObject = JSONObject.parseObject(indicatorUserValue.getIndicatorValue());
              value = Optional.ofNullable(jsonObject.getBigDecimal(indicatorUserValue.getIndicatorCode())).orElse(BigDecimal.ZERO);

          } catch (Exception e) {

              log.error("[{}]指标值转化失败", indicatorUserValue, e);

          }

          return Optional.of(value);

      }
  
      /**
       * 经过目标计算后的用户指标值
       *
       * @param targetCalcType
       * @param targetValue
       * @param userValue
       * @return
       */
      protected BigDecimal calculateTargetValue(TargetCalcTypeEnum targetCalcType, BigDecimal targetValue, BigDecimal userValue) {
          if (Objects.isNull(targetValue) || targetValue.compareTo(BigDecimal.ZERO) <= 0) {
              return userValue;
          }
          if (TargetCalcTypeEnum.TARGET_VALUE.equals(targetCalcType)) {
              return userValue.divide(targetValue, 4, RoundingMode.HALF_UP);
          }
          BigDecimal diffValue = BigDecimal.ONE.subtract(targetValue);
          BigDecimal userDiffValue = userValue.subtract(targetValue);
          if (userDiffValue.compareTo(BigDecimal.ZERO) <= 0) {
              return BigDecimal.ZERO;
          }
          if (diffValue.compareTo(BigDecimal.ZERO) <= 0) {
              return userDiffValue;
          }
          return userDiffValue.divide(diffValue, 4, RoundingMode.HALF_UP);
      }
  

      /**
       * 清除project记录命中配置
       *
       * @param evalGroupRewardId 指标配置id
       * @param param 人员信息
       */
      @Transactional(rollbackFor = Exception.class)

      public void clearProjectHitLog(Long evalGroupRewardId, EvalGroupUserShop param) {

          final Long poolId = param.getPoolId();

          final EvalScopeEnum scopeType = param.getScopeType();
          final LocalDate dataDate = param.getDataDate();
          final Long groupId = param.getGroupId();
          evalGroupRewardHitLogService.remove(Wrappers.<EvalGroupRewardHitLog>lambdaQuery()

                  .eq(EvalGroupRewardHitLog::getPoolId, poolId)

                  .eq(EvalGroupRewardHitLog::getScopeType, scopeType)
                  .eq(EvalGroupRewardHitLog::getEvalGroupRewardId, evalGroupRewardId)
                  .eq(EvalGroupRewardHitLog::getDataDate, dataDate)
                  .eq(EvalGroupRewardHitLog::getGroupId, groupId)
          );
      }
  
      /**
       * 记录命中配置
       *
       * @param evalGroupRewardId 指标配置id

       * @param userShop 信息

       * @param consumer
       */
      @Transactional(rollbackFor = Exception.class)

      public void saveProjectHitLog(Long evalGroupRewardId, EvalGroupUserShop userShop, Consumer<EvalGroupRewardHitLog> consumer) {

          final EvalScopeEnum scopeType = userShop.getScopeType();
          final LocalDate dataDate = userShop.getDataDate();
          final Long groupId = userShop.getGroupId();

          EvalGroupRewardHitLog hitLog = EvalGroupRewardHitLog.builder()
                  .evalGroupRewardId(evalGroupRewardId)

                  .poolId(userShop.getPoolId())

                  .scopeType(scopeType)
                  .evalGroupRewardLaddersId(-1L)
                  .rewardValue(BigDecimal.ZERO)
                  .hitCommissionValue(BigDecimal.ZERO)
                  .dataDate(dataDate)
                  .groupId(groupId)
                  .build();
          if (consumer != null) {
              consumer.accept(hitLog);
          }
          evalGroupRewardHitLogService.save(hitLog);
      }
  

      /**
       * 计算提成参数最终值
       *
       * @param rewardObjectBO
       * @param params
       * @return
       */
      protected BigDecimal calculateParamValue(EvalGroupUserShop rewardObjectBO, List<EvalGroupRewardParam> params) {
          BigDecimal commissionValue = BigDecimal.ZERO;
          for (EvalGroupRewardParam param: params) {
              String indicatorCode = param.getCode();
              boolean isCap = Boolean.TRUE.equals(param.getCap());
              BigDecimal proportion = param.getProportion();
              TargetTypeEnum targetType = param.getTargetType();
              ParamTypeEnum paramType = param.getParamType();

              final BigDecimal userOriginValue = queryValue(rewardObjectBO, param.getCodeType(), indicatorCode).orElse(BigDecimal.ZERO);

              BigDecimal _calcValue = userOriginValue;
              if (!TargetTypeEnum.NO.equals(targetType)) {
                  _calcValue = calculateTargetValue(param.getTargetCalcType(), param.getTargetValue(), _calcValue);
                  saveTargetHitLog(rewardObjectBO, param.getId(), IndicatorTypeEnum.EXAMINE, userOriginValue, _calcValue);
              }
              if (isCap) {
                  _calcValue = _calcValue.compareTo(BigDecimal.ONE) > 0 ? BigDecimal.ONE : _calcValue;
              }
              commissionValue = commissionValue.add(proportion.multiply(_calcValue));
          }
          return commissionValue;
      }
  

      /**

       * 计算排名提成参数最终值
       *
       * @param userShops
       * @param evalGroupRewardId
       * @param params
       * @return
       */
      protected List<EvalGroupRewardRankLog> calculateRankParamValue(List<EvalGroupUserShop> userShops, Long evalGroupRewardId, List<EvalGroupRewardParam> params) {
          List<EvalGroupRewardRankLog> rankLogs = Lists.newArrayListWithCapacity(userShops.size());
          for (EvalGroupUserShop userShop : userShops) {
              BigDecimal commissionValue = BigDecimal.ZERO;
              for (EvalGroupRewardParam param: params) {
                  String indicatorCode = param.getCode();
                  boolean isCap = Boolean.TRUE.equals(param.getCap());
                  BigDecimal proportion = param.getProportion();
                  TargetTypeEnum targetType = param.getTargetType();
                  final BigDecimal userOriginValue = queryValue(userShop, param.getCodeType(), indicatorCode).orElse(BigDecimal.ZERO);
                  BigDecimal _calcValue = userOriginValue;
                  if (!TargetTypeEnum.NO.equals(targetType)) {
                      _calcValue = calculateTargetValue(param.getTargetCalcType(), param.getTargetValue(), _calcValue);
                      saveTargetHitLog(userShop, param.getId(), IndicatorTypeEnum.EXAMINE, userOriginValue, _calcValue);
                  }
                  if (isCap) {
                      _calcValue = _calcValue.compareTo(BigDecimal.ONE) > 0 ? BigDecimal.ONE : _calcValue;
                  }
                  commissionValue = commissionValue.add(proportion.multiply(_calcValue));
              }
              EvalGroupRewardRankLog rankLog = EvalGroupRewardRankLog.builder()
                      .poolId(userShop.getPoolId())

                      .name(userShop.getName())

                      .scopeType(userShop.getScopeType())
                      .referId(evalGroupRewardId)
                      .targetType(RankIndicatorTypeEnum.REWARD_COMMISSION)
                      .value(commissionValue)
                      .reachValue(commissionValue)

                      .hit(Boolean.FALSE)

                      .dataDate(userShop.getDataDate())
                      .groupId(userShop.getGroupId())
                      .build();
              rankLogs.add(rankLog);
          }
          return rankLogs;
      }
  
      /**
       * 计算排名条件最终值
       *
       * @param userShops
       * @param precondition
       * @return
       */
      protected List<EvalGroupRewardRankLog> calculateRankPreconditionValue(List<EvalGroupUserShop> userShops, EvalGroupRewardPrecondition precondition) {
          final String indicatorCode = precondition.getCode();
          final Long preconditionId = precondition.getId();
          final TargetTypeEnum targetType = precondition.getTargetType();
          final BigDecimal targetValue = precondition.getTargetValue();
          final TargetCalcTypeEnum targetCalcType = precondition.getTargetCalcType();
  
          List<EvalGroupRewardRankLog> rankLogs = Lists.newArrayListWithCapacity(userShops.size());
          for (EvalGroupUserShop userShop : userShops) {
              final BigDecimal indicatorValue = queryValue(userShop, precondition.getCodeType(), indicatorCode).orElse(BigDecimal.ZERO);
              BigDecimal reachValue = indicatorValue;
              if (!TargetTypeEnum.NO.equals(targetType)) {
                  reachValue = calculateTargetValue(targetCalcType, targetValue, indicatorValue);
              }
  
              EvalGroupRewardRankLog rankLog = EvalGroupRewardRankLog.builder()

                      .name(userShop.getName())

                      .poolId(userShop.getPoolId())
                      .scopeType(userShop.getScopeType())
                      .referId(preconditionId)
                      .targetType(RankIndicatorTypeEnum.PRE)
                      .value(indicatorValue)
                      .reachValue(reachValue)
                      .dataDate(userShop.getDataDate())
                      .groupId(userShop.getGroupId())
                      .build();
              rankLogs.add(rankLog);
          }
          return rankLogs;
      }
  

      @Transactional(rollbackFor = Exception.class)

      public void saveRankLogs(Long evalGroupRewardId, List<EvalGroupRewardRankLog> rankLogs, RankIndicatorTypeEnum targetType) {
          Set<Long> poolIds = rankLogs.stream().map(EvalGroupRewardRankLog::getPoolId).collect(Collectors.toSet());
          EvalGroupRewardRankLog rankLog = rankLogs.stream().findFirst().get();
          evalGroupRewardRankLogService.remove(Wrappers.<EvalGroupRewardRankLog>lambdaQuery()
              .in(EvalGroupRewardRankLog::getPoolId, poolIds)
              .eq(EvalGroupRewardRankLog::getScopeType, rankLog.getScopeType())
              .eq(EvalGroupRewardRankLog::getReferId, evalGroupRewardId)
              .eq(EvalGroupRewardRankLog::getTargetType, targetType)
              .eq(EvalGroupRewardRankLog::getGroupId, rankLog.getGroupId())
          );
  
          evalGroupRewardRankLogService.saveBatch(rankLogs);
      }
  

      @Transactional(rollbackFor = Exception.class)
      public void updateHitRankLog(List<EvalGroupRewardRankLog> matchRankLogs) {
          if (PublicUtil.isEmpty(matchRankLogs)) {
              return;
          }
          evalGroupRewardRankLogService.update(Wrappers.<EvalGroupRewardRankLog>lambdaUpdate()

                  .in(EvalGroupRewardRankLog::getId, matchRankLogs.stream().map(EvalGroupRewardRankLog::getId).collect(Collectors.toList()))

                  .set(EvalGroupRewardRankLog::getHit, Boolean.TRUE)
          );
      }
  

      /**

       * 初始化奖惩值
       *
       * @param userShops
       * @return
       */
      protected void initReward(List<EvalGroupUserShop> userShops) {
          if (PublicUtil.isEmpty(userShops)) {
              return;
          }
          for (EvalGroupUserShop userShop : userShops) {
              userShop.setEvalGroupRewardAmount(BigDecimal.ZERO);
          }
      }

  }