KPI / fw-morax

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

  import cn.fw.common.exception.BusinessException;

  import cn.fw.morax.common.constant.Constant;

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

  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.enums.*;
  import cn.fw.morax.service.data.SettingDraftService;

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

  import com.alibaba.fastjson.JSON;

  import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;

  import com.baomidou.mybatisplus.core.toolkit.Wrappers;
  import com.google.common.collect.Lists;
  import lombok.RequiredArgsConstructor;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;

  import org.springframework.util.StringUtils;

  import java.math.RoundingMode;

  import java.time.LocalDate;

  import java.util.ArrayList;

  import java.util.Date;

  import java.util.List;

  import java.util.stream.Collectors;
  

  @RequiredArgsConstructor
  @Service
  @Slf4j
  public class KpiGroupDataService {
  
      private final KpiGroupIndicatorLaddersService kpiGroupIndicatorLaddersService;
      private final KpiGroupIndicatorService kpiGroupIndicatorService;

      private final KpiStarLaddersService kpiStarLaddersService;

      private final SettingDraftService settingDraftService;

      private final KpiGroupService kpiGroupService;

      private final KpiGroupUserService kpiGroupUserService;
      private final KpiPoolService kpiPoolService;

      private final KpiGroupIndicatorPreconditionService kpiGroupIndicatorPreconditionService;

      private final KpiGroupIndicatorParamService kpiGroupIndicatorParamService;

      private final KpiGroupIndicatorPreconditionLaddersService kpiGroupIndicatorCondLaddersService;

      private final IndicatorsService indicatorsService;

      /**
       * 保存绩效组

       *

       * @param dto
       */
      public KpiGroup saveKpiGroup(KpiGroupDTO dto) {

          if (PublicUtil.isNotEmpty(dto.getRevokedScoreRatio())) {
              dto.setRevokedScoreRatio(dto.getRevokedScoreRatio().divide(Constant.ONE_HUNDRED, 2, RoundingMode.HALF_UP));
          }

          KpiGroup kpiGroup = PublicUtil.copy(dto, KpiGroup.class);

          kpiGroup.setIndicatorNum(dto.getIndicators().size());

          if (PublicUtil.isNotEmpty(dto.getId())) {
              kpiGroup.setPreId(dto.getId());

              kpiGroup.setKgc(dto.getKgc());
          } else {
              kpiGroup.setKgc(PublicUtil.getUUID());

          }

          kpiGroup.setId(null);

          kpiGroup.setStatus(SettingStatusEnum.EFFECTIVE);

          kpiGroup.setCreateBy(dto.getUserId());

          kpiGroupService.save(kpiGroup);
          return kpiGroup;
      }
  
      /**
       * 保存绩效指标、阶梯

       *

       * @param indicators
       * @param kpiGroup
       * @return
       */
      @Transactional(rollbackFor = Exception.class)
      public void saveKpiIndicators(List<KpiGroupIndicatorDTO> indicators, KpiGroup kpiGroup) {

          List<KpiGroupIndicatorLadders> indicatorLadders = Lists.newArrayListWithCapacity(30);

          List<KpiGroupIndicatorParam> params = Lists.newArrayListWithCapacity(30);
          List<KpiGroupIndicatorPreconditionLadders> preconditionLadders = Lists.newArrayListWithCapacity(30);
  

          Long kpiGroupId = kpiGroup.getId();

          Long indicatorId = null;
          KpiGroupIndicator indicator = null;
          KpiGroupIndicatorLadders indicatorLadder = null;
          for (KpiGroupIndicatorDTO indicatorDto : indicators) {
              indicator = PublicUtil.copy(indicatorDto, KpiGroupIndicator.class);

              indicator.setKpiGroupId(kpiGroupId);
  

              kpiGroupIndicatorService.save(indicator);
              indicatorId = indicator.getId();

  
              //提成参数

              if (PublicUtil.isNotEmpty(indicatorDto.getCommissionParams())) {
                  for (KpiGroupIndicatorParamDTO commissionParam : indicatorDto.getCommissionParams()) {
                      KpiGroupIndicatorParam param = PublicUtil.copy(commissionParam, KpiGroupIndicatorParam.class);
                      param.setKpiGroupId(kpiGroupId);
                      param.setKpiGroupIndicatorId(indicatorId);
                      param.setParamType(ParamTypeEnum.COMMISSION);

                      param.setProportion(param.getProportion().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));

                      if (PublicUtil.isNotEmpty(param.getTargetType()) && TargetTypeEnum.RATIO.equals(param.getTargetType())) {

                          param.setTargetValue(param.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                      }

                      params.add(param);

                  }

              }
  
              //条件

              if (PublicUtil.isNotEmpty(indicatorDto.getConds())) {
                  for (KpiGroupIndicatorPreconditionDTO condDto : indicatorDto.getConds()) {

                      Indicators indicators1 = indicatorsService.queryByCode(condDto.getIndicatorCode(), Boolean.FALSE);

                      KpiGroupIndicatorPrecondition cond = PublicUtil.copy(condDto, KpiGroupIndicatorPrecondition.class);
                      cond.setKpiGroupId(kpiGroupId);
                      cond.setKpiGroupIndicatorId(indicatorId);

                      if (PublicUtil.isNotEmpty(cond.getTargetType()) && TargetTypeEnum.RATIO.equals(cond.getTargetType())) {

                          cond.setTargetValue(cond.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                      }

                      kpiGroupIndicatorPreconditionService.save(cond);

  
                      Long kpiGroupIndicatorCondId = cond.getId();
                      for (KpiGroupIndicatorPreconditionLaddersDTO condLaddersDto : condDto.getCondLadders()) {
                          KpiGroupIndicatorPreconditionLadders condLadder = PublicUtil.copy(condLaddersDto, KpiGroupIndicatorPreconditionLadders.class);
                          condLadder.setPreconditionId(kpiGroupIndicatorCondId);

                          condLadder.dividePercent(cond.getTargetType(), indicators1.getDataType());

                          if (PublicUtil.isNotEmpty(cond.getTargetType()) && TargetTypeEnum.RATIO.equals(cond.getTargetType())) {

                              cond.setTargetValue(cond.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                          }

                          preconditionLadders.add(condLadder);

                      }

                  }
              }
  

              //普通得分没有台阶条件

              if (ScoreWayEnum.NORMAL.equals(indicator.getScoreWay())) {
                  continue;
              }

              if (PublicUtil.isEmpty(indicatorDto.getLadderParams()) || PublicUtil.isEmpty(indicatorDto.getIndicatorLadders())) {
                  throw new BusinessException("台阶参数、台阶不能为空");
              }

  
              //台阶参数
              for (KpiGroupIndicatorParamDTO commissionParam : indicatorDto.getLadderParams()) {
                  KpiGroupIndicatorParam param = PublicUtil.copy(commissionParam, KpiGroupIndicatorParam.class);
                  param.setKpiGroupId(kpiGroupId);
                  param.setKpiGroupIndicatorId(indicatorId);
                  param.setParamType(ParamTypeEnum.LADDER);

                  param.setProportion(param.getProportion().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));

                  if (PublicUtil.isNotEmpty(param.getTargetType()) && TargetTypeEnum.RATIO.equals(param.getTargetType())) {

                      param.setTargetValue(param.getTargetValue().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                  }

                  params.add(param);

              }
  
              //台阶

              for (KpiGroupIndicatorLaddersDTO laddersDto : indicatorDto.getIndicatorLadders()) {

                  indicatorLadder = PublicUtil.copy(laddersDto, KpiGroupIndicatorLadders.class);

                  if (PublicUtil.isNotEmpty(indicator.getLaddersType()) && DataTypeEnum.RATIO.equals(indicator.getLaddersType())) {
                      indicatorLadder.setUpper(indicatorLadder.getUpper().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                      indicatorLadder.setLower(indicatorLadder.getLower().divide(Constant.ONE_HUNDRED, 4, RoundingMode.HALF_UP));
                  }

                  indicatorLadder.setKpiGroupIndicatorId(indicatorId);
                  indicatorLadders.add(indicatorLadder);
              }
          }

          if (PublicUtil.isNotEmpty(indicatorLadders)) {
              kpiGroupIndicatorLaddersService.saveBatch(indicatorLadders);
          }
          if (PublicUtil.isNotEmpty(params)) {
              kpiGroupIndicatorParamService.saveBatch(params);
          }
          if (PublicUtil.isNotEmpty(preconditionLadders)) {
              kpiGroupIndicatorCondLaddersService.saveBatch(preconditionLadders);
          }

      }
  

      /**
       * 保存绩效星级评定阶梯

       *

       * @param starLaddersDtos
       * @param kpiGroup
       * @return
       */
      @Transactional(rollbackFor = Exception.class)
      public KpiGroup saveKpiStarLadders(List<KpiStarLaddersDTO> starLaddersDtos, KpiGroup kpiGroup) {
          List<KpiStarLadders> starLadders = Lists.newArrayListWithCapacity(starLaddersDtos.size());
          Long kpiGroupId = kpiGroup.getId();
          KpiStarLadders starLadder = null;
          for (KpiStarLaddersDTO starLaddersDto : starLaddersDtos) {
              starLadder = PublicUtil.copy(starLaddersDto, KpiStarLadders.class);

              starLadder.setUpper(starLadder.getUpper().divide(Constant.ONE_HUNDRED, 2, RoundingMode.HALF_UP));
              starLadder.setLower(starLadder.getLower().divide(Constant.ONE_HUNDRED, 2, RoundingMode.HALF_UP));

              starLadder.setKpiGroupId(kpiGroupId);
              starLadders.add(starLadder);
          }
          kpiStarLaddersService.saveBatch(starLadders);
          return kpiGroup;
      }
  
      /**

       * 删除绩效组配置（根本没有被使用的绩效组配置会被逻辑删除，如为次月添加3次配置，之前两次根本没有被用，直接删除）

       *

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

      public void delInEffective(List<KpiGroup> kpiGroups) {

          if (PublicUtil.isEmpty(kpiGroups)) {
              return;
          }

          List<Long> kpiIds = kpiGroups.stream().map(KpiGroup::getId).collect(Collectors.toList());

  //        kpiGroupService.removeByIds(kpiIds);
          kpiGroupService.update(Wrappers.<KpiGroup>lambdaUpdate()
                  .set(KpiGroup::getYn, Boolean.FALSE)

                  .set(KpiGroup::getUpdateTime, new Date())

                  .in(KpiGroup::getId, kpiIds)
          );

      }
  
      /**

       * 修改多个绩效组状态

       *

       * @param kpiGroups
       * @param status
       */
      @Transactional(rollbackFor = Exception.class)
      public void modifyStatusByKpis(List<KpiGroup> kpiGroups, SettingStatusEnum status) {
          if (PublicUtil.isEmpty(kpiGroups)) {
              return;
          }

          List<Long> kpiIds = kpiGroups.stream().map(KpiGroup::getId).collect(Collectors.toList());

          this.modifyStatusByIds(kpiIds, status);

      }
  
      /**

       * 将绩效组对应的草稿设置为未发布
       *
       * @param kpiGroups
       */
      @Transactional(rollbackFor = Exception.class)
      public void modifyDraftNoRelease(List<KpiGroup> kpiGroups) {
          if (PublicUtil.isEmpty(kpiGroups)) {
              return;
          }
          List<Long> kpiIds = kpiGroups.stream().map(KpiGroup::getId).collect(Collectors.toList());
  
          settingDraftService.update(Wrappers.<SettingDraft>lambdaUpdate()
                  .set(SettingDraft::getUpdateTime, new Date())
                  .set(SettingDraft::getStatus, SettingDraftStatusEnum.NO_RELEASE)
                  .in(SettingDraft::getUnionId, kpiIds)
                  .eq(SettingDraft::getType, SettingDraftTypeEnum.KPI)
                  .eq(SettingDraft::getYn, Boolean.TRUE)
          );
      }
  
      /**

       * 修改多个绩效组状态

       *

       * @param kpiIds
       * @param status
       */
      @Transactional(rollbackFor = Exception.class)
      public void modifyStatusByIds(List<Long> kpiIds, SettingStatusEnum status) {
          if (PublicUtil.isEmpty(kpiIds)) {
              return;
          }
          log.info("修改绩效组配置状态：{}，{}", JSON.toJSONString(kpiIds), status.getName());

          LocalDate localDate = LocalDate.now();
          LambdaUpdateWrapper<KpiGroup> updateWrapper = Wrappers.<KpiGroup>lambdaUpdate()
                  .set(KpiGroup::getStatus, status)

                  .in(KpiGroup::getId, kpiIds);

          switch (status) {

              case EFFECTIVE: {

                  updateWrapper.set(KpiGroup::getBeginTime, localDate);
                  break;
              }

              case INEFFECTIVE: {

                  updateWrapper.set(KpiGroup::getOverTime, PublicUtil.getPreviousDay(localDate));
                  break;
              }
          }

          kpiGroupService.update(updateWrapper);

      }
  
      /**
       * 修改绩效组状态

       *

       * @param kpiGroup

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

      public void modifyStatusById(KpiGroup kpiGroup, SettingStatusEnum status) {
          log.info("修改绩效组配置状态：{}，{}", kpiGroup.getId(), status.getName());

          LocalDate localDate = LocalDate.now();
          LambdaUpdateWrapper<KpiGroup> updateWrapper = Wrappers.<KpiGroup>lambdaUpdate()

                  .set(KpiGroup::getStatus, status)

                  .eq(KpiGroup::getId, kpiGroup.getId());

          updateWrapper.set(!StringUtils.isEmpty(kpiGroup.getKgc()),KpiGroup::getKgc, kpiGroup.getKgc());

          switch (status) {
  //            case BE_EFFECTIVE : {
  //                KpiGroup kpiGroup = kpiGroupService.getById(kpiId);
  //                updateWrapper.set(KpiGroup::getBeginTime, kpiGroup.getBeginTime());
  //                break;
  //            }

              case EFFECTIVE: {

                  updateWrapper.set(KpiGroup::getBeginTime, localDate);
                  break;
              }

              case INEFFECTIVE: {

                  //之前生效过得配置需要 设置结束时间
                  if (SettingStatusEnum.EFFECTIVE.equals(kpiGroup.getStatus())) {
                      updateWrapper.set(KpiGroup::getOverTime, PublicUtil.getPreviousDay(localDate));
                  }

                  break;
              }
          }

          kpiGroupService.update(updateWrapper);

      }
  

      /**
       * 初始化kgc
       */
      @Transactional(rollbackFor = Exception.class)
      public void initKgc() {

          List<SettingStatusEnum> status = new ArrayList<SettingStatusEnum>() {{

              add(SettingStatusEnum.EFFECTIVE);
          }};
          List<KpiGroup> kpiGroups = kpiGroupService.list(Wrappers.<KpiGroup>lambdaQuery()

                  .in(KpiGroup::getStatus, status)

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

          for (KpiGroup kpiGroup : kpiGroups) {
              final Long kpiGroupId = kpiGroup.getId();
              final String kgc = PublicUtil.getUUID();
  
              kpiGroupService.update(Wrappers.<KpiGroup>lambdaUpdate()
                      .set(KpiGroup::getKgc, kgc)
                      .set(KpiGroup::getUpdateTime, new Date())
                      .eq(KpiGroup::getId, kpiGroupId)
              );
              kpiGroupUserService.update(Wrappers.<KpiGroupUser>lambdaUpdate()
                      .set(KpiGroupUser::getKgc, kgc)
                      .set(KpiGroupUser::getUpdateTime, new Date())

                      .eq(KpiGroupUser::getKpiGroupId, kpiGroupId)

              );
              kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()

  //                    .set(KpiPool::getKgc, kgc)

                      .set(KpiPool::getUpdateTime, new Date())

                      .eq(KpiPool::getKpiGroupId, kpiGroupId)

              );
  
          }
      }

  
  }