KPI / fw-morax

  package cn.fw.morax.service.biz.eval;
  
  import cn.fw.backlog.sdk.api.result.FailBacklogItem;
  import cn.fw.common.cache.locker.DistributedLocker;

  import cn.fw.common.exception.BusinessException;

  import cn.fw.common.web.auth.LoginAuthBean;

  import cn.fw.morax.common.config.TodoVal;

  import cn.fw.morax.common.pojo.event.ApprovalResultEvent;

  import cn.fw.morax.common.utils.DateUtil;
  import cn.fw.morax.common.utils.PublicUtil;
  import cn.fw.morax.common.utils.ThreadPoolUtil;
  import cn.fw.morax.domain.bo.eval.EvalGroupRewardDistributionBO;

  import cn.fw.morax.domain.db.ApprovalRecord;

  import cn.fw.morax.domain.db.eval.*;

  import cn.fw.morax.domain.dto.eval.EvalRewardDistDTO;
  import cn.fw.morax.domain.dto.eval.EvalRewardDistDetailDTO;

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

  import cn.fw.morax.domain.vo.eval.EvalRewardDistDetailVO;

  import cn.fw.morax.domain.vo.eval.EvalRewardDistVO;
  import cn.fw.morax.domain.vo.eval.EvalShopPoolVO;

  import cn.fw.morax.rpc.backlog.TodoRpcService;

  import cn.fw.morax.rpc.backlog.dto.BackLogItemDTO;

  import cn.fw.morax.rpc.backlog.dto.BacklogBatchPlanItemReqDTO;
  import cn.fw.morax.rpc.backlog.dto.BacklogBatchPlanReqDTO;
  import cn.fw.morax.rpc.erp.ErpRpcService;
  import cn.fw.morax.rpc.erp.dto.RpcUserRoleInfoDTO;

  import cn.fw.morax.rpc.erp.dto.RpcUserRoleShopDTO;

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

  import cn.fw.morax.service.data.ApprovalRecordService;

  import cn.fw.morax.service.data.eval.*;
  import com.alibaba.fastjson.JSON;
  import com.alibaba.fastjson.JSONObject;
  import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
  import com.baomidou.mybatisplus.core.toolkit.Wrappers;

  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.data.redis.core.BoundSetOperations;
  import org.springframework.data.redis.core.StringRedisTemplate;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  

  import java.math.BigDecimal;

  import java.text.DecimalFormat;

  import java.time.LocalDate;

  import java.time.LocalDateTime;
  import java.util.*;
  import java.util.concurrent.RejectedExecutionException;
  import java.util.concurrent.ThreadPoolExecutor;
  import java.util.concurrent.locks.Lock;

  import java.util.stream.Collectors;

  
  import static cn.fw.common.businessvalidator.Validator.BV;
  
  /**
   * @author jiangchao
   * @des: 考评计算
   * @date 2023/1/12 17:39
   */
  @Slf4j
  @Service
  @RequiredArgsConstructor
  public class EvalRewardService {
  
      private final TodoVal todoVal;

      private final EvalService evalService;

      private final ErpRpcService erpRpcService;
      private final TodoRpcService todoRpcService;

      private final EvalGroupService evalGroupService;

      private final DistributedLocker distributedLocker;

      private final ApprovalBizService approvalBizService;
      private final StringRedisTemplate stringRedisTemplate;
      private final EvalShopPoolService evalShopPoolService;

      private final ApprovalRecordService approvalRecordService;

      private final EvalRewardDistService evalRewardDistService;
      private final EvalRewardDistDetailService evalRewardDistDetailService;

  
      @Value("${spring.cache.custom.global-prefix}:dist:eval-reward")
      @Getter
      private String distributionKey;
      private final static String REWARD_LOCK_KEY = "eval:group:reward";
  
      /**
       * 缓存分配奖惩的考评池
       *
       */

      public void cacheDistEvalShopPoolIds(LocalDate localDate) {

          Lock lock = distributedLocker.lock(REWARD_LOCK_KEY);
          if (! ((RLock) lock).isLocked()) {
              return;
          }
          try {
              log.info("定时任务【考评奖惩待办】开始执行");
  

              Set<Long> evalGroupIds = evalGroupService.queryDistributionShopReward(localDate);

              if (PublicUtil.isEmpty(evalGroupIds)) {

                  return;
              }

              String[] array = evalGroupIds.stream()
                      .map(evalGroupId -> new EvalGroupRewardDistributionBO(evalGroupId))

                      .map(JSONObject::toJSONString)
                      .toArray(String[]::new);
              stringRedisTemplate.opsForSet().add(getDistributionKey(), array);
  
          } catch (Exception e){
              log.error(e.getMessage(), e);
          } finally {
              lock.unlock();
          }
      }
  
  

      /**
       * 分配奖惩
       */

      public void distributionEvalReward() {
          BoundSetOperations<String, String> setOps = stringRedisTemplate.boundSetOps(getDistributionKey());
          ThreadPoolExecutor threadPool = ThreadPoolUtil.getInstance().getThreadPool();
          List<String> overflowsList = new ArrayList<>();
          String str;
          while ((str = setOps.pop()) != null) {
              final EvalGroupRewardDistributionBO bo = JSONObject.parseObject(str, EvalGroupRewardDistributionBO.class);
              if (Objects.isNull(bo)) {
                  continue;
              }
              try {
                  String finalStr = str;
                  threadPool.execute(() -> {
                      try {
                          distributionEvalGroupReward(bo);
                      } catch (Exception ex) {

                          log.error("计算考评数据失败：{}", bo, ex);

                          setOps.add(finalStr);
                      }
                  });
              } catch (RejectedExecutionException re) {
                  overflowsList.add(str);
              }
          }
          if (!CollectionUtils.isEmpty(overflowsList)) {
              for (String s : overflowsList) {
                  setOps.add(s);
              }
          }
      }
  
  
      private void distributionEvalGroupReward(EvalGroupRewardDistributionBO bo) {

          final Long evalGroupId = bo.getEvalGroupId();
          log.info("分配奖惩的考评组：{}", evalGroupId);

          EvalGroup evalGroup = evalGroupService.getById(evalGroupId);

          BV.notNull(evalGroup, "考评组不存在，终止计算！");
  
          List<EvalShopPool> pools = evalShopPoolService.list(Wrappers.<EvalShopPool>lambdaQuery()
                  .eq(EvalShopPool::getEvalGroupId, evalGroupId)
                  .eq(EvalShopPool::getYn, Boolean.TRUE)
          );
          BV.isNotEmpty(pools, "考评池不存在，终止计算！");

          sendDistRewardTodo(pools, evalGroup );

      }
  
      /**
       * 发送绩效组变动通知
       *
       * @param
       */
      @Transactional(rollbackFor = Exception.class)

      public void sendDistRewardTodo(List<EvalShopPool> pools, EvalGroup evalGroup) {

          Eval eval = evalService.getById(evalGroup.getEvalId());
          BV.notNull(eval, "考评配置不存在，请重试");
  
          DecimalFormat decimalFormat = new DecimalFormat("##########.##");
          final String roleCode = evalGroup.getRoleCodes().stream().findFirst().get();
          final String evalGroupName = evalGroup.getName();
          final String evalName = eval.getName();
          final EvalTypeEnum evalType = eval.getType();
          List<Long> shopIds = evalGroup.getShopIds();
  
          Date expireTime = DateUtil.localDateTime2Date(LocalDateTime.now().plusDays(2L));
  
          List<BacklogBatchPlanItemReqDTO> itemList = new ArrayList<>();
          List<RpcUserRoleInfoDTO> users = this.getUserEnableRoleInfos(roleCode, shopIds);
          for (RpcUserRoleInfoDTO user : users) {
              List<Long> manageShopIds = user.getRangeList().stream()
                      .filter(range -> shopIds.contains(range.getShopId()))
                      .map(RpcUserRoleShopDTO::getShopId).distinct().collect(Collectors.toList());
              if (PublicUtil.isEmpty(manageShopIds)) {
                  continue;
              }
  
              List<Long> poolIds = new ArrayList<>();
              BigDecimal reward = BigDecimal.ZERO;
              for (EvalShopPool pool : pools) {
                  if (manageShopIds.contains(pool.getShopId())) {
                      poolIds.add(pool.getId());
                      reward = reward.add(pool.getReward());
                  }
              }
  

              EvalRewardDist rewardDist = transferPo(evalGroup);

              rewardDist.setUserId(user.getUserId());

              rewardDist.setEvalShopPoolIds(poolIds);
              rewardDist.setShopIds(manageShopIds);

              rewardDist.setEvalName(evalName);
              rewardDist.setEvalType(evalType);

              rewardDist.setReward(reward);

              evalRewardDistService.save(rewardDist);
  
              BacklogBatchPlanItemReqDTO planItemReq = new BacklogBatchPlanItemReqDTO();
              planItemReq.setDataId(rewardDist.getId().toString());
              planItemReq.setUserId(user.getUserId());
              planItemReq.setPlanTime(new Date());
              planItemReq.setExpireTime(expireTime);
  
              Map<String, String> dynamicMap = new HashMap<>(8);
              dynamicMap.put("evalGroupName", evalGroupName);
              dynamicMap.put("evalName", evalName);

              dynamicMap.put("evalType", evalType.getName());

              dynamicMap.put("amount", decimalFormat.format(rewardDist.getReward()));
              planItemReq.setDynamicMap(dynamicMap);
  
              Map<String, Object> extraData = new HashMap<>();
              planItemReq.setExtraData(extraData);
              itemList.add(planItemReq);
          }
  
  
          //推送待办
          BacklogBatchPlanReqDTO batchPlanReq = new BacklogBatchPlanReqDTO(todoVal.getDistEvalReward(), itemList);
          List<FailBacklogItem> failItems = Optional.ofNullable(todoRpcService.batchPush(batchPlanReq)).orElse(new ArrayList<>());
          if (PublicUtil.isNotEmpty(failItems)) {
              log.error("发送分配考评奖励待办失败，失败人员信息：{}", JSON.toJSONString(failItems));
          }
  

  //        if (PublicUtil.isEmpty(failItems) || itemList.size() > failItems.size()) {
  //            pool.setStatus(EvalShopPoolStatusEnum.WAIT_DIST_REWARD);
  //            evalShopPoolService.updateById(pool);
  //        }

      }
  

      public EvalRewardDist transferPo(EvalGroup evalGroup) {
          EvalRewardDist rewardDist = new EvalRewardDist();
          rewardDist.setEvalId(evalGroup.getEvalId());
          rewardDist.setEvalGroupId(evalGroup.getId());
          rewardDist.setEvalGroupName(evalGroup.getName());
          rewardDist.setStatus(EvalRewardDistStatusEnum.NO_DIST);
          rewardDist.setGroupId(evalGroup.getGroupId());
          rewardDist.setYn(Boolean.TRUE);
          return rewardDist;
      }
  

      /**
       * 对查询的人员去重
       *
       * @param roleCode
       * @param shopIds
       * @return
       */
      public List<RpcUserRoleInfoDTO> getUserEnableRoleInfos(String roleCode, List<Long> shopIds) {
          List<RpcUserRoleInfoDTO> userRoleInfos = erpRpcService.getUserEnableRoleInfos(roleCode, shopIds);
          if (PublicUtil.isEmpty(userRoleInfos)) {
              return new ArrayList<>();
          }
          Set<Long> staffIds = new HashSet<>();
          List<RpcUserRoleInfoDTO> repeatUserRoleInfos = Lists.newArrayListWithCapacity(userRoleInfos.size());
          for (RpcUserRoleInfoDTO rpcUserRoleInfoDTO : userRoleInfos) {
              if (staffIds.add(rpcUserRoleInfoDTO.getUserId())) {
                  repeatUserRoleInfos.add(rpcUserRoleInfoDTO);
              }
          }
          return repeatUserRoleInfos;
      }

      /**
       * 奖惩分配详情
       * @param id
       * @return
       */
      public EvalRewardDistVO rewardDistDetail(Long id) {
          EvalRewardDist rewardDist = evalRewardDistService.getById(id);
          BV.notNull(rewardDist, "奖惩分配不存在，请重试");
          EvalRewardDistVO rewardDistVO = PublicUtil.copy(rewardDist, EvalRewardDistVO.class);
  
          List<EvalShopPool> pools = evalShopPoolService.list(Wrappers.<EvalShopPool>lambdaQuery()
                  .in(EvalShopPool::getId, rewardDistVO.getEvalShopPoolIds())
                  .eq(EvalShopPool::getYn, Boolean.TRUE)
          );
          BV.isNotEmpty(pools, "奖惩分配不存在，请重试");
          List<EvalShopPoolVO> shopPools = PublicUtil.copyList(pools, EvalShopPoolVO.class);
          rewardDistVO.setShopPools(shopPools);

          if (EvalRewardDistStatusEnum.APPROVAL.equals(rewardDist.getStatus()) ||
                  EvalRewardDistStatusEnum.APPROVAL_REJECT.equals(rewardDist.getStatus())) {

              List<EvalRewardDistDetail> details = evalRewardDistDetailService.list(Wrappers.<EvalRewardDistDetail>lambdaQuery()

                      .eq(EvalRewardDistDetail::getDistId, rewardDistVO.getId())

                      .eq(EvalRewardDistDetail::getYn, Boolean.TRUE)
              );
              List<EvalRewardDistDetailVO> detailVOS = PublicUtil.copyList(details, EvalRewardDistDetailVO.class);
              rewardDistVO.setRewardDetails(detailVOS);

  
              ApprovalRecord approvalRecord = approvalRecordService.getOne(Wrappers.<ApprovalRecord>lambdaQuery()
                      .eq(ApprovalRecord::getDataId, id)
                      .eq(ApprovalRecord::getApprovalType, ApprovalTypeEnum.EVAL_REWARD_DIST)
                      .eq(ApprovalRecord::getYn, Boolean.TRUE)
                      .last("ORDER BY id DESC LIMIT 1")
              );
              rewardDistVO.setApprovalNo(Optional.ofNullable(approvalRecord).map(ApprovalRecord::getApprovalNo).orElse(""));

          }
  

          return rewardDistVO;
      }
  

      @Transactional(rollbackFor = Exception.class)
      public void rewardDist(EvalRewardDistDTO rewardDistDTO, LoginAuthBean currentUser) {

          Long rewardDistId = rewardDistDTO.getEvalShopDistId();
          EvalRewardDist rewardDist = evalRewardDistService.getById(rewardDistId);
          BV.notNull(rewardDist, "奖惩分配不存在，请重试");
          BV.isNotEmpty(rewardDistDTO.getUsers(), "奖惩分配为空，请重试");
  
          BigDecimal totalReward = rewardDistDTO.getUsers().stream()
                                  .map(EvalRewardDistDetailDTO::getReward)
                                  .reduce(BigDecimal.ZERO, BigDecimal::add);
          if (totalReward.compareTo(totalReward) != 0) {
              throw new BusinessException("分配金额不等于总金额，请重试");
          }
  

          //删除之前的分配
          evalRewardDistDetailService.update(Wrappers.<EvalRewardDistDetail>lambdaUpdate()

                  .eq(EvalRewardDistDetail::getDistId, rewardDistId)

                  .set(EvalRewardDistDetail::getYn, Boolean.FALSE)
          );
  

          List<EvalRewardDistDetail> distDetails = Lists.newArrayListWithCapacity(rewardDistDTO.getUsers().size());
          for (EvalRewardDistDetailDTO distDetailDTO : rewardDistDTO.getUsers()) {

              EvalRewardDistDetail evalRewardDistDetail = distDetailDTO.convertPo(rewardDistId);
              distDetails.add(evalRewardDistDetail);

          }
  

          approvalBizService.applyApproveDistReward(rewardDist, currentUser);
          evalRewardDistDetailService.saveBatch(distDetails);
          rewardDist.setStatus(EvalRewardDistStatusEnum.APPROVAL);
          evalRewardDistService.saveOrUpdate(rewardDist);
      }

      @Transactional(rollbackFor = Exception.class)
      public void approvalEvalRewardDist(ApprovalRecord approvalRecord, ApprovalResultEvent result) {
          log.info("收到考评门店奖惩分配审批信息：{}", JSON.toJSONString(result));
          Boolean agree = result.getAgree();
          Long rewardDistId = approvalRecord.getDataId();
          EvalRewardDist rewardDist = evalRewardDistService.getById(rewardDistId);
          BV.notNull(rewardDist, "奖惩分配不存在，请重试");
          rewardDist.setStatus(EvalRewardDistStatusEnum.APPROVAL_REJECT);
          if (agree) {
              BackLogItemDTO dto = new BackLogItemDTO(rewardDist.getUserId(), todoVal.getDistEvalReward(),
                      String.valueOf(rewardDist.getId()), new Date(), null);
              if (todoRpcService.cancel(dto)) {
  
              } else {
                  log.error("奖惩分配待办取消失败：{}", JSON.toJSONString(rewardDist));
                  throw new BusinessException("奖惩分配失败，请重试");
              }
              rewardDist.setStatus(EvalRewardDistStatusEnum.APPROVAL_AGREE);

              evalRewardDistDetailService.update(Wrappers.<EvalRewardDistDetail>lambdaUpdate()
                      .eq(EvalRewardDistDetail::getDistId, rewardDistId)
                      .eq(EvalRewardDistDetail::getYn, Boolean.TRUE)
                      .set(EvalRewardDistDetail::getStatus, EvalRewardPushStatusEnum.WAIT_PUSH)
                      .set(EvalRewardDistDetail::getUpdateTime, new Date())
              );

          }
          evalRewardDistService.saveOrUpdate(rewardDist);

      }

  }