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

import cn.fw.common.data.mybatis.pagination.PageData;
import cn.fw.common.exception.BusinessException;
import cn.fw.common.page.AppPage;
import cn.fw.common.web.annotation.DisLock;
import cn.fw.common.web.auth.LoginAuthBean;
import cn.fw.morax.common.config.FlowVal;
import cn.fw.morax.common.constant.Constant;
import cn.fw.morax.common.pojo.event.ApprovalResultEvent;
import cn.fw.morax.common.utils.PublicUtil;
import cn.fw.morax.domain.db.ApprovalRecord;
import cn.fw.morax.domain.db.SettingDraft;
import cn.fw.morax.domain.db.eval.*;
import cn.fw.morax.domain.db.kpi.KpiGroup;
import cn.fw.morax.domain.db.kpi.KpiGroupIndicatorLadders;
import cn.fw.morax.domain.db.kpi.KpiPool;
import cn.fw.morax.domain.dto.eval.*;
import cn.fw.morax.domain.dto.kpi.KpiGroupDTO;
import cn.fw.morax.domain.dto.kpi.KpiGroupIndicatorDTO;
import cn.fw.morax.domain.dto.kpi.KpiGroupIndicatorParamDTO;
import cn.fw.morax.domain.dto.kpi.KpiGroupIndicatorPreconditionDTO;
import cn.fw.morax.domain.dto.query.EvalGroupQueryDTO;
import cn.fw.morax.domain.dto.query.KpiGroupQueryDTO;
import cn.fw.morax.domain.enums.*;
import cn.fw.morax.domain.vo.eval.*;
import cn.fw.morax.domain.vo.kpi.KpiGroupIndicatorTargetVO;
import cn.fw.morax.domain.vo.kpi.KpiGroupIndicatorVO;
import cn.fw.morax.domain.vo.kpi.KpiGroupSavePromptVO;
import cn.fw.morax.domain.vo.kpi.KpiGroupVO;
import cn.fw.morax.rpc.approval.FlowApproveRpc;
import cn.fw.morax.service.biz.ApprovalBizService;
import cn.fw.morax.service.biz.CommonService;
import cn.fw.morax.service.biz.kpi.KpiGroupUserBizService;
import cn.fw.morax.service.data.ApprovalRecordService;
import cn.fw.morax.service.data.SettingDraftService;
import cn.fw.morax.service.data.eval.*;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.YearMonth;
import java.util.*;
import java.util.stream.Collectors;

import static cn.fw.common.businessvalidator.Validator.BV;

@Service
@Slf4j
@RequiredArgsConstructor
public class EvalGroupBizService {

    private final EvalGroupIndicatorPreconditionLaddersService evalGroupIndicatorPreconditionLaddersService;
    private final EvalGroupIndicatorPreconditionService evalGroupIndicatorPreconditionService;
    private final EvalGroupRewardPreconditionService evalGroupRewardPreconditionService;
    private final EvalGroupIndicatorLaddersService evalGroupIndicatorLaddersService;
    private final EvalGroupIndicatorParamService evalGroupIndicatorParamService;
    private final EvalGroupRewardLaddersService evalGroupRewardLaddersService;
    private final EvalGroupRewardParamService evalGroupRewardParamService;
    private final EvalGroupIndicatorService evalGroupIndicatorService;
    private final EvalGroupRewardService evalGroupRewardService;
    private final EvalGroupDataService evalGroupDataService;
    private final EvalUserPoolService evalUserPoolService;
    private final EvalShopPoolService evalShopPoolService;
    private final EvalGroupService evalGroupService;
    private final EvalService evalService;
    private final SettingDraftService settingDraftService;
    private final ApprovalBizService approvalBizService;

    @Value("${spring.cache.custom.global-prefix}:eval:save:")
    @Getter
    private String saveGroupPrefix;


