KPI / fw-morax

  package cn.fw.morax.server.task;
  

  import cn.fw.common.cache.locker.DistributedLocker;

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

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

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

  import cn.fw.morax.service.biz.kpi.KpiGroupBizService;
  import cn.fw.morax.service.biz.kpi.KpiGroupUserBizService;

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

  import cn.hutool.core.date.StopWatch;

  import com.alibaba.fastjson.JSON;

  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.redisson.api.RLock;

  import org.springframework.beans.factory.annotation.Value;

  import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  import org.springframework.scheduling.annotation.Scheduled;
  import org.springframework.stereotype.Component;
  import org.springframework.transaction.annotation.Transactional;
  

  import java.time.LocalDate;

  import java.util.*;

  import java.util.concurrent.TimeUnit;

  import java.util.concurrent.locks.Lock;

  import java.util.stream.Collectors;

  
  /**
   * @author : jiangchao
   * @className : KpiGroupStatusTask
   * @description : 绩效组人员定时器
   * @date : 2022-04-07 15:29
   */
  @Component
  @Slf4j
  @RequiredArgsConstructor
  @ConditionalOnProperty(prefix = "task", name = "switch", havingValue = "on")

  public class KpiGroupUserTask {

      private final KpiGroupUserBizService kpiGroupUserBizService;
      private final KpiGroupUserService kpiGroupUserService;
      private final KpiGroupBizService kpiGroupBizService;

      private final DistributedLocker distributedLocker;
  

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

      /**

       * 每天凌晨30分执行（人事角色、岗位调整在5点执行）

       * 1. 将待生效数据改为生效中
       * 2. 将之前的配置设置为失效
       * 3. 处理重复数据，合并、拆分门店的绩效组配置需要把其他的重复配置失效
       */

      @Scheduled(cron = TimeTaskConstant.KPI_GROUP_USER)

      @Transactional(rollbackFor = Exception.class)
      public void processKpiUser() {

          Lock lock = distributedLocker.lock(getKpiGroupUserDistKey());

          if (((RLock) lock).isLocked()) {
              try {

                  log.info("定时任务【绩效组人员更新】开始执行");

                  StopWatch stopWatch = new StopWatch();
                  stopWatch.start("绩效组人员更新,查询人事系统人员状态");
                  //查询员工

                  LocalDate yesterday = LocalDate.now().minusDays(1);
                  List<KpiGroupUser> kpiGroupUsersForSave = this.queryKpiStaff(yesterday);

                  stopWatch.stop();
                  if (PublicUtil.isEmpty(kpiGroupUsersForSave)) {
                      log.info(stopWatch.prettyPrint());
                      return;
                  }
                  stopWatch.start("绩效组人员保存，保存条数："+ kpiGroupUsersForSave.size());

                  //逻辑删除今天已保存人员，保存人员
                  Set<Long> kpiGroupIds = kpiGroupUsersForSave.stream().map(KpiGroupUser::getKpiGroupId).collect(Collectors.toSet());
                  kpiGroupUserService.update(Wrappers.<KpiGroupUser>lambdaUpdate()
                          .in(KpiGroupUser::getKpiGroupId, kpiGroupIds)
                          .eq(KpiGroupUser::getDataDate, yesterday)
                          .eq(KpiGroupUser::getYn, Boolean.TRUE)
                          .set(KpiGroupUser::getYn, Boolean.FALSE)
                  );

                  kpiGroupUserService.saveBatch(kpiGroupUsersForSave);
                  stopWatch.stop();
                  log.info(stopWatch.prettyPrint(TimeUnit.SECONDS));
              } catch (Exception e){
                  log.error(e.getMessage(), e);
              } finally {
                  lock.unlock();
              }

          }

      }
  
      /**
       * 查询绩效员工
       * @return
       */

      private List<KpiGroupUser> queryKpiStaff(LocalDate yesterday) {

          Map<Long, List<KpiGroup>> postKpis = kpiGroupBizService.postEffectKpis();

          if (! postKpis.isEmpty()) {
              log.info("需要生成绩效组人员的绩效组：{}", postKpis);
          }

          Long postId = null;

          List<KpiGroup> kpiGroups = null;

          List<KpiGroupUser> kpiGroupUsers = null;
          List<KpiGroupUser> kpiGroupUsersForSave = Lists.newArrayListWithCapacity(300);

          KpiIgnoreCauseEnum filterEnum = KpiIgnoreCauseEnum.PROBATION;

          for (Map.Entry<Long, List<KpiGroup>> entry : postKpis.entrySet()) {
              postId = entry.getKey();
              kpiGroups = entry.getValue();

              kpiGroupUsers = kpiGroupUserBizService.fetchBuildKpiUser(postId, kpiGroups, yesterday).stream()

  //                    .filter(user -> (PublicUtil.isEmpty(user.getIgnoreCause()) || (! filterEnum.equals(user.getIgnoreCause()))))

                      .collect(Collectors.toList());

              kpiGroupUsersForSave.addAll(kpiGroupUsers);
  
          }

          return kpiGroupUsersForSave;

      }
  

  }