KPI / fw-morax

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

  import cn.fw.common.exception.BusinessException;
  import cn.fw.ehr.sdk.api.enums.StaffShopTypeEnum;

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

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

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

  import cn.fw.morax.domain.db.salary.SalaryExtraProject;
  import cn.fw.morax.domain.db.salary.SalaryGroupUser;
  import cn.fw.morax.domain.db.salary.SalaryPool;
  import cn.fw.morax.domain.db.salary.SalaryProject;

  import cn.fw.morax.domain.dto.salary.SalaryExtraDTO;

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

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

  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.rpc.oop.OopRpcService;
  import cn.fw.morax.rpc.oop.dto.ShopDTO;

  import cn.fw.morax.sdk.dto.salary.GeneralSalaryProjectReq;
  import cn.fw.morax.sdk.dto.salary.SalaryGroupUserQuery;
  import cn.fw.morax.sdk.dto.salary.SalaryGroupUserResult;
  import cn.fw.morax.sdk.dto.salary.SalaryRewardReq;

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

  import cn.fw.morax.service.data.salary.*;
  import com.alibaba.fastjson.JSON;

  import com.alibaba.fastjson.JSONObject;
  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.data.redis.core.BoundListOperations;

  import org.springframework.data.redis.core.ListOperations;

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

  import org.springframework.stereotype.Service;

  import org.springframework.transaction.PlatformTransactionManager;
  import org.springframework.transaction.TransactionDefinition;
  import org.springframework.transaction.TransactionStatus;

  import org.springframework.transaction.annotation.Transactional;

  import org.springframework.util.CollectionUtils;

  import java.text.SimpleDateFormat;

  import java.time.YearMonth;

  import java.util.*;

  import java.util.stream.Collectors;

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

  
  /**
   * @author : kurisu
   * @version : 1.0
   * @className : SalaryReportService
   * @description : 薪酬数据上报
   * @date : 2022-04-22 10:28
   */
  
  @RequiredArgsConstructor
  @Slf4j
  @Service
  public class SalaryReportService {

      private final SalaryExtraProjectService salaryExtraProjectService;
      private final SalaryGroupUserService salaryGroupUserService;
      private final SalaryPoolService salaryPoolService;

      private final OopRpcService oopRpcService;

      private final EhrRpcService ehrRpcService;

      private final PayrollRecordService payrollRecordService;

      private final SalaryProjectService salaryProjectService;
      private final SalaryGroupService salaryGroupService;

      private final SalaryPoolCommonService salaryPoolCommonService;

      private final StringRedisTemplate stringRedisTemplate;

      private final PlatformTransactionManager platformTransactionManager;
      private final TransactionDefinition transactionDefinition;

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

  
      /**
       * 额外薪资数据保存失败的重试
       */
      public void retrySaveReward() {
          ListOperations<String, String> listOps = stringRedisTemplate.opsForList();
          String str;
          List<String> failList = new ArrayList<>();
          while ((str = listOps.leftPop(getExtraSalaryKey())) != null) {
              try {
                  SalaryExtraDTO dto = JSONObject.parseObject(str, SalaryExtraDTO.class);
                  if (Objects.isNull(dto)) {
                      continue;
                  }

                  saveExtraProjectTX(dto);

              } catch (Exception e) {
                  failList.add(str);

                  log.error("薪酬额外薪资数据保存失败", e);

              }
          }
  
          if (!CollectionUtils.isEmpty(failList)) {

              listOps.rightPushAll(getExtraSalaryKey(), failList);

          }
      }
  

      /**
       * 奖惩项薪资上报
       *
       * @param req
       */
      public void salaryRewardReport(SalaryRewardReq req) {
          SalaryExtraDTO extraDTO = transferExtraProject(req);
          try {

              saveExtraProjectTX(extraDTO);

          } catch (Exception e) {

              cacheFailProject(extraDTO, getExtraSalaryKey());

              log.error("奖惩项薪资上报数据处理失败", e);

          }
      }
  
      /**
       * 社保项上报
       *
       * @param req
       */
      public void socialSecurityProject(GeneralSalaryProjectReq req) {

          SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.NECESSARY);

          try {

              saveExtraProjectTX(extraDTO);

          } catch (Exception e) {
              cacheFailProject(extraDTO, getExtraSalaryKey());
              log.error("社保项上报数据处理失败", e);
          }
      }
  
      /**
       * 个税上报
       *
       * @param req
       */
      public void personTaxProject(GeneralSalaryProjectReq req) {

          SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.PERSON_TAX);

          try {

              saveExtraProjectTX(extraDTO);

          } catch (Exception e) {

              cacheFailProject(extraDTO, getExtraSalaryKey());

              log.error("社保项上报数据处理失败", e);

          }
      }
  
      /**

       * 补贴项上报

       *
       * @param req
       */
      public void subsidyProject(GeneralSalaryProjectReq req) {

          SalaryExtraDTO extraDTO = transferExtraProject(req, ExtraSalaryTypeEnum.SUBSIDY);

          try {

              saveExtraProjectTX(extraDTO);

          } catch (Exception e) {

              cacheFailProject(extraDTO, getExtraSalaryKey());

              log.error("补贴项薪资上报数据处理失败", e);

          }
      }
  

      /**
       * 事务保存额外薪酬项
       *
       * @param extraDTO
       */
      public void saveExtraProjectTX(SalaryExtraDTO extraDTO) {
          TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
          try {
              saveExtraProject(extraDTO);
              platformTransactionManager.commit(transactionStatus);
          } catch (Exception e) {
              platformTransactionManager.rollback(transactionStatus);
              throw e;
          }
      }

  
      /**
       * 保存额外薪酬项
       *
       * @param extraDTO
       */

      public void saveExtraProject(SalaryExtraDTO extraDTO) {

          Optional<SalaryPool> optional = queryPoolByUser(extraDTO.getUserId(), extraDTO.getPostId(), extraDTO.getShopId(), extraDTO.getDataDate());

          Long fundShopId;
          Long shopId;
          Long groupId;
          String userName;

  
          if (optional.isPresent()) {
              SalaryPool salaryPool = optional.get();
              fundShopId = PublicUtil.isNotEmpty(salaryPool.getFundShopId()) ? salaryPool.getFundShopId() : salaryPool.getShopId();
              groupId = salaryPool.getGroupId();
              shopId = salaryPool.getShopId();
              userName = salaryPool.getUserName();
          } else {
              StaffBaseInfoDTO staff = ehrRpcService.queryStaffBaseInfo(extraDTO.getUserId());
              if (PublicUtil.isEmpty(staff)) {
                  log.error("保存额外薪酬项，人员信息未找到：{}", JSON.toJSONString(extraDTO));
                  throw new BusinessException("人员信息未找到");
              }
              if (PublicUtil.isEmpty(staff.getStaffShopList())) {
                  log.error("保存额外薪酬项，员工门店列表为空：{}", JSON.toJSONString(extraDTO));
                  throw new BusinessException("员工门店列表为空");
              }
              Optional<StaffShopInfoDTO> fundShop = staff.getStaffShopList().stream()
                      .filter(shop -> StaffShopTypeEnum.FUND_SHOP.getValue().equals(shop.getType()))
                      .findFirst();
              fundShopId = fundShop.isPresent() ? fundShop.get().getShopId() : staff.getShopId();
              groupId = staff.getGroupId();
              shopId = staff.getShopId();
              userName = staff.getName();

          }

          SalaryExtraProject extraProject = transferBaseExtra(extraDTO);
          if (Objects.isNull(extraProject)) {
              return;
          }

          extraProject.setPostId(extraDTO.getPostId());

          extraProject.setShopId(extraDTO.getShopId());

          extraProject.setGroupId(groupId);

          salaryExtraProjectService.save(extraProject);

          if (Boolean.TRUE.equals(extraDTO.getTimely())) {

              Long dealerId = Optional.ofNullable(oopRpcService.queryShop(fundShopId)).map(ShopDTO::getDealerId).orElse(null);

              PayrollRecord pr = PayrollRecord.builder()
                      .userId(extraProject.getUserId())

                      .userName(userName)
                      .shopId(shopId)

                      .fundShopId(fundShopId)

                      .dealerId(dealerId)
                      .bizId(String.valueOf(extraProject.getId()))
                      .payment(ExtraSalaryTypeEnum.AWARD.equals(extraProject.getSalaryType()) || ExtraSalaryTypeEnum.SUBSIDY.equals(extraProject.getSalaryType()))

                      .salary(Boolean.FALSE)
                      .payrollStatus(SalaryPayrollStatusEnum.WAITING)
                      .monthly(YearMonth.from(extraProject.getDataDate()))

                      .groupId(groupId)

                      .build();

              pr.setAmount(extraProject.getMoney());

              payrollRecordService.save(pr);
          }

      }
  
      /**
       * 查询薪酬池
       *
       * @param userId
       * @param postId
       * @param shopId
       * @param date
       * @return
       */

      private Optional<SalaryPool> queryPoolByUser(Long userId, Long postId, Long shopId, Date date) {

          SalaryGroupUser user = salaryGroupUserService.queryUserByPostShopAndUserId(userId, postId, shopId, date);

          if (PublicUtil.isEmpty(user)) {
              return Optional.empty();
          }

          SalaryPool salaryPool = salaryPoolCommonService.inspectionPool(user);

          if (PublicUtil.isEmpty(salaryPool)) {
              return Optional.empty();
          }
          return Optional.of(salaryPool);

      }
  

      /**
       * 缓存处理失败的数据
       *
       * @param dto
       */
      private <T> void cacheFailProject(T dto, String key) {
          BoundListOperations<String, String> listOps = stringRedisTemplate.boundListOps(key);
          String jsonString = JSONObject.toJSONString(dto);

          listOps.rightPush(jsonString);
      }
  

      /**
       * 对象转换
       *
       * @param dto SalaryExtraDTO
       * @return SalaryExtraProject
       */

      private SalaryExtraProject transferBaseExtra(SalaryExtraDTO dto) {
          if (Objects.isNull(dto)) {
              return null;
          }
          SalaryExtraProject salaryExtraProject = new SalaryExtraProject();
          salaryExtraProject.setUserId(dto.getUserId());
          salaryExtraProject.setMoney(dto.getMoney());
          salaryExtraProject.setSalaryType(dto.getSalaryType());
          salaryExtraProject.setDataId(dto.getDataId());
          salaryExtraProject.setDataName(dto.getDataName());
          salaryExtraProject.setDataDate(DateUtil.date2LocalDate(dto.getDataDate()));

          salaryExtraProject.setTimely(PublicUtil.isEmpty(dto.getTimely()) ? Boolean.FALSE : dto.getTimely());

          salaryExtraProject.setYn(Boolean.TRUE);

          return salaryExtraProject;
      }
  

  
      /**
       * 对象转换
       *
       * @param req SalaryRewardReq
       * @return SalaryExtraDTO
       */

      private SalaryExtraDTO transferExtraProject(SalaryRewardReq req) {
          SalaryExtraDTO dto = new SalaryExtraDTO();
          dto.setUserId(req.getUserId());
          dto.setMoney(req.getAmount());
          dto.setSalaryType(ExtraSalaryTypeEnum.AWARD);
          if (!Boolean.TRUE.equals(req.getAward())) {

              dto.setSalaryType(ExtraSalaryTypeEnum.PENALTY);
          }
          dto.setDataId(req.getDataId());
          dto.setDataName(req.getDataName());
          dto.setDataDate(req.getDataTime());
          dto.setPostId(req.getPostId());
          dto.setShopId(req.getShopId());
          dto.setTimely(req.getTimely());
          return dto;
      }
  

      /**
       * 对象转换
       *

       * @param req SalaryRewardReq

       * @return SalaryExtraDTO
       */

      private SalaryExtraDTO transferExtraProject(GeneralSalaryProjectReq req, ExtraSalaryTypeEnum salaryTypeEnum) {

          SalaryExtraDTO dto = new SalaryExtraDTO();
          dto.setUserId(req.getUserId());

          dto.setSalaryType(salaryTypeEnum);

          dto.setMoney(req.getAmount());

          dto.setDataId(req.getDataId());
          dto.setDataName(req.getDataName());
          dto.setDataDate(req.getDataTime());
          dto.setPostId(req.getPostId());
          dto.setShopId(req.getShopId());
          dto.setTimely(Boolean.FALSE);
          return dto;
      }

  
      /**

       * 查询薪酬组人员
       *
       * @param salaryGroupUserQuery
       * @return
       */
      public List<SalaryGroupUserResult> querySalaryGroupUser(SalaryGroupUserQuery salaryGroupUserQuery) {
          final String salaryCode = salaryGroupUserQuery.getSalaryCode();
          final Long postId = salaryGroupUserQuery.getPostId();

          final Date dataDate = new Date(salaryGroupUserQuery.getDataDate());
          log.info("查询薪酬组人员，日期：{}", new SimpleDateFormat("yyyy-MM-dd").format(dataDate));

  
          SalaryProject salaryProject = salaryProjectService.queryByCode(salaryCode, Boolean.FALSE);
          BV.notNull(salaryProject, () -> "指标码不存在或已失效");
  
          ArrayList<SalaryGroupUserResult> list = new ArrayList<>();
  
          List<Long> salaryGroupIds = salaryGroupService.querySalaryGroupIdsByCode(salaryCode,
                  postId, salaryGroupUserQuery.getGroupId(), dataDate);
  
          if (CollectionUtils.isEmpty(salaryGroupIds)) {
              log.error("没有对应的薪酬组数据【{}】", salaryGroupIds);
              return list;
          }
  
          List<SalaryGroupUser> groupUsers = salaryGroupUserService.list(Wrappers.<SalaryGroupUser>lambdaQuery()
                  .in(SalaryGroupUser::getSalaryGroupId, new HashSet<>(salaryGroupIds))
                  .eq(SalaryGroupUser::getDataDate, DateUtil.date2LocalDate(dataDate))
          );
  
          if (CollectionUtils.isEmpty(groupUsers)) {
              log.error("没有对应日期的薪酬组人员数据【薪酬组id：{}，日期：{}】", JSON.toJSONString(salaryGroupIds), DateUtil.getStringDateShort(dataDate));
              return list;
          }
  
          Map<Long, List<SalaryGroupUser>> salaryGroupUserMap = groupUsers.stream().collect(Collectors.groupingBy(SalaryGroupUser::getSalaryGroupId));
          for (List<SalaryGroupUser> valueArr : salaryGroupUserMap.values()) {
              SalaryGroupUserResult result = new SalaryGroupUserResult();
              result.setRoleCodeList(salaryProject.getRoleCodes());
              result.setUserIdList(transferUser(valueArr));
              list.add(result);
          }
  
          return list;
      }
  
      /**
       * 转换器  SalaryGroupUser -> SimpleUserData
       *
       * @param groupUsers
       * @return
       */
      private List<SalaryGroupUserResult.SimpleUserData> transferUser(List<SalaryGroupUser> groupUsers) {
          List<SalaryGroupUserResult.SimpleUserData> list = new ArrayList<>();
          for (SalaryGroupUser salaryGroupUser : groupUsers) {
              SalaryGroupUserResult.SimpleUserData simpleUserData = new SalaryGroupUserResult.SimpleUserData();
              simpleUserData.setUserId(salaryGroupUser.getUserId());
              simpleUserData.setUserName(salaryGroupUser.getUserName());
              simpleUserData.setShopId(salaryGroupUser.getShopId());
              simpleUserData.setShopName(salaryGroupUser.getShopName());
              list.add(simpleUserData);
          }
  
          return list;
      }
  
      public SalaryGroupUserResult queryGroupSalaryUser(SalaryGroupUserQuery salaryGroupUserQuery) {
          final Long groupId = salaryGroupUserQuery.getGroupId();

          final Date dataDate = new Date(salaryGroupUserQuery.getDataDate());
          log.info("查询薪酬组人员，日期：{}", new SimpleDateFormat("yyyy-MM-dd").format(dataDate));
          final YearMonth monthly = YearMonth.from(DateUtil.date2LocalDateTime(dataDate));

          List<SalaryGroupUserResult.SimpleUserData> userData = new ArrayList<>();
  
          List<SalaryPool> pools = salaryPoolService.list(Wrappers.<SalaryPool>lambdaQuery()
                  .eq(SalaryPool::getGroupId, groupId)
                  .eq(SalaryPool::getMonthly, monthly)
                  .eq(SalaryPool::getYn, Boolean.TRUE)
          );
          SalaryGroupUserResult result = new SalaryGroupUserResult();
          if (PublicUtil.isEmpty(pools)) {
              result.setUserIdList(new ArrayList<>());
              return result;
          }
          for (SalaryPool pool : pools) {
              SalaryGroupUserResult.SimpleUserData simpleUserData = new SalaryGroupUserResult.SimpleUserData();
              simpleUserData.setUserId(pool.getUserId());
              simpleUserData.setUserName(pool.getUserName());
              simpleUserData.setShopId(pool.getShopId());
              simpleUserData.setShopName(pool.getShopName());
              userData.add(simpleUserData);
          }
          result.setUserIdList(userData);
          return result;
      }

  }