KPI / fw-morax

  package cn.fw.morax.server.task;
  
  import cn.fw.common.cache.locker.DistributedLocker;
  import cn.fw.ehr.sdk.api.enums.StaffShopTypeEnum;

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

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

  import cn.fw.morax.domain.db.salary.SalaryPool;

  import cn.fw.morax.rpc.ehr.EhrRpcService;
  import cn.fw.morax.rpc.ehr.dto.StaffBaseInfoDTO;
  import cn.fw.morax.rpc.ehr.dto.StaffShopInfoDTO;

  import cn.fw.morax.service.data.salary.SalaryPoolService;

  import com.google.common.base.Functions;
  import com.google.common.collect.Lists;

  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.YearMonth;

  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;

  import java.util.concurrent.locks.Lock;
  import java.util.stream.Collectors;
  
  /**
   * @author : jiangchao
   * @className : SalaryGroupTask
   * @description : 薪酬池写入社保公积金门店
   * @date : 2022-04-07 15:29
   */
  @Component
  @Slf4j
  @RequiredArgsConstructor
  @ConditionalOnProperty(prefix = "task", name = "switch", havingValue = "on")
  public class SalaryPoolFundShopTask {
  

      private final DistributedLocker distributedLocker;
      private final SalaryPoolService salaryPoolService;
      private final EhrRpcService ehrRpcService;
  

      @Value("${spring.cache.custom.global-prefix}:salary:pool:fund")
      @Getter
      private String salaryPoolFundKey;

  
      /**

       * 每月第一天凌晨执行，薪酬池写入社保公积金门店

       * 1. 处理员工有多条绩效池的数据
       * 2. 处理员工只有一条绩效池的数据
       */

      @Scheduled(cron = TimeTaskConstant.SALARY_POOL_FUND_SHOP)

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

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

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

                  log.info("定时任务【酬池写入社保公积金门店】开始执行");

                  //查找待生效数据
                  YearMonth yearMonth = YearMonth.now();
                  List<SalaryPool> updatePools = Lists.newArrayListWithCapacity(1000);
                  this.dealStaffMultiPools(updatePools, yearMonth);
                  this.dealStaffPools(updatePools, yearMonth);
                  salaryPoolService.updateBatchById(updatePools);

                  log.info("薪酬池写入社保公积金门店定时任务结束");

              } catch (Exception e){
                  log.error(e.getMessage(), e);
              } finally {
                  lock.unlock();
              }
          }
      }
  
      /**
       * 处理一个员工多条绩效池的数据
       *
       * @param updatePools
       * @param yearMonth
       */
      @Transactional(rollbackFor = Exception.class)
      public void dealStaffMultiPools(List<SalaryPool> updatePools, YearMonth yearMonth) {
          List<SalaryPool> staffMultiPools = salaryPoolService.queryStaffMultiPools(yearMonth);
          if (PublicUtil.isEmpty(staffMultiPools)) {
              return;
          }
          Set<Long> staffMultiIds = staffMultiPools.stream().map(SalaryPool::getUserId).collect(Collectors.toSet());
          List<Long> staffIds = new ArrayList<>(staffMultiIds);
          Map<Long, List<SalaryPool>> staffMultiPoolMap = staffMultiPools.stream().collect(Collectors.groupingBy(SalaryPool::getUserId));
          List<StaffBaseInfoDTO> multiStaffBaseInfoDTOS = ehrRpcService.queryStaffBaseInfo(staffIds);
          Integer fundShopType = StaffShopTypeEnum.FUND_SHOP.getValue();
  
          for (StaffBaseInfoDTO staff : multiStaffBaseInfoDTOS) {
              List<SalaryPool> pools = staffMultiPoolMap.get(staff.getId());
              if (PublicUtil.isEmpty(pools)) {
                  continue;
              }
              List<StaffShopInfoDTO> staffShops = staff.getStaffShopList();
              StaffShopInfoDTO fundShop = staffShops.stream()
                      .filter(shop -> fundShopType.equals(shop.getType()))
                      .findFirst()
                      .orElse(null);
              if (PublicUtil.isEmpty(fundShop)) {
                  continue;
              }
              for (SalaryPool pool : pools) {
                  pool.setFundShopId(fundShop.getShopId());
                  pool.setFundShopName(fundShop.getShopName());
                  updatePools.add(pool);
              }
          }
      }
  
      /**
       * 处理一个员工一条绩效池的数据
       *
       * @param updatePools
       * @param yearMonth
       */
      @Transactional(rollbackFor = Exception.class)
      public void dealStaffPools(List<SalaryPool> updatePools, YearMonth yearMonth) {

          List<SalaryPool> staffPools = salaryPoolService.queryStaffPools(yearMonth);

          if (PublicUtil.isEmpty(staffPools)) {
              return;
          }
          List<Long> staffIds = staffPools.stream().map(SalaryPool::getUserId).collect(Collectors.toList());
          Map<Long, SalaryPool> staffPoolMap = staffPools.stream()
                  .collect(Collectors.toMap(SalaryPool::getUserId, Functions.identity(), (v1, v2) -> {
                      log.error("出现员工多条绩效池 " + v1.getUserId());
                      return v2;
                  }));
          List<StaffBaseInfoDTO> multiStaffBaseInfoDTOS = ehrRpcService.queryStaffBaseInfo(staffIds);
          Integer fundShopType = StaffShopTypeEnum.FUND_SHOP.getValue();
  
          for (StaffBaseInfoDTO staff : multiStaffBaseInfoDTOS) {
              SalaryPool pool = staffPoolMap.get(staff.getId());
              if (PublicUtil.isEmpty(pool)) {
                  continue;
              }
              List<StaffShopInfoDTO> staffShops = staff.getStaffShopList();
              StaffShopInfoDTO fundShop = staffShops.stream()
                      .filter(shop -> fundShopType.equals(shop.getType()))
                      .findFirst()
                      .orElse(null);
              if (PublicUtil.isEmpty(fundShop)) {
                  continue;
              }
              pool.setFundShopId(fundShop.getShopId());
              pool.setFundShopName(fundShop.getShopName());
              updatePools.add(pool);
          }
      }
  
      /**
       * 截取list
       *
       * @param list
       * @param skip
       * @param pageSize
       * @param <T>
       * @return
       */
      public static <T> List<T> getSubListPage(List<T> list, int skip, int pageSize) {
          if (list == null || list.isEmpty()) {
              return null;
          }
          int startIndex = skip;
          int endIndex = skip + pageSize;
          if (startIndex > endIndex || startIndex > list.size()) {
              return null;
          }
          if (endIndex > list.size()) {
              endIndex = list.size();
          }
          return list.subList(startIndex, endIndex);
      }
  

  }