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);

        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.toString()).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));
            }
            //有目标
            if (PublicUtil.isNotEmpty(paramVO.getExtraTargetType()) && (! TargetTypeEnum.NO.equals(paramVO.getExtraTargetType()))) {
                paramVO.setExtraReachValue(Optional.ofNullable(paramVO.getExtraReachValue()).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));
            }
            //有目标
            if (PublicUtil.isNotEmpty(paramVO.getExtraTargetType()) && (! TargetTypeEnum.NO.equals(paramVO.getExtraTargetType()))) {
                paramVO.setExtraReachValue(Optional.ofNullable(paramVO.getExtraReachValue()).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) {
            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::getExtraReachValue).orElse(BigDecimal.ZERO));
            paramVO.setUseTarget(hitLogOptional.map(EvalGroupIndicatorTargetHitLog::getUseTarget).orElse(EvalUseTargetEnum.NO));

//            paramVO.setTargetCalcType(paramVO.getTargetCalcType());
//            paramVO.setTargetType(paramVO.getTargetType());
//            paramVO.setTargetValue(paramVO.getTargetValue());
//            paramVO.setExtraTargetCalcType(paramVO.getExtraTargetCalcType());
//            paramVO.setExtraTargetType(paramVO.getExtraTargetType());
//            paramVO.setExtraTargetValue(paramVO.getExtraTargetValue());
        }

        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);
                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)
                .last("order by rank_order_type ASC, lower ASC")
        );
        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<>())) {
            //指标原始值
            preconditionVO.convertValueToPercent();

//            if (DataTypeEnum.RATIO.equals(preconditionVO.getDataType())) {
//                preconditionVO.setCondValue(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 dto
     * @return
     */
    public KpiIndicatorRankVO queryIndicatorRank(EvalGroupIndicatorRankDTO dto, EvalScopeEnum scopeType) {
        Long referId = null;
        String code = null;
        String name = null;
        IndicatorTypeEnum indicatorTypeEnum = IndicatorTypeEnum.EXAMINE;
        TargetTypeEnum targetType = null;
        DataTypeEnum dataType = null;
        IndicatorCodeTypeEnum codeType = null;
        if (dto.getIsEvalGroupIndicator()) {
            if (PublicUtil.isNotEmpty(dto.getEvalGroupIndicatorParamId())) {
                referId = dto.getEvalGroupIndicatorParamId();
                EvalGroupIndicatorParam evalGroupIndicatorParam = evalGroupIndicatorParamService.getById(referId);
                BV.notNull(evalGroupIndicatorParam, "数据不存在");
                targetType = evalGroupIndicatorParam.getTargetType();
                dataType = evalGroupIndicatorParam.getDataType();
                codeType = evalGroupIndicatorParam.getCodeType();
                code = evalGroupIndicatorParam.getCode();
                name = evalGroupIndicatorParam.getName();
            } else {
                referId = dto.getEvalGroupIndicatorPreconditionId();
                indicatorTypeEnum = IndicatorTypeEnum.PRE;
                EvalGroupIndicatorPrecondition evalGroupIndicatorPrecondition = evalGroupIndicatorPreconditionService.getById(referId);
                BV.notNull(evalGroupIndicatorPrecondition, "数据不存在");
                targetType = evalGroupIndicatorPrecondition.getTargetType();
                dataType = evalGroupIndicatorPrecondition.getDataType();
                codeType = evalGroupIndicatorPrecondition.getCodeType();
                code = evalGroupIndicatorPrecondition.getCode();
                name = evalGroupIndicatorPrecondition.getName();
            }
        } else {
            if (PublicUtil.isNotEmpty(dto.getEvalGroupRewardParamId())) {
                referId = dto.getEvalGroupRewardParamId();
                EvalGroupRewardParam evalGroupRewardParam = evalGroupRewardParamService.getById(referId);
                BV.notNull(evalGroupRewardParam, "数据不存在");
                targetType = evalGroupRewardParam.getTargetType();
                dataType = evalGroupRewardParam.getDataType();
                codeType = evalGroupRewardParam.getCodeType();
                code = evalGroupRewardParam.getCode();
                name = evalGroupRewardParam.getName();
            } else {
                referId = dto.getEvalGroupRewardPreconditionId();
                indicatorTypeEnum = IndicatorTypeEnum.PRE;
                EvalGroupRewardPrecondition evalGroupRewardPrecondition = evalGroupRewardPreconditionService.getById(referId);
                BV.notNull(evalGroupRewardPrecondition, "数据不存在");
                targetType = evalGroupRewardPrecondition.getTargetType();
                dataType = evalGroupRewardPrecondition.getDataType();
                codeType = evalGroupRewardPrecondition.getCodeType();
                code = evalGroupRewardPrecondition.getCode();
                name = evalGroupRewardPrecondition.getName();
            }
        }

        KpiIndicatorRankVO result = KpiIndicatorRankVO.builder()
                .indicatorCode(code)
                .indicatorName(name)
                .dataType(dataType)
                .targetType(targetType)
                .deadlineDate(DateUtil.localDate2Date(dto.getDataDate()))
                .build();

        if (EvalScopeEnum.STAFF.equals(scopeType)) {
            return getStaffIndicatorRank(dto, result, referId, indicatorTypeEnum, codeType);
        }
        return getShopIndicatorRank(dto, result, referId, indicatorTypeEnum, codeType);
    }

    public KpiIndicatorRankVO getStaffIndicatorRank(EvalGroupIndicatorRankDTO dto,
                                                    KpiIndicatorRankVO result,
                                                    Long referId,
                                                    IndicatorTypeEnum indicatorTypeEnum,
                                                    IndicatorCodeTypeEnum codeType) {
        String code = result.getIndicatorCode();
        LocalDate dataDate = dto.getDataDate();
        TargetTypeEnum targetType = result.getTargetType();

        List<EvalUserPool> pools = evalUserPoolService.list(Wrappers.<EvalUserPool>lambdaQuery()
                .eq(EvalUserPool::getEvalGroupId, dto.getEvalGroupId())
                .eq(EvalUserPool::getMonthly, YearMonth.from(dataDate))
                .eq(EvalUserPool::getYn, Boolean.TRUE)
        );
        if (! TargetTypeEnum.NO.equals(targetType)) {
            return queryTargetIndicatorRank(result, pools, dto.getDataDate(), referId, indicatorTypeEnum, dto.getIsEvalGroupIndicator());
        }

        if (IndicatorCodeTypeEnum.INDICATOR.equals(codeType)) {
            result.setStaffs(getNoTargetIndicatorRanks(code, dataDate, pools));
            return result;
        }

        result.setStaffs(getNoTargetEvalIndicatorRanks(code, dataDate, pools));
        return result;
    }

    public KpiIndicatorRankVO getShopIndicatorRank(EvalGroupIndicatorRankDTO dto,
                                                    KpiIndicatorRankVO result,
                                                    Long referId,
                                                    IndicatorTypeEnum indicatorTypeEnum,
                                                    IndicatorCodeTypeEnum codeType) {
        String code = result.getIndicatorCode();
        LocalDate dataDate = dto.getDataDate();
        TargetTypeEnum targetType = result.getTargetType();

        List<EvalShopPool> pools = evalShopPoolService.list(Wrappers.<EvalShopPool>lambdaQuery()
                .eq(EvalShopPool::getEvalGroupId, dto.getEvalGroupId())
                .eq(EvalShopPool::getMonthly, YearMonth.from(dataDate))
                .eq(EvalShopPool::getYn, Boolean.TRUE)
        );
        List<EvalIndicatorRankShopVO> shopVos = null;
        if (! TargetTypeEnum.NO.equals(targetType)) {
            shopVos = getShopTargetIndicatorRanks(referId, dataDate, pools, indicatorTypeEnum, result.getDataType());
        } else {
            if (IndicatorCodeTypeEnum.INDICATOR.equals(codeType)) {
                shopVos = getShopNoTargetIndicatorRanks(code, dataDate, pools);
            } else {
                shopVos = getShopNoTargetEvalIndicatorRanks(code, dataDate, pools);
            }
        }

        Collections.sort(shopVos);
        calcShopRank(shopVos);
        result.setShops(shopVos);
        return result;
    }

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

        Map<Long, IndicatorUserValueVO> indicatorUserValueMap = indicatorUserValues.stream()
                .collect(Collectors.toMap(IndicatorUserValueVO::getUserId, Function.identity(), (v1, v2) -> v1));

        List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorUserValues.size());
        for (EvalUserPool kpiPool : pools) {
            KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();

            rankStaffVO.setUserId(kpiPool.getUserId());
            rankStaffVO.setUserName(kpiPool.getUserName());
            rankStaffVO.setPostId(kpiPool.getPostId());
            rankStaffVO.setPostName(kpiPool.getPostName());
            rankStaffVO.setShopId(kpiPool.getShopId());
            rankStaffVO.setShopName(kpiPool.getShopName());
            rankStaffVO.setInclusion(kpiPool.getInclusion());

            if (indicatorUserValueMap.containsKey(kpiPool.getUserId())) {
                IndicatorUserValueVO indicatorUserValueVO = indicatorUserValueMap.get(kpiPool.getUserId());
                rankStaffVO.setOriginValue(commonService.queryIndicatorValueVO(indicatorCode, indicatorUserValueVO));
            }
            staffRanks.add(rankStaffVO);
        }
        Collections.sort(staffRanks);
        calcRank(staffRanks);
        return staffRanks;
    }

    /**
     * 无目标指标排名
     *
     * @param indicatorCode
     * @param localDate
     * @param pools
     * @return
     */
    public List<EvalIndicatorRankShopVO> getShopNoTargetIndicatorRanks(String indicatorCode, LocalDate localDate, List<EvalShopPool> pools) {
        Set<Long> shopIds = pools.stream().map(EvalShopPool::getShopId).collect(Collectors.toSet());
        List<IndicatorUserValueVO> indicatorUserValues = indicatorUserValueService.getShopReportData(indicatorCode, YearMonth.from(localDate), shopIds);

        Map<Long, IndicatorUserValueVO> indicatorUserValueMap = indicatorUserValues.stream()
                .collect(Collectors.toMap(IndicatorUserValueVO::getUserId, Function.identity(), (v1, v2) -> v1));

        List<EvalIndicatorRankShopVO> staffRanks = Lists.newArrayListWithCapacity(indicatorUserValues.size());
        for (EvalShopPool pool : pools) {
            EvalIndicatorRankShopVO rankShopVO = new EvalIndicatorRankShopVO();
            rankShopVO.setShopId(pool.getShopId());
            rankShopVO.setShopName(pool.getShopName());
            if (indicatorUserValueMap.containsKey(pool.getShopId())) {
                IndicatorUserValueVO indicatorUserValueVO = indicatorUserValueMap.get(pool.getShopId());
                rankShopVO.setOriginValue(commonService.queryIndicatorValueVO(indicatorCode, indicatorUserValueVO));
            }
            staffRanks.add(rankShopVO);
        }
        return staffRanks;
    }

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

        YearMonth lastMonth = YearMonth.from(localDate).minusMonths(1);
        List<EvalIndicatorValue> indicatorUserValues = evalIndicatorValueService.getStaffReportData(indicatorCode, lastMonth, userIds);

        Map<Long, EvalIndicatorValue> indicatorUserValueMap = indicatorUserValues.stream()
                .collect(Collectors.toMap(EvalIndicatorValue::getUserId, Function.identity(), (v1, v2) -> v1));

        List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorUserValues.size());
        for (EvalUserPool kpiPool : pools) {
            KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();

            rankStaffVO.setUserId(kpiPool.getUserId());
            rankStaffVO.setUserName(kpiPool.getUserName());
            rankStaffVO.setPostId(kpiPool.getPostId());
            rankStaffVO.setPostName(kpiPool.getPostName());
            rankStaffVO.setShopId(kpiPool.getShopId());
            rankStaffVO.setShopName(kpiPool.getShopName());
            rankStaffVO.setInclusion(kpiPool.getInclusion());

            if (indicatorUserValueMap.containsKey(kpiPool.getUserId())) {
                EvalIndicatorValue indicatorUserValueVO = indicatorUserValueMap.get(kpiPool.getUserId());
                rankStaffVO.setOriginValue(commonService.queryEvalIndicatorValueVO(indicatorCode, indicatorUserValueVO));

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

    /**
     * 无目标指标排名
     *
     * @param indicatorCode
     * @param localDate
     * @param pools
     * @return
     */
    public List<EvalIndicatorRankShopVO> getShopNoTargetEvalIndicatorRanks(String indicatorCode, LocalDate localDate, List<EvalShopPool> pools) {
        Set<Long> shopIds = pools.stream().map(EvalShopPool::getShopId).collect(Collectors.toSet());

        YearMonth lastMonth = YearMonth.from(localDate).minusMonths(1);
        List<EvalIndicatorValue> indicatorUserValues = evalIndicatorValueService.getShopReportData(indicatorCode, lastMonth, shopIds);

        Map<Long, EvalIndicatorValue> indicatorUserValueMap = indicatorUserValues.stream()
                .collect(Collectors.toMap(EvalIndicatorValue::getShopId, Function.identity(), (v1, v2) -> v1));

        List<EvalIndicatorRankShopVO> staffRanks = Lists.newArrayListWithCapacity(indicatorUserValues.size());
        for (EvalShopPool pool : pools) {
            EvalIndicatorRankShopVO shopVO = new EvalIndicatorRankShopVO();
            shopVO.setShopId(pool.getShopId());
            shopVO.setShopName(pool.getShopName());
            shopVO.setOriginValue(BigDecimal.ZERO);
            if (indicatorUserValueMap.containsKey(pool.getShopId())) {
                EvalIndicatorValue indicatorUserValueVO = indicatorUserValueMap.get(pool.getShopId());
                shopVO.setOriginValue(commonService.queryEvalIndicatorValueVO(indicatorCode, indicatorUserValueVO));
            }
            staffRanks.add(shopVO);
        }
        return staffRanks;
    }

    public KpiIndicatorRankVO queryTargetIndicatorRank(KpiIndicatorRankVO kpiIndicatorRankVO,
                                                       List<EvalUserPool> pools,
                                                       LocalDate dataDate,
                                                       Long referId,
                                                       IndicatorTypeEnum indicatorTypeEnum,
                                                       Boolean isEvalGroupIndicator) {
        List<KpiIndicatorRankStaffVO> staffs = null;
        if (isEvalGroupIndicator) {
            staffs = getTargetIndicatorRanks(referId, dataDate, pools, indicatorTypeEnum, kpiIndicatorRankVO.getDataType());
        } else {
            staffs = getTargetRewardRanks(referId, dataDate, pools, indicatorTypeEnum, kpiIndicatorRankVO.getDataType());
        }

        Collections.sort(staffs);
        calcRank(staffs);
        kpiIndicatorRankVO.setStaffs(staffs);
        return kpiIndicatorRankVO;
    }

    /**
     * 有目标指标排名
     *
     * @param referId
     * @param localDate
     * @param pools
     * @param indicatorTypeEnum
     * @return
     */
    public List<KpiIndicatorRankStaffVO> getTargetIndicatorRanks(Long referId,
                                                                 LocalDate localDate,
                                                                 List<EvalUserPool> pools,
                                                                 IndicatorTypeEnum indicatorTypeEnum,
                                                                 DataTypeEnum dataType) {
        Set<Long> poolIds = pools.stream().map(EvalUserPool::getId).collect(Collectors.toSet());
        List<EvalGroupIndicatorTargetHitLogVO> indicatorTargetHitLogs = evalGroupIndicatorTargetHitLogService.getIndicatorData(referId,
                YearMonth.from(localDate), indicatorTypeEnum, poolIds, EvalScopeEnum.STAFF);

        Map<Long, EvalGroupIndicatorTargetHitLogVO> indicatorTargetMap = indicatorTargetHitLogs.stream()
                .collect(Collectors.toMap(EvalGroupIndicatorTargetHitLogVO::getPoolId, Function.identity(), (v1, v2) -> v1));

        List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorTargetMap.size());
        for (EvalUserPool userPool : pools) {
            KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();

            rankStaffVO.setUserId(userPool.getUserId());
            rankStaffVO.setUserName(userPool.getUserName());
            rankStaffVO.setPostId(userPool.getPostId());
            rankStaffVO.setPostName(userPool.getPostName());
            rankStaffVO.setShopId(userPool.getShopId());
            rankStaffVO.setShopName(userPool.getShopName());
            rankStaffVO.setInclusion(userPool.getInclusion());

            if (indicatorTargetMap.containsKey(userPool.getId())) {
                EvalGroupIndicatorTargetHitLogVO targetHitLogVO = indicatorTargetMap.get(userPool.getId());
                rankStaffVO.setOriginValue(targetHitLogVO.getValue());
                rankStaffVO.setReachValue(targetHitLogVO.getReachValue());
                rankStaffVO.convertValueForTarget(dataType);
            }
            staffRanks.add(rankStaffVO);
        }

        Collections.sort(staffRanks);
        calcRank(staffRanks);
        return staffRanks;
    }

    /**
     * 有目标指标排名
     *
     * @param referId
     * @param localDate
     * @param pools
     * @param indicatorTypeEnum
     * @return
     */
    public List<EvalIndicatorRankShopVO> getShopTargetIndicatorRanks(Long referId,
                                                                     LocalDate localDate,
                                                                     List<EvalShopPool> pools,
                                                                     IndicatorTypeEnum indicatorTypeEnum,
                                                                     DataTypeEnum dataType) {
        Set<Long> poolIds = pools.stream().map(EvalShopPool::getId).collect(Collectors.toSet());
        List<EvalGroupIndicatorTargetHitLogVO> indicatorTargetHitLogs = evalGroupIndicatorTargetHitLogService.getIndicatorData(referId,
                YearMonth.from(localDate), indicatorTypeEnum, poolIds, EvalScopeEnum.SHOP);

        Map<Long, EvalGroupIndicatorTargetHitLogVO> indicatorTargetMap = indicatorTargetHitLogs.stream()
                .collect(Collectors.toMap(EvalGroupIndicatorTargetHitLogVO::getPoolId, Function.identity(), (v1, v2) -> v1));

        List<EvalIndicatorRankShopVO> shopRanks = Lists.newArrayListWithCapacity(indicatorTargetMap.size());
        for (EvalShopPool shopPool : pools) {
            EvalIndicatorRankShopVO shopVO = new EvalIndicatorRankShopVO();
            shopVO.setShopId(shopPool.getShopId());
            shopVO.setShopName(shopPool.getShopName());
            if (indicatorTargetMap.containsKey(shopPool.getId())) {
                EvalGroupIndicatorTargetHitLogVO targetHitLogVO = indicatorTargetMap.get(shopPool.getId());
                shopVO.setOriginValue(targetHitLogVO.getValue());
                shopVO.setReachValue(targetHitLogVO.getReachValue());
                shopVO.convertValueForTarget(dataType);
            }
            shopRanks.add(shopVO);
        }
        return shopRanks;
    }

    /**
     * 有目标指标排名
     *
     * @param referId
     * @param localDate
     * @param pools
     * @param indicatorTypeEnum
     * @return
     */
    public List<KpiIndicatorRankStaffVO> getTargetRewardRanks(Long referId,
                                                                 LocalDate localDate,
                                                                 List<EvalUserPool> pools,
                                                                 IndicatorTypeEnum indicatorTypeEnum,
                                                                 DataTypeEnum dataType) {
        Set<Long> poolIds = pools.stream().map(EvalUserPool::getId).collect(Collectors.toSet());
        List<EvalGroupRewardTargetHitLogVO> indicatorTargetHitLogs = evalGroupRewardTargetHitLogService.getIndicatorData(referId,
                YearMonth.from(localDate), indicatorTypeEnum, poolIds, EvalScopeEnum.STAFF);

        Map<Long, EvalGroupRewardTargetHitLogVO> indicatorTargetMap = indicatorTargetHitLogs.stream()
                .collect(Collectors.toMap(EvalGroupRewardTargetHitLogVO::getPoolId, Function.identity(), (v1, v2) -> v1));

        List<KpiIndicatorRankStaffVO> staffRanks = Lists.newArrayListWithCapacity(indicatorTargetMap.size());
        for (EvalUserPool userPool : pools) {
            KpiIndicatorRankStaffVO rankStaffVO = new KpiIndicatorRankStaffVO();

            rankStaffVO.setUserId(userPool.getUserId());
            rankStaffVO.setUserName(userPool.getUserName());
            rankStaffVO.setPostId(userPool.getPostId());
            rankStaffVO.setPostName(userPool.getPostName());
            rankStaffVO.setShopId(userPool.getShopId());
            rankStaffVO.setShopName(userPool.getShopName());
            rankStaffVO.setInclusion(userPool.getInclusion());

            if (indicatorTargetMap.containsKey(userPool.getId())) {
                EvalGroupRewardTargetHitLogVO targetHitLogVO = indicatorTargetMap.get(userPool.getId());
                rankStaffVO.setOriginValue(targetHitLogVO.getValue());
                rankStaffVO.setReachValue(targetHitLogVO.getReachValue());
                rankStaffVO.convertValueForTarget(dataType);
            }
            staffRanks.add(rankStaffVO);
        }

        Collections.sort(staffRanks);
        calcRank(staffRanks);
        return staffRanks;
    }

    /**
     * 设置排名序号
     *
     * @return
     */
    public void calcRank(List<KpiIndicatorRankStaffVO> staffs) {
        int rank = 1;
        BigDecimal lastIndicatorValue = null;
        for (KpiIndicatorRankStaffVO staff : staffs) {
            if (! staff.getInclusion()) {
                continue;
            }
            if (PublicUtil.isEmpty(lastIndicatorValue) || PublicUtil.isEmpty(staff.getOriginValue()) ) {
                staff.setIndicatorRank(rank);
                lastIndicatorValue = staff.getOriginValue();
                continue;
            }
            if (lastIndicatorValue.compareTo(staff.getOriginValue()) != 0) {
                rank++;
            }
            staff.setIndicatorRank(rank);
            lastIndicatorValue = staff.getOriginValue();
        }
    }

    /**
     * 设置排名序号
     *
     * @return
     */
    public void calcShopRank(List<EvalIndicatorRankShopVO> shops) {
        int rank = 1;
        BigDecimal lastIndicatorValue = null;
        for (EvalIndicatorRankShopVO shop : shops) {
            if (PublicUtil.isEmpty(lastIndicatorValue) || PublicUtil.isEmpty(shop.getOriginValue()) ) {
                shop.setIndicatorRank(rank);
                lastIndicatorValue = shop.getOriginValue();
                continue;
            }
            if (lastIndicatorValue.compareTo(shop.getOriginValue()) != 0) {
                rank++;
            }
            shop.setIndicatorRank(rank);
            lastIndicatorValue = shop.getOriginValue();
        }
    }

    public List<EvalGroupRewardRankLogVO> getRewardCondRankLogs(Long preconditionId, LocalDate dataDate) {
        EvalGroupRewardPrecondition precondition = evalGroupRewardPreconditionService.getById(preconditionId);
        BV.notNull(precondition, "奖惩条件不存在");
        BV.isTrue(ConditionTypeEnum.RANK.equals(precondition.getCondType()), "满足排名率条件才能查询排名情况");
        final DataTypeEnum dataType = precondition.getDataType();
        final TargetTypeEnum targetType = precondition.getTargetType();
        List<EvalGroupRewardRankLog> rankLogs = evalGroupRewardRankLogService.list(Wrappers.<EvalGroupRewardRankLog>lambdaQuery()
                .eq(EvalGroupRewardRankLog::getDataDate, dataDate)
                .eq(EvalGroupRewardRankLog::getReferId, preconditionId)
                .eq(EvalGroupRewardRankLog::getTargetType, RankIndicatorTypeEnum.PRE)
                .eq(EvalGroupRewardRankLog::getYn, Boolean.TRUE)
        );
        Collections.sort(rankLogs);

        List<EvalGroupRewardRankLogVO> rankLogVOs = PublicUtil.copyList(rankLogs, EvalGroupRewardRankLogVO.class);
        rankLogVOs.stream().forEach(rankLog -> rankLog.convertPercentForCond(dataType, targetType));
        return rankLogVOs;
    }

    public List<EvalGroupRewardRankLogVO> queryRewardCommissionRank(Long evalGroupRewardId, LocalDate dataDate) {
        EvalGroupReward reward = evalGroupRewardService.getById(evalGroupRewardId);
        BV.notNull(reward, "奖惩不存在");
        List<EvalGroupRewardRankLog> rankLogs = evalGroupRewardRankLogService.list(Wrappers.<EvalGroupRewardRankLog>lambdaQuery()
                .eq(EvalGroupRewardRankLog::getDataDate, dataDate)
                .eq(EvalGroupRewardRankLog::getReferId, evalGroupRewardId)
                .eq(EvalGroupRewardRankLog::getTargetType, RankIndicatorTypeEnum.REWARD_COMMISSION)
                .eq(EvalGroupRewardRankLog::getYn, Boolean.TRUE)
        );
        Collections.sort(rankLogs);
        List<EvalGroupRewardRankLogVO> rankLogVOs = PublicUtil.copyList(rankLogs, EvalGroupRewardRankLogVO.class);
        return rankLogVOs;
    }

    public List<EvalGroupRewardHitLogVO> queryRewardProportion(EvalScopeEnum scopeType, Long evalGroupRewardId, LocalDate dataDate) {
        EvalGroupReward reward = evalGroupRewardService.getById(evalGroupRewardId);
        BV.notNull(reward, "奖惩不存在");
        List<EvalGroupRewardHitLogVO> hitLogVOS = null;
        if (EvalScopeEnum.STAFF.equals(scopeType)) {
            hitLogVOS = evalGroupRewardHitLogService.getUserHitLogs(evalGroupRewardId, dataDate);
        } else {
            hitLogVOS = evalGroupRewardHitLogService.getShopHitLogs(evalGroupRewardId, dataDate);
        }
        hitLogVOS.stream().forEach(hitLog -> hitLog.convertValueToPercent(reward.getLaddersType()));
        return hitLogVOS;
    }
}