KPI / fw-morax

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

  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.constant.Constant;

  import cn.fw.morax.common.pojo.event.ApprovalResultEvent;

  import cn.fw.morax.common.pojo.event.KpiGroupChangeEvent;

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

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

  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.kpi.*;

  import cn.fw.morax.domain.dto.kpi.*;

  import cn.fw.morax.domain.dto.query.KpiGroupQueryDTO;

  import cn.fw.morax.domain.dto.query.KpiGroupRepeatQueryDTO;

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

  import cn.fw.morax.domain.vo.kpi.*;

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

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

  import cn.fw.morax.service.data.ApprovalRecordService;
  import cn.fw.morax.service.data.SettingDraftService;

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

  import com.alibaba.fastjson.JSON;

  import com.alibaba.fastjson.JSONObject;

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

  import com.google.common.collect.Lists;

  import com.google.common.collect.Maps;

  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 org.springframework.util.CollectionUtils;

  import java.math.BigDecimal;

  import java.math.RoundingMode;

  import java.text.SimpleDateFormat;

  import java.time.LocalDate;

  import java.time.LocalDateTime;

  import java.time.YearMonth;

  import java.util.*;

  import java.util.stream.Collectors;
  
  import static cn.fw.common.businessvalidator.Validator.BV;
  
  @RequiredArgsConstructor
  @Service
  @Slf4j
  public class KpiGroupBizService {
  

      private final KpiGroupIndicatorLaddersService kpiGroupIndicatorLaddersService;

      private final KpiGroupIndicatorService kpiGroupIndicatorService;

      private final KpiGroupUserBizService kpiGroupUserBizService;

      private final KpiStarLaddersService kpiStarLaddersService;

      private final KpiGroupDataService kpiGroupDataService;

      private final ApprovalBizService approvalBizService;

      private final ApprovalRecordService approvalRecordService;

      private final CommonService commonService;

      private final IndicatorsService indicatorsService;

      private final SettingDraftService settingDraftService;

      private final KpiGroupService kpiGroupService;

      private final KpiPoolService kpiPoolService;

      private final KpiGroupIndicatorPreconditionService kpiGroupIndicatorPreconditionService;

      private final KpiGroupIndicatorParamService kpiGroupIndicatorParamService;

      private final KpiGroupIndicatorPreconditionLaddersService kpiGroupIndicatorCondLaddersService;

      private final KpiGroupRankStarLaddersService kpiGroupRankStarLaddersService;

      private final KpiGroupRankService kpiGroupRankService;

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

      /**
       * 分页查询
       * @param dto
       * @return
       */

      public AppPage<KpiGroupVO> kpiGroupPage(KpiGroupQueryDTO dto) {

          PageData<KpiGroup> pageData = kpiGroupService.page(new PageData<>(dto.getCurrent(), dto.getPageSize()),
                  Wrappers.<KpiGroup>lambdaQuery()
                          .eq(KpiGroup::getGroupId, dto.getGroupId())

                          .eq(PublicUtil.isNotEmpty(dto.getPostId()), KpiGroup::getPostId, dto.getPostId())

                          .eq(PublicUtil.isNotEmpty(dto.getStatus()), KpiGroup::getStatus, dto.getStatus())

                          .eq(KpiGroup::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> kpiGroupIds = pageData.getRecords().stream().map(KpiGroup::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, (v1, v2) -> v1));

          }
          Map<Long, String> finalApprovalRecordMap = approvalRecordMap;

          return PublicUtil.toPage(pageData, kpiGroup -> {

              KpiGroupVO kpiGroupVo = PublicUtil.copy(kpiGroup, KpiGroupVO.class);

              kpiGroupVo.setApprovalNo(finalApprovalRecordMap.getOrDefault(kpiGroup.getId(), ""));

              kpiGroupVo.setBeginTime(kpiGroup.getBeginTime());
              kpiGroupVo.setOverTime(kpiGroup.getOverTime());

              return kpiGroupVo;
          });
      }
  

      /**

       * 禁用绩效组
       *
       * @param kpiGroupId
       */
      public void disableKpiGroup(Long kpiGroupId) {
          KpiGroup kpiGroup = kpiGroupService.getById(kpiGroupId);
          BV.notNull(kpiGroup, "绩效配置不存在，请重试");
          BV.isTrue(SettingStatusEnum.EFFECTIVE.equals(kpiGroup.getStatus()), "生效中才能禁用，请重试");
  
          kpiGroup.setStatus(SettingStatusEnum.DRAFT);
          kpiGroup.setUpdateTime(new Date());
          kpiGroupService.updateById(kpiGroup);
  

      }

      /**
       * 绩效组排名组合详情
       *
       * @param id
       * @return
       */
      public KpiGroupRankVO kpiGroupRankDetail(Long id) {
          KpiGroupRank kpiGroupRank = kpiGroupRankService.getById(id);
          KpiGroupRankVO kpiGroupRankVO = PublicUtil.copy(kpiGroupRank, KpiGroupRankVO.class);
          kpiGroupRankVO.setKpiGroups(new ArrayList<>());
          for (Long kpiGroupId : kpiGroupRankVO.getKpiGroupIds()) {
              KpiGroupVO kpiGroupVO = this.kpiGroupDetail(kpiGroupId);
              kpiGroupRankVO.getKpiGroups().add(kpiGroupVO);
          }
          List<KpiGroupRankStarLadders> starLadders = kpiGroupRankStarLaddersService.list(Wrappers.<KpiGroupRankStarLadders>lambdaQuery()
                  .eq(KpiGroupRankStarLadders::getKpiGroupRankId, id)
                  .eq(KpiGroupRankStarLadders::getYn, Boolean.TRUE)
          );
          List<KpiGroupRankStarLaddersVO> starLaddersVOS = PublicUtil.copyList(starLadders, KpiGroupRankStarLaddersVO.class);
          for (KpiGroupRankStarLaddersVO starLaddersVO : starLaddersVOS) {
              starLaddersVO.setUpper(starLaddersVO.getUpper().multiply(Constant.ONE_HUNDRED));
              starLaddersVO.setLower(starLaddersVO.getLower().multiply(Constant.ONE_HUNDRED));
          }
          kpiGroupRankVO.setStarLadders(starLaddersVOS);
          if (PublicUtil.isNotEmpty(kpiGroupRankVO.getRevokedScoreRatio())) {
              kpiGroupRankVO.setRevokedScoreRatio(kpiGroupRankVO.getRevokedScoreRatio().multiply(Constant.ONE_HUNDRED));
          }
          return kpiGroupRankVO;

      }
  
  
      /**

       * 绩效组详情
       * @param kpiGroupId
       * @return
       */

      public KpiGroupVO kpiGroupDetail(Long kpiGroupId) {

          KpiGroup kpiGroup = kpiGroupService.getById(kpiGroupId);
          BV.notNull(kpiGroup, "绩效配置不存在，请重试");

          KpiGroupVO kpiGroupVo = KpiGroupVO.convertKpiGroup(kpiGroup);

  
          //星级数据

          List<KpiStarLadders> starLadders = kpiStarLaddersService.list(Wrappers.<KpiStarLadders>lambdaQuery()

                  .eq(KpiStarLadders::getKpiGroupId, kpiGroupVo.getId())

                  .eq(KpiStarLadders::getYn, Boolean.TRUE)

          );

          List<KpiStarLaddersVO> starLaddersVos = PublicUtil.copyList(starLadders, KpiStarLaddersVO.class);

          starLaddersVos.stream().forEach(KpiStarLaddersVO::processPercent);

          kpiGroupVo.setStarLadders(starLaddersVos);

          //指标数据
          this.setIndicatorVo(kpiGroupVo);
          return kpiGroupVo;
      }
  
      /**
       * 设置指标
       *
       * @param kpiGroupVo
       */
      public void setIndicatorVo(KpiGroupVO kpiGroupVo) {
          Long kpiGroupId = kpiGroupVo.getId();
          List<KpiGroupIndicator> indicators = kpiGroupIndicatorService.list(Wrappers.<KpiGroupIndicator>lambdaQuery()

                  .eq(KpiGroupIndicator::getKpiGroupId, kpiGroupId)

                  .eq(KpiGroupIndicator::getYn, Boolean.TRUE)

          );

          Map<Long, List<KpiGroupIndicatorParamVO>> paramMap = kpiGroupIndicatorParamService.getKpiGroupParamMap(kpiGroupId);

          Map<Long, List<KpiGroupIndicatorPreconditionVO>> condMap = kpiGroupIndicatorPreconditionService.getKpiGroupIndicatorCondVO(kpiGroupId);

  
  
          List<KpiGroupIndicatorVO> kpiGroupIndicatorVOS = PublicUtil.copyList(indicators, KpiGroupIndicatorVO.class);

          for (KpiGroupIndicatorVO indicatorVO : kpiGroupIndicatorVOS) {

              Long kpiGroupIndicatorId = indicatorVO.getId();

              //参数-台阶得分

              List<KpiGroupIndicatorParamVO> indicatorParamVOS = paramMap.getOrDefault(kpiGroupIndicatorId, new ArrayList<>());
              Map<ParamTypeEnum, List<KpiGroupIndicatorParamVO>> paramTypeMap = indicatorParamVOS.stream()

                      .collect(Collectors.groupingBy(KpiGroupIndicatorParamVO::getParamType));

              indicatorVO.setCommissionParams(paramTypeMap.getOrDefault(ParamTypeEnum.COMMISSION, new ArrayList<>()));
              indicatorVO.setLadderParams(paramTypeMap.getOrDefault(ParamTypeEnum.LADDER, new ArrayList<>()));

              //前置条件

              List<KpiGroupIndicatorPreconditionVO> preconditionVOS = condMap.getOrDefault(kpiGroupIndicatorId, new ArrayList<>());
              for (KpiGroupIndicatorPreconditionVO cond : preconditionVOS) {

  
                  List<KpiGroupIndicatorPreconditionLaddersVO> condLaddersVOS = kpiGroupIndicatorCondLaddersService.getVOS(
                          cond.getId(), cond.getTargetType(), cond.getDataType());

                  cond.setCondLadders(condLaddersVOS);

              }

              Collections.sort(preconditionVOS, Comparator.comparingInt(KpiGroupIndicatorPreconditionVO::getSort));
              indicatorVO.setConds(preconditionVOS);
  
              //设置目标对象
              setTargetVos(indicatorVO);

          }

          //设置台阶得分阶梯

          List<KpiGroupIndicatorLadders> kpiGroupIndicatorLadders = kpiGroupIndicatorLaddersService.list(Wrappers.<KpiGroupIndicatorLadders>lambdaQuery()

                  .in(KpiGroupIndicatorLadders::getKpiGroupIndicatorId,
                          kpiGroupIndicatorVOS.stream().map(KpiGroupIndicatorVO::getId).collect(Collectors.toList()))

                  .eq(KpiGroupIndicatorLadders::getYn, Boolean.TRUE)

                  .orderByAsc(KpiGroupIndicatorLadders::getId)

          );
          Map<Long, List<KpiGroupIndicatorLadders>> indicatorLaddersMap = kpiGroupIndicatorLadders.stream().collect(Collectors.groupingBy(KpiGroupIndicatorLadders::getKpiGroupIndicatorId));

          for (KpiGroupIndicatorVO indicatorVo : kpiGroupIndicatorVOS) {

              if (indicatorLaddersMap.containsKey(indicatorVo.getId())) {

                  List<KpiGroupIndicatorLaddersVO> laddersVos = PublicUtil.copyList(indicatorLaddersMap.get(indicatorVo.getId()), KpiGroupIndicatorLaddersVO.class);

                  for (KpiGroupIndicatorLaddersVO laddersVO : laddersVos) {

                      laddersVO.convertLadderToPercent(indicatorVo.getLaddersType());

                  }

                  indicatorVo.setIndicatorLadders(laddersVos);
              }
          }

          kpiGroupVo.setIndicators(kpiGroupIndicatorVOS);

      }
  
      /**

       * 装换为目标对象

       *

       * @return

       */

      public void setTargetVos(KpiGroupIndicatorVO indicatorVO) {
  

          List<KpiGroupIndicatorParamVO> ladderParams = Optional.ofNullable(indicatorVO.getLadderParams()).orElse(new ArrayList<>());
          List<KpiGroupIndicatorParamVO> commissionParams = Optional.ofNullable(indicatorVO.getCommissionParams()).orElse(new ArrayList<>());
          List<KpiGroupIndicatorPreconditionVO> conds =Optional.ofNullable(indicatorVO.getConds()).orElse(new ArrayList<>());

  
          List<KpiGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
          for (KpiGroupIndicatorParamVO paramVO : ladderParams) {
              if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                  KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, KpiGroupIndicatorTargetVO.class);

                  targetVOS.add(targetVO);
              }

          }

          for (KpiGroupIndicatorParamVO paramVO : commissionParams) {
              if (PublicUtil.isNotEmpty(paramVO.getTargetType())) {
                  KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramVO, KpiGroupIndicatorTargetVO.class);

                  targetVOS.add(targetVO);
              }

          }

  
          for (KpiGroupIndicatorPreconditionVO preconditionVO : conds) {
              if (PublicUtil.isNotEmpty(preconditionVO.getTargetType())) {
                  KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionVO, KpiGroupIndicatorTargetVO.class);

                  targetVOS.add(targetVO);
              }

          }

  
          indicatorVO.setTargets(targetVOS);

      }
  

      /**
       * 装换为目标对象
       *
       * @return
       */
      public void setTargetVos(KpiGroupDTO kpiGroupDTO) {
  
          for (KpiGroupIndicatorDTO indicatorDTO : kpiGroupDTO.getIndicators()) {

              List<KpiGroupIndicatorParamDTO> ladderParams = Optional.ofNullable(indicatorDTO.getLadderParams()).orElse(new ArrayList<>());
              List<KpiGroupIndicatorParamDTO> commissionParams = Optional.ofNullable(indicatorDTO.getCommissionParams()).orElse(new ArrayList<>());
              List<KpiGroupIndicatorPreconditionDTO> conds = Optional.ofNullable(indicatorDTO.getConds()).orElse(new ArrayList<>());

  
              List<KpiGroupIndicatorTargetVO> targetVOS = new ArrayList<>();
              for (KpiGroupIndicatorParamDTO paramDTO : ladderParams) {
                  if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                      KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, KpiGroupIndicatorTargetVO.class);
                      targetVOS.add(targetVO);
                  }
              }
  
              for (KpiGroupIndicatorParamDTO paramDTO : commissionParams) {
                  if (PublicUtil.isNotEmpty(paramDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(paramDTO.getTargetType()))) {
                      KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(paramDTO, KpiGroupIndicatorTargetVO.class);
                      targetVOS.add(targetVO);
                  }
              }
  
              for (KpiGroupIndicatorPreconditionDTO preconditionDTO : conds) {
                  if (PublicUtil.isNotEmpty(preconditionDTO.getTargetType()) && (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()))) {
                      KpiGroupIndicatorTargetVO targetVO = PublicUtil.copy(preconditionDTO, KpiGroupIndicatorTargetVO.class);
                      targetVOS.add(targetVO);
                  }
              }
  
              indicatorDTO.setTargets(targetVOS);
          }
      }
  

      /**
       * 绩效组保存
       * @param dto
       */
      @Transactional(rollbackFor = Exception.class)
      @DisLock(prefix = "#this.getSavePrefix()", key = "#dto.getPostId()", message = "保存中，请勿重复操作")

      public KpiGroupSavePromptVO saveKpi(KpiGroupDTO dto, LoginAuthBean user, Boolean submit) {

          //初始化数据

  //        this.initKpi(dto);

          //检查数据

          this.checkKpi(dto);

          this.checkNameRepetition(dto.getId(), dto.getName(), dto.getDraftId());

          this.checkKpiLadders(dto.getIndicators());

          this.checkStarLadders(dto.getStarLadders(), dto.getStarEvaluationType());

          KpiGroupSavePromptVO promptVo = this.checkShopKpiRepeat(dto);

          if (promptVo.getPrompt()) {
              return promptVo;
          }

          setTargetVos(dto);

          SettingDraft settingDraft = getSettingDraft(dto, submit);

          settingDraftService.saveOrUpdate(settingDraft);

          if (! submit) {
              return new KpiGroupSavePromptVO(false);
          }

          Integer staffNum = kpiGroupUserBizService.queryShopPostCurStaffNum(dto.getPostId(), dto.getShopIds());

          approvalBizService.applyApproveKpiDraft(dto, settingDraft, user, staffNum);

          return new KpiGroupSavePromptVO(false);

      }
  

      /**

       * 绩效组保存
       * @param dto
       */
      @Transactional(rollbackFor = Exception.class)

      @DisLock(prefix = "#this.getSavePrefix()", key = "#dto.getName()", message = "保存中，请勿重复操作")

      public KpiGroupSavePromptVO saveKpiGroupRankDraft(KpiGroupRankDTO dto, LoginAuthBean user, Boolean submit) {

          checkNameRepetition(dto.getId(), dto.getName());
          checkRankStarLadders(dto.getStarLadders(), dto.getStarEvaluationType());

          this.initKpi(dto);

          for (KpiGroupDTO kpiGroupDTO : dto.getKpiGroups()) {

              //检查数据
              this.checkKpi(kpiGroupDTO);
              this.checkNameRepetition(kpiGroupDTO.getId(), kpiGroupDTO.getName(), kpiGroupDTO.getDraftId());
              this.checkKpiLadders(kpiGroupDTO.getIndicators());

  //            KpiGroupSavePromptVO promptVo = this.checkShopKpiRepeat(kpiGroupDTO);
  //            if (promptVo.getPrompt()) {
  //                return promptVo;
  //            }

              setTargetVos(kpiGroupDTO);
          }
  
          SettingDraft settingDraft = getSettingDraft(dto, submit);
          settingDraftService.saveOrUpdate(settingDraft);
          if (! submit) {
              return new KpiGroupSavePromptVO(false);
          }
          approvalBizService.applyApproveKpiRankDraft(dto, settingDraft, user);
          return new KpiGroupSavePromptVO(false);
      }
  

      /**
       * 获取草稿
       *
       * @param dto
       * @return
       */
      public SettingDraft getSettingDraft(KpiGroupRankDTO 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.KPI_GROUP_RANK);
          } else {
              settingDraft = settingDraftService.getById(dto.getDraftId());
              BV.notNull(settingDraft, "草稿配置不存在，请重试");
          }
  

          List<Long> postIds = dto.getKpiGroups().stream().map(KpiGroupDTO::getPostId).distinct().collect(Collectors.toList());
          List<Long> shopIds = dto.getKpiGroups().stream().flatMap(kpiGroup -> kpiGroup.getShopIds().stream()).distinct().collect(Collectors.toList());
          settingDraft.setPostIds(postIds);
          settingDraft.setShopIds(shopIds);

          List<KpiGroupRankBaseInfoDTO> baseInfoDTOs = dto.getKpiGroups().stream().map(kpiGroup -> {
              return new KpiGroupRankBaseInfoDTO(kpiGroup);
          }).collect(Collectors.toList());
          settingDraft.setBaseInfo(JSON.toJSONString(baseInfoDTOs));
          settingDraft.setStatus(submit ? SettingDraftStatusEnum.RELEASE_APPROVAL : SettingDraftStatusEnum.NO_RELEASE);
          settingDraft.setName(dto.getName());
          settingDraft.setContent(JSONObject.toJSONString(dto));
          return settingDraft;
      }
  
      /**

       * 获取草稿
       *
       * @param dto
       * @return
       */

      public SettingDraft getSettingDraft(KpiGroupDTO 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.KPI);
              settingDraft.setPostId(dto.getPostId());
              settingDraft.setShopIds(dto.getShopIds());

          } else {
              settingDraft = settingDraftService.getById(dto.getDraftId());
              BV.notNull(settingDraft, "草稿配置不存在，请重试");
          }

          settingDraft.setStatus(submit ? SettingDraftStatusEnum.RELEASE_APPROVAL : SettingDraftStatusEnum.NO_RELEASE);

          settingDraft.setName(dto.getName());

          settingDraft.setContent(JSONObject.toJSONString(dto));
          return settingDraft;
      }
  
  
      /**

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

       * 检查绩效组配置状态
       *
       * @param dto
       */
      public void checkKpi(KpiGroupDTO dto) {

          Long postId = dto.getPostId();
          List<Long> shopIds = dto.getShopIds();

  //        List<KpiGroup> effectKpis = kpiGroupService.getRepeatKpis(postId, shopIds, dto.getId(), dto.getBeginTime());
  //        if (PublicUtil.isNotEmpty(effectKpis)) {
  //            Optional<KpiGroup> optional = effectKpis.stream()
  //                    .filter(kpi -> ! kpi.getStatus().equals(SettingStatusEnum.INEFFECTIVE)).findFirst();
  //            if (optional.isPresent()) {
  //                KpiGroup kpiGroup = optional.get();
  //                List<String> shopNames = new ArrayList<>(kpiGroup.getShopNames());
  //                shopNames.retainAll(dto.getShopNames());
  //                throw new BusinessException("绩效组门店【" + String.join(",", shopNames) + "】存在" +
  //                        kpiGroup.getStatus().getName() + "配置");
  //            }
  //        }
          List<SettingDraft> settingDrafts = settingDraftService.getRepeatApprovals(postId, shopIds, SettingDraftTypeEnum.KPI,
                  SettingDraftStatusEnum.RELEASE_APPROVAL, dto.getBeginTime());

          if (PublicUtil.isNotEmpty(settingDrafts)) {
              throw new BusinessException("绩效组门店存在正在生效中配置");
          }

          for (KpiGroupIndicatorDTO indicator : dto.getIndicators()) {

              if (IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(indicator.getCodeType())){
                  if (PublicUtil.isEmpty(indicator.getCode())){
                      throw new BusinessException("指标库["+indicator.getName()+"]台阶参数选择为组合指标时,必须传入对应的组合指标编码!");
                  }
              }

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

                  for (KpiGroupIndicatorParamDTO commissionParam : indicator.getLadderParams()) {

                      if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&

                              (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {

                          commissionParam.setTargetType(TargetTypeEnum.NO);

                      }
                  }

              }
  
              if (PublicUtil.isNotEmpty(indicator.getCommissionParams())) {

                  BigDecimal proportion = indicator.getCommissionParams().stream()

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

                  for (KpiGroupIndicatorParamDTO commissionParam : indicator.getCommissionParams()) {

                      if (! TargetTypeEnum.NO.equals(commissionParam.getTargetType()) &&

                              (PublicUtil.isEmpty(commissionParam.getTargetType()) || PublicUtil.isEmpty(commissionParam.getTargetValue()))) {

                          commissionParam.setTargetType(TargetTypeEnum.NO);

                      }
                  }

              }

              if (PublicUtil.isNotEmpty(indicator.getConds())) {

                  for (KpiGroupIndicatorPreconditionDTO preconditionDTO : indicator.getConds()) {

                      if (! TargetTypeEnum.NO.equals(preconditionDTO.getTargetType()) &&

                              (PublicUtil.isEmpty(preconditionDTO.getTargetType()) || PublicUtil.isEmpty(preconditionDTO.getTargetValue()))) {

                          preconditionDTO.setTargetType(TargetTypeEnum.NO);

                      }
                  }

              }

          }
  

          //原来的绩效组配置不能在审批中
          if (PublicUtil.isEmpty(dto.getId())) {
              return;
          }
          KpiGroup kpiGroup = kpiGroupService.getById(dto.getId());

  //        BV.notNull(kpiGroup, "绩效配置不存在，请重试");
          if (PublicUtil.isNotEmpty(kpiGroup)) {
              BV.isFalse((SettingStatusEnum.APPROVING.equals(kpiGroup.getStatus())), "审批中的绩效组配置不能编辑");
              dto.setKgc(kpiGroup.getKgc());
          }

      }

      /**

       * 检查绩效组排名名称是否重复
       *

       * @param id

       * @param name

       */

      public void checkNameRepetition(Long id, String name, Long draftId) {

          int count = kpiGroupService.count(Wrappers.<KpiGroup>lambdaQuery()
                  .eq(KpiGroup::getName, name)
                  .ne(PublicUtil.isNotEmpty(id), KpiGroup::getId, id)
                  .eq(KpiGroup::getYn, Boolean.TRUE)

                  .eq(KpiGroup::getStatus, SettingStatusEnum.EFFECTIVE)

          );

  //        BV.isTrue(count <= 0, "绩效组名称重复，请重新输入");
          if (count > 0) {
              log.info("绩效组名称重复，name：{}，id：{}: ", name, Optional.ofNullable(id).orElse(0L).toString());
              throw new BusinessException("绩效组名称重复，请重新输入");
          }

          List<SettingDraft> drafts = commonService.getEditDraftByName(name, SettingDraftTypeEnum.KPI, draftId);

          BV.isTrue(drafts.size() <= 0, "绩效组名称在草稿中存在，请重新输入");

      }
  
      /**

       * 检查指标修改的权限
       * @param dto
       */

      private void initKpi(KpiGroupRankDTO dto) {

          LocalDate currentTime = LocalDate.now();
          dto.setBeginTime((EffectMonthEnum.CURRENT_MONTH.equals(dto.getBeginTimeType()) ? currentTime : PublicUtil.getNextMonthFirstDay()));

      }
  
      /**

       * 检查绩效组配置是否重复
       * 同月
       * 之前没有这些门店配置，不提示
       * 有这些门店配置
       *      1)门店和之前相同不提示
       *      2)门店比之前少，之前ABC门店，现A门店，提示BC门店缺失绩效组配置
       *      3)门店比之前多，配置1 ABC门店, 配置2 DE门店,新增ABCD门店，提示E门店缺失绩效配置

       * @param kpiGroupDTO

       */

      private KpiGroupSavePromptVO checkShopKpiRepeat(KpiGroupDTO kpiGroupDTO) {

          //强制提交，退出检查

  //        if (kpiGroupDTO.getForce()) {
  //            return new KpiGroupSavePromptVO(false);
  //        }

          YearMonth yearMonth = YearMonth.now();

          YearMonth beginTime = YearMonth.from(kpiGroupDTO.getBeginTime());

          StringBuilder msgBuilder = new StringBuilder();

          if (yearMonth.equals(beginTime)) {

              KpiGroupRepeatQueryDTO effectRepeatDTO = KpiGroupRepeatQueryDTO.convertDto(kpiGroupDTO, SettingStatusEnum.EFFECTIVE);

              List<KpiGroup> effectKpiGroups = kpiGroupService.queryRepeatKpiGroup(effectRepeatDTO);
              if (PublicUtil.isNotEmpty(effectKpiGroups)) {

                  msgBuilder.append("审批通过后").append(yearMonth.getMonth().getValue()).append("月份已生效绩效组配置会被移除，门店【");
                  HashSet<String> shopNames = effectKpiGroups.stream().map(KpiGroup::getShopNames).collect(HashSet::new, HashSet::addAll, HashSet::addAll);
                  msgBuilder.append(String.join(",", shopNames));
                  msgBuilder.append("】。");

              }

          }

          KpiGroupRepeatQueryDTO beEffectRepeatDTO = KpiGroupRepeatQueryDTO.convertDto(kpiGroupDTO, SettingStatusEnum.BE_EFFECTIVE);

          List<KpiGroup> beKpiGroups = kpiGroupService.queryRepeatKpiGroup(beEffectRepeatDTO);
          if (PublicUtil.isNotEmpty(beKpiGroups)) {
              if (msgBuilder.length() == 0) {
                  msgBuilder.append("审批通过后");
              }
              Map<LocalDate, List<KpiGroup>> monthKpiMap = beKpiGroups.stream().collect(Collectors.groupingBy(KpiGroup::getBeginTime));
              for (Map.Entry<LocalDate, List<KpiGroup>> monthKpi : monthKpiMap.entrySet()) {

                  msgBuilder.append(monthKpi.getKey().getMonth().getValue()).append("月份待生效绩效组配置会被移除，门店【");
                  HashSet<String> shopNames = monthKpi.getValue().stream().map(KpiGroup::getShopNames).collect(HashSet::new, HashSet::addAll, HashSet::addAll);
                  msgBuilder.append(String.join(",", shopNames));

              }

              msgBuilder.append("】。");

          }
          if (msgBuilder.length() == 0) {

              return new KpiGroupSavePromptVO(false);

          }