    /**
     * 考评组保存
     *
     * @param dto
     * @param user
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @DisLock(prefix = "#this.getSaveGroupPrefix()", key = "#dto.getName()", message = "保存中，请勿重复操作")
    public void saveEvalGroup(EvalDTO dto, LoginAuthBean user, Boolean isSubmit) {

        for (EvalGroupDTO evalGroupDTO : dto.getEvalGroups()) {
            initEvalGroupDTO(evalGroupDTO);
            checkTime(evalGroupDTO);
            checkNameRepetition(dto.getId(), dto.getName());
            checkIndicator(evalGroupDTO);
            checkReward(evalGroupDTO);
            checkEvalIndicatorLadders(evalGroupDTO.getIndicators());
            checkEvalRewardLadders(evalGroupDTO.getRewards());
            sortRewardRankLadders(evalGroupDTO.getRewards());
            setTargetVos(evalGroupDTO);
        }
        SettingDraft settingDraft = getSettingDraft(dto, isSubmit);
        settingDraftService.saveOrUpdate(settingDraft);
        if (! isSubmit) {
            return;
        }

//        Eval eval = evalGroupDataService.saveEval(dto);
//        for (EvalGroupDTO evalGroupDTO : dto.getEvalGroups()) {
//            EvalGroup evalGroup = evalGroupDataService.saveEvalGroup(evalGroupDTO, eval);
//            evalGroupDataService.saveEvalGroupIndicator(evalGroup, evalGroupDTO.getIndicators());
//            evalGroupDataService.saveEvalGroupReward(evalGroup, evalGroupDTO.getRewards());
//        }
        approvalBizService.applyApproveEvalDraft(dto, dto.getEvalGroups(), settingDraft, user);
    }

    /**
     * 获取草稿
     *
     * @param dto
     * @return
     */
    public SettingDraft getSettingDraft(EvalDTO dto, Boolean submit) {
        SettingDraft settingDraft = null;
        if (PublicUtil.isEmpty(dto.getDraftId())) {
            settingDraft = new SettingDraft();
            settingDraft.setGroupId(dto.getGroupId());
            settingDraft.setYn(Boolean.TRUE);
            settingDraft.setType(SettingDraftTypeEnum.EVAL);
        } else {
            settingDraft = settingDraftService.getById(dto.getDraftId());
            BV.notNull(settingDraft, "草稿配置不存在，请重试");
        }
        settingDraft.setStatus(submit ? SettingDraftStatusEnum.RELEASE_APPROVAL : SettingDraftStatusEnum.NO_RELEASE);
        settingDraft.setEvalType(dto.getType());
        settingDraft.setName(dto.getName());
        settingDraft.setContent(JSONObject.toJSONString(dto));
        return settingDraft;
    }

