KPI / fw-morax

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

  import cn.fw.common.exception.BusinessException;

  import cn.fw.common.page.AppPage;

  import cn.fw.common.web.annotation.DisLock;

  import cn.fw.ehr.sdk.api.enums.RoleManagerEnum;

  import cn.fw.ehr.sdk.api.result.PostRoleVo;

  import cn.fw.morax.common.utils.PublicUtil;
  import cn.fw.morax.domain.db.kpi.Indicators;

  import cn.fw.morax.domain.db.kpi.KpiGroup;

  import cn.fw.morax.domain.dto.IndicatorsDTO;

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

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

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

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

  import cn.fw.morax.rpc.ehr.EhrRpcService;
  import cn.fw.morax.rpc.ehr.dto.PostInfoDTO;

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

  import com.alibaba.fastjson.JSON;

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

  import java.util.function.Function;

  import java.util.stream.Collectors;
  

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

  
  @RequiredArgsConstructor
  @Service
  @Slf4j
  public class IndicatorBizService {
  

      private final KpiGroupIndicatorBizService kpiGroupIndicatorBizService;

      private final IndicatorsService indicatorsService;

      private final EhrRpcService ehrRpcService;

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

      /**
       * 分页查询

       *

       * @param dto
       * @return
       */

      public AppPage<IndicatorsVO> indicatorsPage(IndicatorQueryDTO dto) {

          if (PublicUtil.isNotEmpty(dto.getRoleCode())) {

              List<ApplicableRoleEnum> roleTypes = new ArrayList<ApplicableRoleEnum>(){{

                  add(ApplicableRoleEnum.ALL);
                  add(ApplicableRoleEnum.MANAGEMENT_ROLE);
              }};

              dto.setAllRoleTypes(roleTypes);

          }

          Long total = indicatorsService.indicatorsPageTotal(dto);
          return PublicUtil.<IndicatorsVO, IndicatorQueryDTO>queryPage(dto, total, new Function<IndicatorQueryDTO, List<IndicatorsVO>>() {
              @Override
              public List<IndicatorsVO> apply(IndicatorQueryDTO basePageQuery) {

                  return indicatorsService.indicatorsPage(dto);

              }

          });

      }
  
      /**

       * 指标详情

       *

       * @param id
       * @return
       */

      public IndicatorsVO indicatorDetail(Long id) {

          Indicators indicators = indicatorsService.getById(id);

          BV.notNull(indicators, "指标不存在，请重试");

          return PublicUtil.copy(indicators, IndicatorsVO.class);

      }
  
      /**

       * 保存指标

       *

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

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

      public void saveIndicator(IndicatorsDTO dto) {

          this.checkIndicatorRole(dto);

          this.checkIndicatorName(dto.getIndicatorName());

          String indicatorCode = PublicUtil.getUUID();
          this.checkIndicatorCode(indicatorCode);

          Indicators indicators = dto.convertToPo();
          indicators.setIndicatorCode(indicatorCode);

          indicatorsService.save(indicators);

      }
  

      /**
       * 指标库禁用启用

       * 

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

      @DisLock(prefix = "#this.getEnablePrefix()", key = "#indicatorId", message = "修改中，请勿重复操作")

      public void enableIndicator(Long indicatorId, Boolean enable) {
          Indicators indicators = indicatorsService.getById(indicatorId);
          BV.notNull(indicators, "指标不存在，请重试");
          BV.isFalse(enable.equals(indicators.getEnable()), "指标已经是" + ((enable) ? "启用": "禁用") + "状态，请重试");
          //禁用情况：正在使用的指标不能禁用，并提示哪些地方在用
          if (! enable) {

              List<KpiGroup> kpiGroups = kpiGroupIndicatorBizService.getKpiGroupByIndicatorId(indicatorId);

              Set<String> postNames = kpiGroups.stream().map(KpiGroup::getPostName).collect(Collectors.toSet());
              if (PublicUtil.isNotEmpty(postNames)) {
                  throw new BusinessException(String.join(",", postNames) + "岗位正在使用此绩效指标，不能禁用");
              }
          }

          indicatorsService.update(Wrappers.<Indicators>lambdaUpdate()

                  .set(Indicators::getEnable, enable)
                  .eq(Indicators::getId, indicatorId)
          );

      }
  
      /**
       * 检查指标角色配置

       *

       * @param dto
       */

      private void checkIndicatorRole(IndicatorsDTO dto) {

          Boolean portionNotSelectRole = ApplicableRoleEnum.PORTION.equals(dto.getRoleType()) &&

                  PublicUtil.isEmpty(dto.getRoleNames());

          BV.isFalse(portionNotSelectRole, "自定义角色，请选择至少一个角色");

      }
  
      /**
       * 检查指标名称

       *

       * @param indicatorName

       */

      private void checkIndicatorName(String indicatorName) {

          long taskCount = indicatorsService.count(Wrappers.<Indicators>lambdaQuery()
                  .eq(Indicators::getIndicatorName, indicatorName)

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

          );

          BV.isFalse(taskCount > 0, "指标名称已存在，请重新输入");

      }
  
      /**
       * 检查指标编码

       *

       * @param indicatorCode
       */
      private void checkIndicatorCode(String indicatorCode) {
          long taskCount = indicatorsService.count(Wrappers.<Indicators>lambdaQuery()
                  .eq(Indicators::getIndicatorCode, indicatorCode)
          );
          if (taskCount > 0) {
              log.error("指标编码生成重复：{}", indicatorCode);
              throw new BusinessException("指标编码已存在，请重试");
          }
      }

  
      /**
       * 获取岗位下的绩效组指标

       *

       * @param postId
       * @return
       */

      public List<IndicatorsVO> getPostIndicators(Long postId, String shopIds) {

          List<Long> postIds = new ArrayList<Long>(){{
              add(postId);

          }};

          List<PostInfoDTO> postInfoDTOS = ehrRpcService.getPostInfoList(postIds);

          List<String> roleCodes = postInfoDTOS.stream()
                  .map(PostInfoDTO::getRoleList)

                  .filter(Objects::nonNull)

                  .flatMap(Collection::stream)
                  .map(PostRoleVo::getRoleCode)
                  .distinct().collect(Collectors.toList());

          Boolean queryManagerRole = hasManagerRole(roleCodes);
          IndicatorPostQueryDTO dto = new IndicatorPostQueryDTO(roleCodes, queryManagerRole);

  //        IndicatorPostQueryDTO dto = new IndicatorPostQueryDTO(new ArrayList<String>(){{add("FWGW");add("XSGW");}}, Boolean.TRUE);

          return indicatorsService.getPostIndicators(dto);
      }
  
      /**
       * 是否拥有管理角色

       *

       * @return
       */
      private Boolean hasManagerRole(List<String> roleCodes) {

          if (PublicUtil.isEmpty(roleCodes)) {

              return Boolean.FALSE;

          }

          HashSet<String> roleCodeSet = new HashSet<>(roleCodes);
          return Arrays.stream(RoleManagerEnum.values())
                  .anyMatch(roleManagerEnum -> roleCodeSet.contains(roleManagerEnum.getCode()));

      }

  }