KPI / fw-morax

  package cn.fw.morax.server.controller.erp;
  
  import cn.fw.common.web.annotation.ControllerMethod;

  import cn.fw.data.base.domain.common.Message;

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

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

  import cn.fw.morax.domain.bo.kpi.KpiGroupCalculableBO;

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

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

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

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

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

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

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

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

  import cn.fw.morax.server.task.GenericTask;

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

  import cn.fw.morax.service.biz.kpi.IndicatorBizService;

  import cn.fw.morax.service.biz.kpi.KpiCalculateService;
  import cn.fw.morax.service.biz.kpi.KpiPoolBizService;

  import cn.fw.morax.service.data.kpi.KpiGroupRankService;
  import cn.fw.morax.service.data.kpi.KpiGroupService;

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

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

  import cn.fw.security.auth.client.annotation.Authorization;

  import cn.fw.security.auth.client.enums.AuthType;

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

  import lombok.RequiredArgsConstructor;
  import lombok.extern.slf4j.Slf4j;

  import org.springframework.data.redis.core.BoundZSetOperations;
  import org.springframework.data.redis.core.StringRedisTemplate;

  import org.springframework.validation.annotation.Validated;

  import org.springframework.web.bind.annotation.*;

  import javax.validation.Valid;

  import java.math.BigDecimal;

  import java.time.LocalDate;

  import java.time.LocalDateTime;

  import java.time.YearMonth;

  import java.time.temporal.ChronoUnit;

  import java.util.List;

  import java.util.Set;
  import java.util.stream.Collectors;

  import static cn.fw.common.web.util.ResultBuilder.success;
  
  /**
   * @author : kurisu
   * @version : 1.0
   * @className : DebugController
   * @description : 绩效通用调试控制器
   * @date : 2022-04-11 10:45
   * @ignore
   */
  @Slf4j
  @RestController

  @Authorization(AuthType.NONE)

  @RequiredArgsConstructor

  @Validated
  @RequestMapping("/debug/kpi")
  public class KpiDebugController {

      private final KpiCalculateService kpiCalculateService;
      private final KpiPoolBizService kpiPoolBizService;

      private final CommonService commonService;

      private final GenericTask genericTask;

      private final KpiGroupUserService kpiGroupUserService;

      private final KpiGroupService kpiGroupService;
      private final KpiGroupRankService kpiGroupRankService;

      private final KpiPoolService kpiPoolService;

      private final IndicatorBizService indicatorBizService;

      @PostMapping("/indicator/report/up")
      @ControllerMethod("手动上报简单指标数据")
      public Message<Void> reportIndicator(@Valid @RequestBody UserIndicatorDTO dto) {
          indicatorBizService.reportData(dto);
          return success();
      }
  

      @GetMapping("/regular-kpi")
      @ControllerMethod("固定绩效数据")
      public Message<Void> regularKpiStar() {
          genericTask.regularKpiStar();
          return success();
      }
  

      @PutMapping("/indicator/calc/score")

      @ControllerMethod("计算绩效得分")
      public Message<Void> calcScore(@RequestParam("kpiGroupId") Long kpiGroupId,
                                     @RequestParam("date") LocalDate localDate) {

          kpiCalculateService.calculateKpi(new KpiGroupCalculableBO(kpiGroupId, localDate));
          return success();
      }
  

      @PutMapping("/indicator/calc/score-rate")

      @ControllerMethod("手动计算绩效得分率")

      public Message<Void> calcRate(@RequestParam("kpiGroupId") Long kpiGroupId,
                                    @RequestParam("date") LocalDate localDate) {

          kpiPoolBizService.calcuScoringRate(new KpiGroupCalculableBO(kpiGroupId, localDate));
          return success();
      }
  

      @PutMapping("/indicator/calc/star")

      @ControllerMethod("手动计算绩效排名和星级")
      public Message<Void> calcLevel(@RequestParam("kpiGroupId") Long kpiGroupId,
                                     @RequestParam("date") LocalDate localDate) {
          kpiPoolBizService.cacheCalculableKpiGroupRank(kpiGroupId, localDate);
          return success();
      }

      @PutMapping("/indicator/calc/rank")

      @ControllerMethod("手动计算绩效排名")

      public Message<Void> calcLevel(@RequestParam("shopId") Long shopId,
                                     @RequestParam("postId") Long postId) {
          List<KpiPool> poolList = kpiPoolService.list(Wrappers.<KpiPool>lambdaQuery()
                  .eq(KpiPool::getShopId, shopId)
                  .eq(KpiPool::getMonthly, YearMonth.from(YearMonth.now()))
                  .eq(KpiPool::getPostId, postId)
                  .eq(KpiPool::getYn, Boolean.TRUE)
          );
          kpiPoolBizService.calcRank(poolList);
          return success();
      }
  

      @GetMapping("/manage-staff")
      @ControllerMethod("查询管理员工")
      public Message<List<StaffBaseInfoDTO>> initKgc(Long userId, String monthly) {
          List<StaffBaseInfoDTO> staffBaseInfoDTOS = commonService.queryManageStaffs(userId, YearMonth.parse(monthly));
          return success(staffBaseInfoDTOS);
      }

      private final EhrRpcService ehrRpcService;

      @GetMapping("/manage-staff1")
      @ControllerMethod("查询管理员工")
      public Message<List<StaffBaseInfoDTO>> initKgc1(Long userId) {
          System.out.println(ehrRpcService.queryProbationerSalary(userId, LocalDate.now()));
          return success();

      }
  
      private final StringRedisTemplate stringRedisTemplate;
      @GetMapping("/set")
      @ControllerMethod("查询管理员工")
      public Message<List<StaffBaseInfoDTO>> initKgc2(Long userId) {
          BoundZSetOperations<String, String> zSetOps = stringRedisTemplate.boundZSetOps("eval:test");
          stringRedisTemplate.expireAt("eval:test", DateUtil.localDateTime2Date(LocalDateTime.now().plus(2L,ChronoUnit.HOURS)));
  
          zSetOps.add("1", new BigDecimal("0.99").doubleValue());
          zSetOps.add("2", new BigDecimal("0.89").doubleValue());
          zSetOps.add("3", new BigDecimal("0.79").doubleValue());
          zSetOps.add("4", new BigDecimal("0.69").doubleValue());
          zSetOps.add("5", new BigDecimal("0.59").doubleValue());
          zSetOps.add("6", new BigDecimal("0.49").doubleValue());
          zSetOps.add("7", new BigDecimal("0.39").doubleValue());
          zSetOps.add("8", new BigDecimal("0.29").doubleValue());
          zSetOps.add("9", new BigDecimal("0.19").doubleValue());
          zSetOps.add("10", new BigDecimal("0.09").doubleValue());
  
          System.out.println("-1,0 ： " + zSetOps.reverseRange(-1,0));
          System.out.println("0,0 ： " + zSetOps.reverseRange(0,0));
          System.out.println("0,1 ： " + zSetOps.reverseRange(0,1));
          System.out.println("1,2 ： " + zSetOps.reverseRange(1,2));
          System.out.println("1,2 ： " + zSetOps.reverseRange(1,2));
          System.out.println("1,3 ： " + zSetOps.reverseRange(1,3));
          System.out.println("1,4 ： " + zSetOps.reverseRange(1,4));
          System.out.println("5,6 ： " + zSetOps.reverseRange(5,6));
          System.out.println("9,9 ： " + zSetOps.reverseRange(9,9));
          System.out.println("10,10 ： " + zSetOps.reverseRange(10,10));
  
          return success();

      }
  

      @GetMapping("/probation-user")
      @ControllerMethod("处理试用期员工")
      public Message<Void> probationUser() {

          List<KpiGroupUser> userList = kpiGroupUserService.list(Wrappers.<KpiGroupUser>lambdaQuery()

                  .eq(KpiGroupUser::getDataDate, LocalDate.now().minusDays(2))

                  .eq(KpiGroupUser::getIgnored, Boolean.TRUE)
                  .eq(KpiGroupUser::getIgnoreCause, KpiIgnoreCauseEnum.PROBATION)
                  .eq(KpiGroupUser::getYn, Boolean.TRUE)
          );

          if (PublicUtil.isEmpty(userList)) {

              return success();
          }
  
          Set<Long> userIds = userList.stream().map(KpiGroupUser::getUserId).collect(Collectors.toSet());
          kpiPoolService.update(Wrappers.<KpiPool>lambdaUpdate()
                  .set(KpiPool::getYn, Boolean.FALSE)
                  .eq(KpiPool::getYn, Boolean.TRUE)
                  .eq(KpiPool::getMonthly, YearMonth.now())
                  .in(KpiPool::getUserId, userIds)
          );
          return success();
      }
  

      @GetMapping("/process-kpi-rank")
      @ControllerMethod("处理绩效排名组老数据")
      public Message<Void> processKpiRank() {
          List<KpiGroupRank> kpiGroupRanks = kpiGroupRankService.list(Wrappers.<KpiGroupRank>lambdaQuery()
                  .eq(KpiGroupRank::getYn, Boolean.TRUE)
                  .isNull(KpiGroupRank::getKpiGroupIds)
          );
          for (KpiGroupRank kpiGroupRank : kpiGroupRanks) {
              List<KpiGroup> kpiGroups = kpiGroupService.list(Wrappers.<KpiGroup>lambdaQuery()
                      .eq(KpiGroup::getStatus, SettingStatusEnum.EFFECTIVE)
                      .in(KpiGroup::getKgc, kpiGroupRank.getKgcs())
              );
              if (PublicUtil.isNotEmpty(kpiGroups)) {

                  kpiGroupRank.setPostIds(kpiGroups.stream().map(KpiGroup::getPostId).distinct().collect(Collectors.toList()));
                  kpiGroupRank.setShopIds(kpiGroups.stream().flatMap(kpiGroup -> kpiGroup.getShopIds().stream()).distinct().collect(Collectors.toList()));
                  kpiGroupRank.setKpiGroupIds(kpiGroups.stream().map(KpiGroup::getId).distinct().collect(Collectors.toList()));

                  kpiGroupRank.setStatus(SettingStatusEnum.EFFECTIVE);
                  kpiGroupRankService.updateById(kpiGroupRank);
              }
          }
          return success();
      }
  

      @GetMapping("/process-kpi-user")
      @ControllerMethod("处理绩效用户老数据")
      public Message<Void> processKpiUserInclusion() {
          //纳入绩效考核人员
          List<KpiGroupUser> groupUsers = kpiGroupUserService.list(Wrappers.<KpiGroupUser>lambdaQuery()
                  .eq(KpiGroupUser::getDataDate, LocalDate.now().minusDays(1))
                  .eq(KpiGroupUser::getIgnored, Boolean.FALSE)
                  .eq(KpiGroupUser::getYn, Boolean.TRUE)
          );
  
          for (KpiGroupUser groupUser : groupUsers) {
              KpiPool kpiPool = kpiPoolService.getOne(Wrappers.<KpiPool>lambdaQuery()
                      .eq(KpiPool::getKpiGroupId, groupUser.getKpiGroupId())
                      .eq(KpiPool::getUserId, groupUser.getUserId())
                      .eq(KpiPool::getMonthly, YearMonth.from(groupUser.getDataDate()))
                      .eq(KpiPool::getYn, Boolean.TRUE)
              , Boolean.FALSE);
              if (PublicUtil.isNotEmpty(kpiPool)) {
                  //纳入绩效计算 绩效池不参与
                  if (! kpiPool.getInclusion()) {
                      kpiPool.setInclusion(Boolean.TRUE);
                      kpiPoolService.updateById(kpiPool);
                  }
              }
          }
          return success();
      }
  

  }