    /**
     * 装换为目标对象
     *
     * @return
     */
    public void setTargetVos(EvalGroupDTO evalGroupDTO) {

        for (EvalGroupIndicatorDTO indicatorDTO : evalGroupDTO.getIndicators()) {
            List<EvalGroupIndicatorParamDTO> ladderParams = Optional.ofNullable(indicatorDTO.getLadderParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorParamDTO> commissionParams = Optional.ofNullable(indicatorDTO.getCommissionParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorPreconditionDTO> conds = Optional.ofNullable(indicatorDTO.getConds()).orElse(new ArrayList<>());

            List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
            for (EvalGroupIndicatorParamDTO paramDTO : ladderParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorParamDTO paramDTO : commissionParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorPreconditionDTO preconditionDTO : conds) {
                if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            indicatorDTO.setTargets(targetVOS);
        }

        for (EvalGroupRewardDTO rewardDTO : evalGroupDTO.getRewards()) {
            List<EvalGroupRewardParamDTO> ladderParams = Optional.ofNullable(rewardDTO.getLadderParams()).orElse(new ArrayList<>());
            List<EvalGroupRewardParamDTO> commissionParams = Optional.ofNullable(rewardDTO.getCommissionParams()).orElse(new ArrayList<>());
            List<EvalGroupRewardPreconditionDTO> conds = Optional.ofNullable(rewardDTO.getConds()).orElse(new ArrayList<>());

            List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
            for (EvalGroupRewardParamDTO paramDTO : ladderParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupRewardParamDTO paramDTO : commissionParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupRewardPreconditionDTO preconditionDTO : conds) {
                if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }
            rewardDTO.setTargets(targetVOS);
        }
    }

    /**
     * 装换为目标对象
     *
     * @return
     */
    public void setTargetVos(EvalGroupVO evalGroupVO) {

        for (EvalGroupIndicatorVO indicatorDTO : evalGroupVO.getIndicators()) {
            List<EvalGroupIndicatorParamVO> ladderParams = Optional.ofNullable(indicatorDTO.getLadderParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorParamVO> commissionParams = Optional.ofNullable(indicatorDTO.getCommissionParams()).orElse(new ArrayList<>());
            List<EvalGroupIndicatorPreconditionVO> conds = Optional.ofNullable(indicatorDTO.getConds()).orElse(new ArrayList<>());

            List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
            for (EvalGroupIndicatorParamVO paramDTO : ladderParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorParamVO paramDTO : commissionParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupIndicatorPreconditionVO preconditionDTO : conds) {
                if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            indicatorDTO.setTargets(targetVOS);
        }

        for (EvalGroupRewardVO rewardDTO : evalGroupVO.getRewards()) {
            List<EvalGroupRewardParamVO> ladderParams = Optional.ofNullable(rewardDTO.getLadderParams()).orElse(new ArrayList<>());
            List<EvalGroupRewardParamVO> commissionParams = Optional.ofNullable(rewardDTO.getCommissionParams()).orElse(new ArrayList<>());
            List<EvalGroupRewardPreconditionVO> conds = Optional.ofNullable(rewardDTO.getConds()).orElse(new ArrayList<>());

            List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
            for (EvalGroupRewardParamVO paramDTO : ladderParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupRewardParamVO paramDTO : commissionParams) {
                if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }

            for (EvalGroupRewardPreconditionVO preconditionDTO : conds) {
                if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                    EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, EvalGroupIndicatorTargetVO.class);
                    targetVOS.add(targetVO);
                }
            }
            rewardDTO.setTargets(targetVOS);
        }
    }

    /**
     * 检查时间
     *
     * @param dto
     */
    public void initEvalGroupDTO(EvalGroupDTO dto) {
        for (EvalGroupIndicatorDTO indicatorDTO : dto.getIndicators()) {
            if (PublicUtil.isEmpty(indicatorDTO.getLadderParams())) {
                indicatorDTO.setLadderParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getCommissionParams())) {
                indicatorDTO.setCommissionParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getLadders())) {
                indicatorDTO.setLadders(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(indicatorDTO.getConds())) {
                indicatorDTO.setConds(new ArrayList<>());
            }
        }
        for (EvalGroupRewardDTO rewardDTO : dto.getRewards()) {
            if (PublicUtil.isEmpty(rewardDTO.getLadderParams())) {
                rewardDTO.setLadderParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(rewardDTO.getCommissionParams())) {
                rewardDTO.setCommissionParams(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(rewardDTO.getLadders())) {
                rewardDTO.setLadders(new ArrayList<>());
            }
            if (PublicUtil.isEmpty(rewardDTO.getConds())) {
                rewardDTO.setConds(new ArrayList<>());
            }
        }
    }
    /**
     * 检查时间
     *
     * @param dto
     */
    public void checkTime(EvalGroupDTO dto) {
//        BV.isTrue(dto.getBeginTime().isBefore(dto.getOverTime()), "考评组【" + dto.getName()+ "】生效时间必须在结束时间之前");

        if (PublicUtil.isNotEmpty(dto.getId())) {
            List<EvalGroup> evalGroups = evalGroupService.list(Wrappers.<EvalGroup>lambdaQuery()
                    .eq(EvalGroup::getEvalId, dto.getId())
                    .eq(EvalGroup::getYn, Boolean.TRUE)
            );
            LocalDate now = LocalDate.now();
            Optional<EvalGroup> optionalEvalGroup = evalGroups.stream()
                    .filter(evalGroup -> EvalScopeEnum.SHOP.equals(evalGroup.getScopeType()) && now.equals(evalGroup.getOverTime())).findFirst();
            if (optionalEvalGroup.isPresent()) {
                throw new BusinessException("考评组 " + optionalEvalGroup.get().getName() + "已结束,不能编辑");
            }
        }
    }

    /**
     * 检查绩效组排名名称是否重复
     *
     * @param id
     * @param name
     */
    public void checkNameRepetition(Long id, String name) {
        int count = evalGroupService.count(Wrappers.<EvalGroup>lambdaQuery()
                .eq(EvalGroup::getName, name)
                .ne(PublicUtil.isNotEmpty(id), EvalGroup::getId, id)
                .eq(EvalGroup::getYn, Boolean.TRUE)
//                .eq(EvalGroup::getStatus, SettingStatusEnum.EFFECTIVE)
        );
        BV.isTrue(count <= 0, "绩效组名称重复，请重新输入");
    }

    /**
     * 检查阶梯分值
     * @param indicators
     */
    private void checkEvalIndicatorLadders(List<EvalGroupIndicatorDTO> indicators) {
        Integer baseScore = null;
        for (EvalGroupIndicatorDTO indicatorDto : indicators) {
            if (ScoreWayEnum.NORMAL.equals(indicatorDto.getScoreWay())) {
                continue;
            }

            baseScore = indicatorDto.getBaseScore();
            List<EvalGroupIndicatorLaddersDTO> ladders = indicatorDto.getLadders();
            Collections.sort(ladders);

            //阶梯值校验  标准分不能超过指标基础分，阶梯值必须连续
            for (EvalGroupIndicatorLaddersDTO laddersDto : ladders) {
                BV.isTrue(PublicUtil.isNotEmpty(laddersDto.getLower()), "阶梯下限不能为空");
                BV.isTrue(PublicUtil.isNotEmpty(laddersDto.getUpper()), "阶梯上限不能为空");

                //阶梯标准分不能超过绩效分值
                if (laddersDto.getStandardScore().compareTo(baseScore) > 0) {
                    throw new BusinessException("【" + indicatorDto.getName() + "】的阶梯标准分不能超过绩效分值");
                }
            }
            //校验阶梯
            CommonService.checkLadders(ladders, indicatorDto.getName());

            //校验条件
            for (EvalGroupIndicatorPreconditionDTO condDTO : indicatorDto.getConds()) {
                CommonService.checkLadders(condDTO.getLadders(), indicatorDto.getName());
            }
        }
    }

    /**
     * 检查阶梯分值
     * @param rewards
     */
    private void checkEvalRewardLadders(List<EvalGroupRewardDTO> rewards) {
        for (EvalGroupRewardDTO reward : rewards) {

            String rewardName = reward.getName();
            List<EvalGroupRewardLaddersDTO> ladders = reward.getLadders();
            if (EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER_DOUBLE.equals(reward.getCalMethod())) {
                BV.isTrue(PublicUtil.isNotEmpty(ladders), "阶梯不能为空");
                Collections.sort(ladders);
            }

            for (EvalGroupRewardLaddersDTO ladder : ladders) {
                BV.isTrue(PublicUtil.isNotEmpty(ladder.getLower()), "阶梯下限不能为空");
                BV.isTrue(PublicUtil.isNotEmpty(ladder.getUpper()), "阶梯上限不能为空");
            }

            switch (reward.getCalMethod()) {
                case TOTAL_PROPORTION: case FIXATION:{
                    if (PublicUtil.isNotEmpty(ladders)) {
                        throw new BusinessException("计算方式【" + reward.getCalMethod().getName() + "】不能配置阶梯");
                    }
                    break;
                }
//                case RANK:
                case LADDER:
                case LADDER_DOUBLE:
                {
                    CommonService.checkLadders(ladders, rewardName);
                    break;
                }
            }

        }
    }

    /**
     * 检查阶梯分值
     * @param rewards
     */
    private void sortRewardRankLadders(List<EvalGroupRewardDTO> rewards) {
        for (EvalGroupRewardDTO reward : rewards) {
            if (! EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod())) {
                continue;
            }

            List<EvalGroupRewardLaddersDTO> ladders = reward.getLadders();
            Collections.sort(ladders, new Comparator<EvalGroupRewardLaddersDTO>() {
                @Override
                public int compare(EvalGroupRewardLaddersDTO o1, EvalGroupRewardLaddersDTO o2) {
                    if (PublicUtil.isEmpty(o1.getRankOrderType())) {
                        return -1;
                    }
                    if (PublicUtil.isEmpty(o2.getRankOrderType())) {
                        return 1;
                    }
                    //正数在前 负数在后
                    Integer order = o1.getRankOrderType().compareTo(o2.getRankOrderType());
                    if (order == 0) {
                        //大的在后
                        return o1.getLower().subtract(o2.getLower()).intValue();
                    }
                    return order;
                }
            });

        }
    }

    /**
     * 检查考评组指标
     *
     * @param evalGroupDTO
     */
    public void checkIndicator(EvalGroupDTO evalGroupDTO) {
        for (EvalGroupIndicatorDTO indicator : evalGroupDTO.getIndicators()) {
            String indicatorName = indicator.getName();

            if (ScoreWayEnum.LADDER.equals(indicator.getScoreWay())) {
                BV.notNull(indicator.getLaddersType(), indicatorName + " 台阶数据类型不能为空");
            }

            if (PublicUtil.isNotEmpty(indicator.getLadderParams())) {
                BigDecimal proportion = indicator.getLadderParams().stream()
                        .map(EvalGroupIndicatorParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + indicator.getName() + "】台阶占比总和必须为100");

                for (EvalGroupIndicatorParamDTO paramDTO : indicator.getLadderParams()) {
                    if (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(paramDTO.getTargetType()) || PublicUtil.isEmpty(paramDTO.getTargetValue()))) {
                        paramDTO.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(indicator.getCommissionParams())) {
                BigDecimal proportion = indicator.getCommissionParams().stream()
                        .map(EvalGroupIndicatorParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + indicator.getName() + "】提成占比总和必须为100");

                for (EvalGroupIndicatorParamDTO paramDTO : indicator.getCommissionParams()) {
                    if (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(paramDTO.getTargetType()) || PublicUtil.isEmpty(paramDTO.getTargetValue()))) {
                        paramDTO.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(indicator.getConds())) {
                for (EvalGroupIndicatorPreconditionDTO preconditionDTO : indicator.getConds()) {
                    if (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(preconditionDTO.getTargetType()) || PublicUtil.isEmpty(preconditionDTO.getTargetValue()))) {
                        preconditionDTO.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

        }
    }

    /**
     * 检查考评组指标
     *
     * @param evalGroupDTO
     */
    public void checkReward(EvalGroupDTO evalGroupDTO) {
        for (EvalGroupRewardDTO reward : evalGroupDTO.getRewards()) {
            String rewardName = reward.getName();

            if (EvalRewardCalMethodEnum.LADDER.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.LADDER_DOUBLE.equals(reward.getCalMethod()) ||
                    EvalRewardCalMethodEnum.RANK.equals(reward.getCalMethod())) {
                BV.notNull(reward.getLaddersType(), rewardName + " 台阶数据类型不能为空");
            }

            if (PublicUtil.isNotEmpty(reward.getCommissionParams())) {
                BigDecimal proportion = reward.getCommissionParams().stream()
                        .map(EvalGroupRewardParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + rewardName + "】台阶占比总和必须为100");

                for (EvalGroupRewardParamDTO commissionParam : reward.getCommissionParams()) {
                    if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&
                            (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {
                        commissionParam.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(reward.getLadderParams())) {
                BigDecimal proportion = reward.getLadderParams().stream()
                        .map(EvalGroupRewardParamDTO::getProportion)
                        .reduce(BigDecimal.ZERO, BigDecimal::add);
                BV.isTrue(Constant.ONE_HUNDRED.compareTo(proportion) == 0, "【" + rewardName + "】提成占比总和必须为100");

                for (EvalGroupRewardParamDTO commissionParam : reward.getLadderParams()) {
                    if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&
                            (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {
                        commissionParam.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }

            if (PublicUtil.isNotEmpty(reward.getConds())) {
                for (EvalGroupRewardPreconditionDTO preconditionDTO : reward.getConds()) {
                    if (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()) &&
                            (PublicUtil.isEmpty(preconditionDTO.getTargetType()) || PublicUtil.isEmpty(preconditionDTO.getTargetValue()))) {
                        preconditionDTO.setTargetType(TargetTypeEnum.NO);
                    }
                }
            }
        }
    }

    /**
     * 分页查询
     * @param dto
     * @return
     */
    public AppPage<EvalVO> evalPage(EvalGroupQueryDTO dto) {
        PageData<Eval> pageData = evalService.page(new PageData<Eval>(dto.getCurrent(), dto.getPageSize()),
                Wrappers.<Eval>lambdaQuery()
                        .eq(Eval::getGroupId, dto.getGroupId())
                        .eq(PublicUtil.isNotEmpty(dto.getStatus()), Eval::getStatus, dto.getStatus())
                        .eq(Eval::getYn, Boolean.TRUE)
                        .last("ORDER BY FIELD(`status`,3,1,2,4)")
        );

//        Map<Long, String> approvalRecordMap = new HashMap<>();
//        if (PublicUtil.isNotEmpty(pageData.getRecords())) {
//            List<Long> evalIds = pageData.getRecords().stream().map(Eval::getId).collect(Collectors.toList());
//            List<ApprovalRecord> approvalRecords = approvalRecordService.list(Wrappers.<ApprovalRecord>lambdaQuery()
//                    .in(ApprovalRecord::getDataId, kpiGroupIds)
//                    .eq(ApprovalRecord::getApprovalType, ApprovalTypeEnum.KPI)
//                    .eq(ApprovalRecord::getYn, Boolean.TRUE));
//
//            approvalRecordMap = approvalRecords.stream().collect(Collectors.toMap(ApprovalRecord::getDataId, ApprovalRecord::getApprovalNo));
//        }
//        Map<Long, String> finalApprovalRecordMap = approvalRecordMap;
        return PublicUtil.toPage(pageData, eval -> {
            EvalVO evalVO = PublicUtil.copy(eval, EvalVO.class);
//            kpiGroupVo.setApprovalNo(finalApprovalRecordMap.getOrDefault(kpiGroup.getId(), ""));
//            kpiGroupVo.setBeginTime(kpiGroup.getBeginTime());
//            kpiGroupVo.setOverTime(kpiGroup.getOverTime());
            return evalVO;
        });
    }

    /**
     * 考评组详情
     *
     * @param evalId
     * @return
     */
    public EvalVO evalDetail(Long evalId) {
        Eval eval = evalService.getById(evalId);
        BV.notNull(eval, "考评配置不存在，请重试");
        EvalVO evalVO = PublicUtil.copy(eval, EvalVO.class);

        List<EvalGroup> evalGroups = evalGroupService.list(Wrappers.<EvalGroup>lambdaQuery()
                .in(EvalGroup::getEvalId, evalId)
                .in(EvalGroup::getYn, Boolean.TRUE)
        );
        List<EvalGroupVO> evalGroupVOs = PublicUtil.copyList(evalGroups, EvalGroupVO.class);
        for (EvalGroupVO evalGroupVO : evalGroupVOs) {
            this.setEvalGroupIndicator(evalGroupVO);
            this.setEvalGroupReward(evalGroupVO);
            this.setTargetVos(evalGroupVO);
        }
        evalVO.setEvalGroups(evalGroupVOs);

        return evalVO;
    }


    /**
     * 设置奖励
     *
     * @param evalGroupVO
     */
    public void setEvalGroupReward(EvalGroupVO evalGroupVO) {
        Long evalGroupId = evalGroupVO.getId();
        List<EvalGroupReward> rewards = evalGroupRewardService.list(Wrappers.<EvalGroupReward>lambdaQuery()
                .eq(EvalGroupReward::getEvalGroupId, evalGroupId)
                .eq(EvalGroupReward::getYn, Boolean.TRUE)
        );
        if (PublicUtil.isNotEmpty(rewards)) {
            List<EvalGroupRewardVO> rewardVOS = PublicUtil.copyList(rewards, EvalGroupRewardVO.class);
            evalGroupVO.setRewards(rewardVOS);

            Map<Long, List<EvalGroupRewardParamVO>> rewardParamMap = this.getEvalGroupRewardParamVO(evalGroupId);
            Map<Long, List<EvalGroupRewardPreconditionVO>> rewardCondMap = this.getEvalGroupRewardPreconditionVO(evalGroupId);

            for (EvalGroupRewardVO reward : rewardVOS) {
                Long rewardId = reward.getId();

                List<EvalGroupRewardParamVO> rewardParamVOS = rewardParamMap.getOrDefault(rewardId, new ArrayList<>());
                Map<ParamTypeEnum, List<EvalGroupRewardParamVO>> paramTypeMap = rewardParamVOS.stream()
                        .collect(Collectors.groupingBy(EvalGroupRewardParamVO::getParamType));
                reward.setCommissionParams(paramTypeMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));
                reward.setLadderParams(paramTypeMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));
                reward.setConds(rewardCondMap.getOrDefault(rewardId, new ArrayList<>()));

                List<EvalGroupRewardLadders> rewardLadders = evalGroupRewardLaddersService.list(Wrappers.<EvalGroupRewardLadders>lambdaQuery()
                        .eq(EvalGroupRewardLadders::getEvalGroupRewardId, rewardId)
                        .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());
                    rewardLaddersVOS.add(rewardLaddersVO);
                }
                reward.setLadders(rewardLaddersVOS);

                setRewardTargetVos(reward);
            }
        }
    }

    /**
     * 装换为目标对象
     *
     * @return
     */
    public void setRewardTargetVos(EvalGroupRewardVO reward) {

        List<EvalGroupRewardParamVO> ladderParams = reward.getLadderParams();
        List<EvalGroupRewardParamVO> commissionParams = reward.getCommissionParams();
        List<EvalGroupRewardPreconditionVO> conds = reward.getConds();

        List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
        for (EvalGroupRewardParamVO paramVO : ladderParams) {
            if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        for (EvalGroupRewardParamVO paramVO : commissionParams) {
            if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        for (EvalGroupRewardPreconditionVO preconditionVO : conds) {
            if (PublicUtil.isNotEmpty(preconditionVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        reward.setTargets(targetVOS);
    }
    /**
     * 装换为目标对象
     *
     * @return
     */
    public void setIndicatorTargetVos(EvalGroupIndicatorVO indicatorVO) {

        List<EvalGroupIndicatorParamVO> ladderParams = indicatorVO.getLadderParams();
        List<EvalGroupIndicatorParamVO> commissionParams = indicatorVO.getCommissionParams();
        List<EvalGroupIndicatorPreconditionVO> conds = indicatorVO.getConds();

        List<EvalGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
        for (EvalGroupIndicatorParamVO paramVO : ladderParams) {
            if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        for (EvalGroupIndicatorParamVO paramVO : commissionParams) {
            if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        for (EvalGroupIndicatorPreconditionVO preconditionVO : conds) {
            if (PublicUtil.isNotEmpty(preconditionVO.getTargetType())) {
                EvalGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionVO, EvalGroupIndicatorTargetVO.class);
                if (TargetTypeEnum.RATIO.equals(targetVO.getTargetType())) {
                    targetVO.setTargetValue(targetVO.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                }
                targetVOS.add(targetVO);
            }
        }

        indicatorVO.setTargets(targetVOS);
    }


    /**
     * 考评奖惩条件
     *
     * @param evalGroupId
     * @return
     */
    public Map<Long, List<EvalGroupRewardPreconditionVO>> getEvalGroupRewardPreconditionVO(Long evalGroupId) {
        List<EvalGroupRewardPrecondition> rewardPreconditions = evalGroupRewardPreconditionService.list(Wrappers.<EvalGroupRewardPrecondition>lambdaQuery()
                .eq(EvalGroupRewardPrecondition::getEvalGroupId, evalGroupId)
                .eq(EvalGroupRewardPrecondition::getYn, Boolean.TRUE)
        );

        List<EvalGroupRewardPreconditionVO> rewardPreconditionVOS = new ArrayList<>();
        for (EvalGroupRewardPrecondition precondition : rewardPreconditions) {
            EvalGroupRewardPreconditionVO preconditionVO = PublicUtil.copy(precondition, EvalGroupRewardPreconditionVO.class);
            preconditionVO.convertToPercent();
            rewardPreconditionVOS.add(preconditionVO);
        }

        Map<Long, List<EvalGroupRewardPreconditionVO>> rewardCondMap = rewardPreconditionVOS.stream()
                .collect(Collectors.groupingBy(EvalGroupRewardPreconditionVO::getEvalGroupRewardId));

        return rewardCondMap;
    }

    /**
     * 考评奖惩参数
     *
     * @param evalGroupId
     * @return
     */
    public Map<Long, List<EvalGroupRewardParamVO>> getEvalGroupRewardParamVO(Long evalGroupId) {
        List<EvalGroupRewardParam> rewardParams = evalGroupRewardParamService.list(Wrappers.<EvalGroupRewardParam>lambdaQuery()
                .eq(EvalGroupRewardParam::getEvalGroupId, evalGroupId)
                .eq(EvalGroupRewardParam::getYn, Boolean.TRUE)
        );

        List<EvalGroupRewardParamVO> rewardParamVOS = new ArrayList<>();
        for (EvalGroupRewardParam rewardParam : rewardParams) {
            EvalGroupRewardParamVO paramVO = PublicUtil.copy(rewardParam, EvalGroupRewardParamVO.class);
            paramVO.convertToPercent();
            rewardParamVOS.add(paramVO);
        }

        Map<Long, List<EvalGroupRewardParamVO>> rewardParamMap = rewardParamVOS.stream()
                .collect(Collectors.groupingBy(EvalGroupRewardParamVO::getEvalGroupRewardId));

        return rewardParamMap;
    }

    /**
     * 设置考评指标
     *
     * @param evalGroupVO
     */
    public void setEvalGroupIndicator(EvalGroupVO evalGroupVO) {
        Long evalGroupId = evalGroupVO.getId();
        List<EvalGroupIndicator> indicators = evalGroupIndicatorService.list(Wrappers.<EvalGroupIndicator>lambdaQuery()
                .eq(EvalGroupIndicator::getEvalGroupId, evalGroupId)
                .eq(EvalGroupIndicator::getYn, Boolean.TRUE)
        );
        if (PublicUtil.isNotEmpty(indicators)) {
            List<EvalGroupIndicatorVO> indicatorVOS = PublicUtil.copyList(indicators, EvalGroupIndicatorVO.class);
            evalGroupVO.setIndicators(indicatorVOS);

            Map<Long, List<EvalGroupIndicatorParamVO>> paramMap = this.getEvalGroupIndicatorParamVO(evalGroupId);
            Map<Long, List<EvalGroupIndicatorPreconditionVO>> condMap = this.getEvalGroupIndicatorCondVO(evalGroupId);

            for (EvalGroupIndicatorVO indicatorVO : indicatorVOS) {
                Long kpiGroupIndicatorId = indicatorVO.getId();

                //参数
                List<EvalGroupIndicatorParamVO> indicatorParamVOS = paramMap.getOrDefault(kpiGroupIndicatorId, new ArrayList<>());
                Map<ParamTypeEnum, List<EvalGroupIndicatorParamVO>> paramTypeMap = indicatorParamVOS.stream()
                        .collect(Collectors.groupingBy(EvalGroupIndicatorParamVO::getParamType));
                indicatorVO.setCommissionParams(paramTypeMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));
                indicatorVO.setLadderParams(paramTypeMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));

                //条件
                List<EvalGroupIndicatorPreconditionVO> preconditionVOS = condMap.getOrDefault(kpiGroupIndicatorId, new ArrayList<>());
                for (EvalGroupIndicatorPreconditionVO cond : preconditionVOS) {
                    List<EvalGroupIndicatorPreconditionLadders> condLadders = evalGroupIndicatorPreconditionLaddersService.list(Wrappers.<EvalGroupIndicatorPreconditionLadders>lambdaQuery()
                                    .eq(EvalGroupIndicatorPreconditionLadders::getPreconditionId, cond.getId())
                                    .eq(EvalGroupIndicatorPreconditionLadders::getYn, Boolean.TRUE));

                    List<EvalGroupIndicatorPreconditionLaddersVO> condLaddersVOS = new ArrayList<>();
                    for (EvalGroupIndicatorPreconditionLadders condLadder : condLadders) {
                        EvalGroupIndicatorPreconditionLaddersVO condLaddersVO = PublicUtil.copy(condLadder, EvalGroupIndicatorPreconditionLaddersVO.class);
                        condLaddersVO.convertLaddersToPercent(cond.getTargetType(), cond.getDataType());
                        condLaddersVOS.add(condLaddersVO);
                    }
                    cond.setLadders(condLaddersVOS);
                }
                Collections.sort(preconditionVOS, Comparator.comparingInt(EvalGroupIndicatorPreconditionVO::getSort));
                indicatorVO.setConds(preconditionVOS);

                //设置阶梯
                if (ScoreWayEnum.LADDER.equals(indicatorVO.getScoreWay())) {
                    List<EvalGroupIndicatorLadders> ladders = evalGroupIndicatorLaddersService.list(Wrappers.<EvalGroupIndicatorLadders>lambdaQuery()
                            .in(EvalGroupIndicatorLadders::getEvalGroupIndicatorId, kpiGroupIndicatorId)
                            .eq(EvalGroupIndicatorLadders::getYn, Boolean.TRUE)
                            .orderByAsc(EvalGroupIndicatorLadders::getId)
                    );
                    List<EvalGroupIndicatorLaddersVO> laddersVOS = PublicUtil.copyList(ladders, EvalGroupIndicatorLaddersVO.class);
                    laddersVOS.stream().forEach(l -> l.convertLadderToPercent(indicatorVO.getLaddersType()));
                    indicatorVO.setLadders(laddersVOS);
                }

                setIndicatorTargetVos(indicatorVO);
            }
        }
    }

    /**
     * 考评参数
     *
     * @param evalGroupId
     * @return
     */
    public Map<Long, List<EvalGroupIndicatorParamVO>> getEvalGroupIndicatorParamVO(Long evalGroupId) {
        List<EvalGroupIndicatorParam> params = evalGroupIndicatorParamService.list(Wrappers.<EvalGroupIndicatorParam>lambdaQuery()
                .eq(EvalGroupIndicatorParam::getEvalGroupId, evalGroupId)
                .eq(EvalGroupIndicatorParam::getYn, Boolean.TRUE)
        );

        List<EvalGroupIndicatorParamVO> paramVOS = new ArrayList<>();
        for (EvalGroupIndicatorParam param : params) {
            EvalGroupIndicatorParamVO paramVO = PublicUtil.copy(param, EvalGroupIndicatorParamVO.class);
            paramVO.processPercent();
            paramVOS.add(paramVO);
        }

        Map<Long, List<EvalGroupIndicatorParamVO>> indicatorParamMap = paramVOS.stream()
                .collect(Collectors.groupingBy(EvalGroupIndicatorParamVO::getEvalGroupIndicatorId));

        return indicatorParamMap;
    }

    /**
     * 获取指标条件
     *
     * @param evalGroupId
     * @return
     */
    public Map<Long, List<EvalGroupIndicatorPreconditionVO>> getEvalGroupIndicatorCondVO(Long evalGroupId) {
        List<EvalGroupIndicatorPrecondition> preconditions = evalGroupIndicatorPreconditionService.list(Wrappers.<EvalGroupIndicatorPrecondition>lambdaQuery()
                .eq(EvalGroupIndicatorPrecondition::getEvalGroupId, evalGroupId)
                .eq(EvalGroupIndicatorPrecondition::getYn, Boolean.TRUE)
        );

        List<EvalGroupIndicatorPreconditionVO> preconditionVOS = new ArrayList<>();
        for (EvalGroupIndicatorPrecondition precondition : preconditions) {
            EvalGroupIndicatorPreconditionVO preconditionVO = PublicUtil.copy(precondition, EvalGroupIndicatorPreconditionVO.class);
            preconditionVO.processPercent();
            preconditionVOS.add(preconditionVO);
        }

        Map<Long, List<EvalGroupIndicatorPreconditionVO>> indicatorCondMap = preconditionVOS.stream()
                .collect(Collectors.groupingBy(EvalGroupIndicatorPreconditionVO::getEvalGroupIndicatorId));

        return indicatorCondMap;
    }


    /**
     * 审批考评组
     *
     * @param approvalRecord
     * @param result
     */
    public void approvalEvalConfig(ApprovalRecord approvalRecord, ApprovalResultEvent result) {
        log.info("收到岗位最低收入补偿审批信息：{}", JSON.toJSONString(result));
        Boolean agree = result.getAgree();
        SettingDraft settingDraft = settingDraftService.getById(approvalRecord.getDataId());
        BV.isTrue(PublicUtil.isNotEmpty(settingDraft), "考评草稿数据不存在");

        SettingDraftStatusEnum draftStatus = (agree) ? SettingDraftStatusEnum.RELEASE_APPROVAL_AGREE :
                SettingDraftStatusEnum.RELEASE_APPROVAL_REJECT;

        if (! agree) {
            if (! SettingDraftStatusEnum.RELEASE_APPROVAL_CANCEL.equals(settingDraft.getStatus())) {
                settingDraftService.update(Wrappers.<SettingDraft>lambdaUpdate()
                        .set(SettingDraft::getStatus, draftStatus)
                        .set(SettingDraft::getUpdateTime, new Date())
                        .eq(SettingDraft::getId, settingDraft.getId())
                );
            }
            return;
        }

        EvalDTO evalDTO = JSON.parseObject(settingDraft.getContent(), EvalDTO.class);
        Eval eval = evalGroupDataService.saveEval(evalDTO);
        for (EvalGroupDTO evalGroupDTO : evalDTO.getEvalGroups()) {
            EvalGroup evalGroup = evalGroupDataService.saveEvalGroup(evalGroupDTO, eval);
            evalGroupDataService.saveEvalGroupIndicator(evalGroup, evalGroupDTO.getIndicators());
            evalGroupDataService.saveEvalGroupReward(evalGroup, evalGroupDTO.getRewards());
        }

        settingDraftService.update(Wrappers.<SettingDraft>lambdaUpdate()
                .set(SettingDraft::getUnionId, eval.getId())
                .set(SettingDraft::getStatus, draftStatus)
                .set(SettingDraft::getUpdateTime, new Date())
                .eq(SettingDraft::getId, settingDraft.getId())
        );

    }

    /**
     * 禁用考评
     *
     * @param id
     * @param currentUser
     */
    public void disableEval(Long id, LoginAuthBean currentUser) {
        Eval eval = evalService.getById(id);
        BV.notNull(eval, "考评配置不存在，请重试");

        Boolean statusCheck = SettingStatusEnum.BE_EFFECTIVE.equals(eval.getStatus()) ||
                SettingStatusEnum.EFFECTIVE.equals(eval.getStatus());
        BV.isTrue(statusCheck, "只有生效中、待生效考评配置能禁用");

        log.info("禁用绩效组，id：{},操作人：{}", id, currentUser);

        evalService.update(Wrappers.<Eval>lambdaUpdate()
                .set(Eval::getUpdateTime, new Date())
                .set(Eval::getYn, Boolean.FALSE)
                .eq(Eval::getId, eval.getId())
        );

        if (SettingStatusEnum.EFFECTIVE.equals(eval.getStatus())) {
            evalUserPoolService.update(Wrappers.<EvalUserPool>lambdaUpdate()
                    .set(EvalUserPool::getUpdateTime, new Date())
                    .set(EvalUserPool::getYn, Boolean.FALSE)
                    .eq(EvalUserPool::getId, id)
                    .eq(EvalUserPool::getYn, Boolean.TRUE)
            );
            evalShopPoolService.update(Wrappers.<EvalShopPool>lambdaUpdate()
                    .set(EvalShopPool::getUpdateTime, new Date())
                    .set(EvalShopPool::getYn, Boolean.FALSE)
                    .eq(EvalShopPool::getId, id)
                    .eq(EvalShopPool::getYn, Boolean.TRUE)
            );
        }

    }
}