KPI / fw-morax

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

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