KPI / fw-morax

  package cn.fw.morax.server.task;
  
  import cn.fw.common.cache.locker.DistributedLocker;

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

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

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

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

  import cn.fw.morax.domain.bo.salary.SalaryGroupProjectBO;

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

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

  import cn.fw.morax.domain.vo.salary.SalaryGroupProjectParamVO;

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

  import cn.fw.morax.rpc.ehr.dto.ManagerStaffRoleDTO;
  import cn.fw.morax.rpc.ehr.dto.ManagerStaffShopDTO;

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

  import cn.fw.morax.rpc.oop.OopRpcService;

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

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

  import cn.fw.morax.service.biz.salary.SalarySettingCommonService;

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

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

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

  import com.alibaba.fastjson.JSON;

  import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

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

  import com.google.common.collect.Maps;

  import lombok.Getter;

  import lombok.RequiredArgsConstructor;
  import lombok.extern.slf4j.Slf4j;
  import org.apache.commons.collections4.map.MultiKeyMap;

  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.PlatformTransactionManager;
  import org.springframework.transaction.TransactionDefinition;
  import org.springframework.transaction.TransactionStatus;

  import org.springframework.transaction.annotation.Transactional;
  import org.springframework.util.CollectionUtils;
  
  import java.math.BigDecimal;

  import java.time.LocalDate;
  import java.time.YearMonth;

  import java.time.temporal.TemporalAdjusters;

  import java.util.*;

  import java.util.concurrent.atomic.AtomicInteger;

  import java.util.concurrent.locks.Lock;

  import java.util.function.Function;

  import java.util.function.Predicate;
  import java.util.function.ToDoubleFunction;

  import java.util.stream.Collectors;
  
  /**
   * @author : jiangchao

   * @className : SalaryReportRatioTask

   * @description : 薪酬报表定时器

   * @date : 2022-04-07 15:29
   */
  @Component
  @Slf4j
  @RequiredArgsConstructor
  @ConditionalOnProperty(prefix = "task", name = "switch", havingValue = "on")
  public class SalaryReportTask {
  

      private final DistributedLocker distributedLocker;

      private final SalaryGroupService salaryGroupService;
      private final SalaryPoolService salaryPoolService;

      private final KpiPoolService kpiPoolService;
      private final KpiPoolCommonService kpiPoolCommonService;

      private final ReportSalaryService reportSalaryService;

      private final TransactionDefinition transactionDefinition;

      private final ReportSalaryDimService reportSalaryDimService;

      private final ReportSalaryCodeService reportSalaryCodeService;
      private final IndicatorUserValueService indicatorUserValueService;

      private final SalaryGroupProjectService salaryGroupProjectService;

      private final PlatformTransactionManager platformTransactionManager;

      private final ReportSalaryDimExtraService reportSalaryDimExtraService;

      private final ReportSalaryDimValueService reportSalaryDimValueService;

      private final SalaryGroupProjectHitLogService salaryGroupProjectHitLogService;

      private final SalaryGeneralSettinService salaryGeneralSettinService;

      private final SalaryGroupProjectSettinService salaryGroupProjectSettinService;

      private final SalarySettingCommonService salarySettingCommonService;

      private final SalaryGroupProjectParamService salaryGroupProjectParamService;

      private final SalaryGroupProjectTargetHitLogService salaryGroupProjectTargetHitLogService;

      private final CommonService commonService;

      private final EhrRpcService ehrRpcService;

      private final OopRpcService oopRpcService;

      private final SalaryPoolDetailService salaryPoolDetailService;

      @Value("${special-indicator-code.car-series}")
      @Getter
      private String carSeries;

      @Value("${special-indicator-code.base-salary}")
      @Getter
      private String baseSalaryCode;

      @Value("${spring.cache.custom.global-prefix}:salary:group:report")
      @Getter

      private String salaryGroupReportDistKey;

      /**

       * 薪酬报表定时任务

       *

       */

      @Scheduled(cron = TimeTaskConstant.SALARY_REPORT)

      @Transactional(rollbackFor = Exception.class)
      public void salaryReportTask() {
          this.salaryReport(LocalDate.now().minusDays(1));
      }
  
      /**

       * 薪酬报表最终定时任务（

       * 人员质量评测每月2号计算上月、计算完成后会操作上月薪酬分，所以再次抽取上月报表）

       */

      @Scheduled(cron = TimeTaskConstant.SALARY_MONTH_FINAL_REPORT)

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

          LocalDate lastMonthEndDay = LocalDate.now().minusMonths(1).with(TemporalAdjusters.lastDayOfMonth());

          YearMonth monthly = YearMonth.now().minusMonths(1);

          oopRpcService.allGroups().stream().forEach(group -> {
              final Long groupId = group.getId();

              Boolean hasEndAppeal = salarySettingCommonService.lastDayHasClosureForReport(groupId, monthly);

              if (hasEndAppeal) {

                  this.salaryReport(lastMonthEndDay);
              }
          });

      }
  
      /**

       * 薪酬报表定时任务

       *
       * @param date
       */

      public void salaryReport(LocalDate date) {

          Lock lock = distributedLocker.lock(getSalaryGroupReportDistKey());
          if (! ((RLock) lock).isLocked()) {

              return;
          }

          TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);

          try {

              log.info("定时任务【薪酬报表数据抽取-新】开始执行");

              //清理数据,每天留一条当月最新数据,每个月留一条月最后一天的数据
              cleanData(date);

              //查询所有需要处理的薪酬组

              List<SalaryGroup> salaryGroups = salaryGroupService.getAllEffectGroups(DateUtil.localDate2Date(date));

              for (SalaryGroup salaryGroup : salaryGroups) {

                  //抽取排名组数据

                  createReport(salaryGroup, salaryGroup.getGroupId(), date);

              }
              platformTransactionManager.commit(transactionStatus);
          } catch (Exception e){
              platformTransactionManager.rollback(transactionStatus);

              log.error(e.getMessage(), e);
          } finally {
              lock.unlock();
          }
      }
  

      /**

       * 薪酬排名组报表数据抽取

       * @param salaryGroup

       * @param groupId
       * @param date

       */

      private void createReport(SalaryGroup salaryGroup, Long groupId, LocalDate date) {
          final Long salaryGroupId = salaryGroup.getId();

          List<SalaryPool> pools = salaryPoolService.list(Wrappers.<SalaryPool>lambdaQuery()

                  .eq(SalaryPool::getSalaryGroupId, salaryGroupId)

                  .eq(SalaryPool::getMonthly, YearMonth.from(date))
                  .eq(SalaryPool::getYn, Boolean.TRUE)
          );
          if (PublicUtil.isEmpty(pools)) {
              return;
          }

          //保存 报表薪酬排名组 信息

          final Long reportSalaryId = saveReportSalary(salaryGroup, groupId, date);

  
          //薪酬排名组下归属的所有薪酬组的对应指标集合

          List<SalaryGroupProjectBO> salaryGroupProjects = getProjectBO(salaryGroupId);

          //一个薪酬排名组对应多个薪酬组,也对应薪酬组下的所有指标集合

          saveReportSalaryCodes(date, reportSalaryId, salaryGroupProjects);
          List<ReportSalaryDim> userDims = new ArrayList();

          //人员维度

          List<ReportSalaryDimValue> userSalaryValues = calcUser(salaryGroupProjects, userDims, date, pools, reportSalaryId);

          //门店维度

          calcShop(salaryGroupProjects, pools, reportSalaryId, userSalaryValues, userDims, date);

          //管理层维度
          calcManager(salaryGroupProjects, pools, reportSalaryId, userSalaryValues, userDims, date);

      }
  

      private List<ReportSalaryCode> saveReportSalaryCodes(LocalDate date, Long reportSalaryId, List<SalaryGroupProjectBO> salaryGroupProjects) {
          LinkedList<ReportSalaryCode> reportSalaryCodes = new LinkedList<>();
          AtomicInteger order = new AtomicInteger();
          for (SalaryGroupProjectBO salaryGroupProject : salaryGroupProjects) {

              reportSalaryCodes.add(createProjectCode(salaryGroupProject, order));
              if (IndicatorCodeTypeEnum.COMBINE_INDICATOR.equals(salaryGroupProject.getCodeType())) {
                  List<SalaryGroupProjectParamVO> salaryGroupProjectParamVos = salaryGroupProjectParamService.
                          getSalaryGroupProjectParamVO(salaryGroupProject.getId());
                  if (salaryGroupProject.getCalMethod().equals(SalaryCalMethodEnum.CAR_SERIES)) {

                      continue;

                  }
                  reportSalaryCodes.addAll(createParamCodes(salaryGroupProject, salaryGroupProjectParamVos, order));
              }
          }
  
          if (PublicUtil.isNotEmpty(reportSalaryCodes)) {
              reportSalaryCodes.forEach(reportSalaryCode -> {
                  reportSalaryCode.setReportSalaryId(reportSalaryId);
                  reportSalaryCode.setDataDate(date);
              });
              reportSalaryCodeService.saveBatch(reportSalaryCodes);
          }
          return reportSalaryCodes;
      }
  
  
  
      private List<ReportSalaryDimValue> calcUser(List<SalaryGroupProjectBO> salaryGroupProjects,
                                                    List<ReportSalaryDim> userDims,
                                                    LocalDate date,
                                                    List<SalaryPool> pools,
                                                    Long reportSalaryId) {
          MultiKeyMap<Long, BigDecimal> userSalaryMap = this.getUserIndicatorHitMap(salaryGroupProjects, date, pools);

          Map<Long, List<SalaryPoolDetail>> salaryPoolDetailMap = this.getSalaryPoolDetailMap(date, pools);

          List<ReportSalaryDimValue> reportSalaryValues = new ArrayList<>();

          //人的维度为基础,计算各个指标信息对应的数据

          for (SalaryPool pool : pools) {

              List<SalaryPoolDetail> salaryPoolIdDetails = Optional.ofNullable(salaryPoolDetailMap.get(pool.getId())).orElse(Collections.emptyList());
              ReportSalaryDim reportSalaryDim = saveStaffDim(pool, date, reportSalaryId,salaryPoolIdDetails);

              userDims.add(reportSalaryDim);

              final Long userId = pool.getUserId();

              final Long reportSalaryDimId = reportSalaryDim.getId();
              //薪酬排名组下的所有指标集合

              for (SalaryGroupProjectBO salaryGroupProject : salaryGroupProjects) {

                  if (! pool.getSalaryGroupId().equals(salaryGroupProject.getSalaryGroupId())) {

                      continue;

                  }

                  final Long salaryGroupProjectId = salaryGroupProject.getId();

                  reportSalaryValues.add(this.convertDB(salaryGroupProject, reportSalaryDimId, date, userSalaryMap.get(userId, salaryGroupProjectId)));
                  List<SalaryGroupProjectParamVO> salaryGroupProjectParamVos = salaryGroupProjectParamService.getSalaryGroupProjectParamVO(salaryGroupProject.getId());

  
                  if (salaryGroupProject.getCalMethod().equals(SalaryCalMethodEnum.CAR_SERIES)) {

                      continue;
                  }
  

                  Set<String> paramCodes = new HashSet<>();
                  for (SalaryGroupProjectParamVO salaryGroupProjectParam : salaryGroupProjectParamVos) {
                      //一个薪酬项目中，指标只能出现一次
                      if (! paramCodes.add(salaryGroupProjectParam.getIndicatorCode())) {
                          continue;
                      }
                      if (TargetTypeEnum.NO.equals(salaryGroupProjectParam.getTargetType())) {
                          //无目标
                          Map<Long, BigDecimal> userValueMap = queryUserOriginValue(salaryGroupProjectParam.getIndicatorCode(), userId, date);
                          BigDecimal value = userValueMap.getOrDefault(userId, BigDecimal.ZERO);
                          reportSalaryValues.add(this.convertNoTargetDB(salaryGroupProject, salaryGroupProjectParam, date, reportSalaryDimId, value));
                      } else {
                          //有目标
                          Map<Long, SalaryGroupProjectTargetHitLog> targetHitLogMap = queryUserTargetValue(salaryGroupProjectParam.getId(), userId, date);
                          SalaryGroupProjectTargetHitLog hitLog = targetHitLogMap.get(userId);
                          BigDecimal value = Optional.ofNullable(hitLog).map(SalaryGroupProjectTargetHitLog::getReachValue).orElse(BigDecimal.ZERO);
                          reportSalaryValues.add(this.convertTargetDB(salaryGroupProject, salaryGroupProjectParam, date, reportSalaryDimId, value));

                      }

                  }
              }
          }

          if (PublicUtil.isNotEmpty(reportSalaryValues)){

              reportSalaryDimValueService.saveBatch(reportSalaryValues);

          }
          return reportSalaryValues;
      }

      public void calcShop(List<SalaryGroupProjectBO> salaryGroupProjects,

                            List<SalaryPool> pools,

                            Long reportSalaryId,

                            List<ReportSalaryDimValue> userSalaryValues,

                            List<ReportSalaryDim> userDims,

                            LocalDate date) {
          Map<Long, String> shopMap = pools.stream().collect(Collectors.toMap(SalaryPool::getShopId, SalaryPool::getShopName, (v1, v2) -> v1));

          List<ReportSalaryDimValue> reportSalaryDimValues = new ArrayList<>();

          for (Long shopId : shopMap.keySet()) {

              List<ReportSalaryDimValue> childReportSalaryDimValues = new ArrayList<>();

              Set<Long> shopDimReportIds = userDims.stream()

                      .filter(user -> shopId.equals(user.getShopId()))

                      .map(ReportSalaryDim::getId).collect(Collectors.toSet());

              if (PublicUtil.isEmpty(shopDimReportIds)) {
                  continue;
              }

              final Long shopReportSalaryDimId = this.saveShopDimDB(shopId, shopMap, date, reportSalaryId, userDims, shopDimReportIds);

              for (SalaryGroupProjectBO salaryGroupProject : salaryGroupProjects) {

                  BigDecimal value = calcAverageValue(userSalaryValues, shopDimReportIds, salaryGroupProject.getId().toString());

                  childReportSalaryDimValues.add(this.convertProjectValueDB(salaryGroupProject, value));
                  Set<String> paramCodes = new HashSet<>();
                  List<SalaryGroupProjectParamVO> salaryGroupProjectParamVos = salaryGroupProjectParamService.getSalaryGroupProjectParamVO(salaryGroupProject.getId());
                  for (SalaryGroupProjectParamVO salaryGroupProjectParam : salaryGroupProjectParamVos) {
                      if (! paramCodes.add(salaryGroupProjectParam.getIndicatorCode())) {
                          continue;

                      }

                      BigDecimal paramValue = calcAverageValue(userSalaryValues, shopDimReportIds, salaryGroupProjectParam.getIndicatorCode());
                      childReportSalaryDimValues.add(this.convertShopValueDBPcode(salaryGroupProjectParam, paramValue, salaryGroupProject));

                  }

              }

  
              childReportSalaryDimValues.forEach(reportSalaryDimValue -> {
                  reportSalaryDimValue.setDataDate(date);
                  reportSalaryDimValue.setReportSalaryDimId(shopReportSalaryDimId);
              });
              reportSalaryDimValues.addAll(childReportSalaryDimValues);
          }
          if (PublicUtil.isNotEmpty(reportSalaryDimValues)){
              reportSalaryDimValueService.saveBatch(reportSalaryDimValues);

          }
      }

      public void calcManager(List<SalaryGroupProjectBO> salaryGroupProjects,

                            List<SalaryPool> pools,
                            Long reportSalaryId,
                            List<ReportSalaryDimValue> userSalaryValues,
                            List<ReportSalaryDim> userDims,
                            LocalDate date) {
          List<Long> shopIds = pools.stream().map(SalaryPool::getShopId).collect(Collectors.toList());
          List<ManagerDTO> managerDTOS = ehrRpcService.getRealTimeShopManager(new ArrayList<>(shopIds));
          log.info("查询门店实时管理者：{}，{}", JSON.toJSONString(shopIds), JSON.toJSONString(managerDTOS));
          if (PublicUtil.isEmpty(managerDTOS)) {
              return;
          }
          Map<Long, StaffBaseInfoDTO> managerMap = staffInfoMap(managerDTOS);
          List<ReportSalaryDimValue> reportSalaryDimValues = new ArrayList<>();
          for (ManagerDTO manager : managerDTOS) {

              List<ReportSalaryDimValue> childReportSalaryDimValues = new ArrayList<>();

              if (PublicUtil.isEmpty(manager.getManageStaffList())) {
                  continue;
              }

              List<Long> manageStaffIds = manager.getManageStaffList().stream().map(StaffBaseInfoDTO::getId).distinct().collect(Collectors.toList());
              Set<Long> managerStaffDimReportIds = userDims.stream()

                      .filter(user -> manageStaffIds.contains(user.getUserId()))

                      .map(ReportSalaryDim::getId).collect(Collectors.toSet());
              if (PublicUtil.isEmpty(managerStaffDimReportIds)) {
                  continue;
              }

              //BigDecimal kpiScoreRatio = calcAverageKpiScoreRatio(userDims, managerStaffDimReportIds);
              //BigDecimal averageSalary = calcAverageTotalSalary(userDims, managerStaffDimReportIds);
              final Long reportSalaryDimId = this.saveManagerDimDB(manager, date, reportSalaryId, managerMap,manageStaffIds,managerStaffDimReportIds,userDims);

              for (SalaryGroupProjectBO salaryGroupProject : salaryGroupProjects) {

                  BigDecimal value = calcAverageValue(userSalaryValues, managerStaffDimReportIds, salaryGroupProject.getId().toString());

                  childReportSalaryDimValues.add(this.convertProjectValueDB(salaryGroupProject, value));

                  List<SalaryGroupProjectParamVO> salaryGroupProjectParamVos = salaryGroupProjectParamService.getSalaryGroupProjectParamVO(salaryGroupProject.getId());
                  for (SalaryGroupProjectParamVO salaryGroupProjectParam : salaryGroupProjectParamVos) {
                      BigDecimal paramValue = calcAverageValue(userSalaryValues, managerStaffDimReportIds, salaryGroupProjectParam.getIndicatorCode());

                      childReportSalaryDimValues.add(this.convertShopValueDBPcode(salaryGroupProjectParam, paramValue, salaryGroupProject));

                  }
              }

  
              childReportSalaryDimValues.forEach(reportSalaryDimValue -> {
                  reportSalaryDimValue.setDataDate(date);
                  reportSalaryDimValue.setReportSalaryDimId(reportSalaryDimId);
              });
              reportSalaryDimValues.addAll(childReportSalaryDimValues);

          }
          if (PublicUtil.isNotEmpty(reportSalaryDimValues)) {
              reportSalaryDimValueService.saveBatch(reportSalaryDimValues);
          }
      }
  
      public Map<Long, StaffBaseInfoDTO> staffInfoMap(List<ManagerDTO> managerDTOS) {
          List<Long> staffIds = managerDTOS.stream().map(ManagerDTO::getStaffId).collect(Collectors.toList());
          List<StaffBaseInfoDTO> staffInfos = ehrRpcService.queryStaffBaseInfo(staffIds);
          return staffInfos.stream().collect(Collectors.toMap(StaffBaseInfoDTO::getId, Function.identity(), (v1, v2) -> v1));
      }
  

      /**
       * 抽象处理平均值计算
       * @param data
       * @param predicate
       * @param field
       * @return
       */
      private <T> BigDecimal calcAverage(final Collection<T> data,Predicate<T> predicate, final ToDoubleFunction<T> field) {
          if (CollectionUtils.isEmpty(data)) {
              return BigDecimal.ZERO;
          }
          Double averageRatioDouble = data.stream()
                  .filter(predicate)
                  .mapToDouble(field)
                  .average()
                  .orElse(0);
          return BigDecimal.valueOf(averageRatioDouble);
      }
  
      /**
       * 抽象处理平均值计算
       * @param data
       * @param field
       * @return
       * @param <T>
       */
      private <T> BigDecimal calcAverage(final Collection<T> data, final ToDoubleFunction<T> field) {
          if (CollectionUtils.isEmpty(data)) {
              return BigDecimal.ZERO;
          }
          Double averageRatioDouble = data.stream()
                  .mapToDouble(field)
                  .average()
                  .orElse(0);
          return BigDecimal.valueOf(averageRatioDouble);
      }
  
  

      public BigDecimal calcAverageTotalSalary(List<ReportSalaryDim> dims, Set<Long> ReportDimIds) {
          Double averageRatioDouble = dims.stream()
                  .filter(user -> ReportDimIds.contains(user.getId()))
                  .mapToDouble(userValue -> Optional.ofNullable(userValue.getTotalReward()).orElse(BigDecimal.ZERO).doubleValue())
                  .average()
                  .orElse(0);
          return new BigDecimal(averageRatioDouble.toString());
      }
  

      public BigDecimal calcAverageKpiScoreRatio(List<ReportSalaryDim> dims, Set<Long> ReportDimIds) {
          Double averageRatioDouble = dims.stream()
                  .filter(user -> ReportDimIds.contains(user.getId()))
                  .mapToDouble(userValue -> Optional.ofNullable(userValue.getKpiScoreRatio()).orElse(BigDecimal.ZERO).doubleValue())
                  .average()
                  .orElse(0);
          return new BigDecimal(averageRatioDouble.toString());
      }
  

      public BigDecimal calcAverageValue(List<ReportSalaryDimValue> userSalaryValues, Set<Long> ReportDimIds, String code) {

          Double averageRatioDouble = userSalaryValues.stream()

                  .filter(user -> ReportDimIds.contains(user.getReportSalaryDimId()) && code.equals(user.getCode()))

                  .mapToDouble(userValue -> Optional.ofNullable(userValue.getValue()).orElse(BigDecimal.ZERO).doubleValue())
                  .average()
                  .orElse(0);
          return new BigDecimal(averageRatioDouble.toString());
      }

      public Long saveShopDimDB(Long shopId,
                                Map<Long, String> shopMap,
                                LocalDate date,
                                Long reportSalaryId,
                                List<ReportSalaryDim> userDims,
                                Set<Long> shopDimReportIds) {

          ReportSalaryDim reportSalaryDim = new ReportSalaryDim();
          reportSalaryDim.setDimension(ReportDimensionEnum.SHOP);
          reportSalaryDim.setReferId(shopId);
          reportSalaryDim.setShopId(shopId);
          reportSalaryDim.setShopName(shopMap.get(shopId));
          reportSalaryDim.setDataDate(date);
          reportSalaryDim.setReportSalaryId(reportSalaryId);

          //计算平均值薪酬的额外项
          extCalcAverage(userDims, shopDimReportIds, reportSalaryDim);

          reportSalaryDimService.save(reportSalaryDim);
          return reportSalaryDim.getId();

      }

  
      /**
       * 计算平均值薪酬的额外项
       * @param userDims
       * @param shopDimReportIds
       * @param reportSalaryDim
       */
      private void extCalcAverage(List<ReportSalaryDim> userDims, Set<Long> shopDimReportIds, ReportSalaryDim reportSalaryDim) {
          List<ReportSalaryDim> filterUserDims = userDims.stream().filter(e -> shopDimReportIds.contains(e.getId())).collect(Collectors.toList());
          //绩效得分率(N)
          reportSalaryDim.setKpiScoreRatio(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getKpiScoreRatio()).orElse(BigDecimal.ZERO).doubleValue()));
          //收入-平均值
          reportSalaryDim.setActKpiMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActKpiMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActAwardMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActAwardMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActSubsidyMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActSubsidyMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActProbationMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActProbationMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActJobCompensateMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActJobCompensateMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActEvalAwardMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActEvalAwardMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          //总收入合计平均值
          reportSalaryDim.setActRevenueTotalMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActRevenueTotalMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          //reportSalaryDim.setActRevenueTotalMoney(
          //        reportSalaryDim.getActKpiMoney()
          //                .add(reportSalaryDim.getActAwardMoney())
          //                .add(reportSalaryDim.getActSubsidyMoney())
          //                .add(reportSalaryDim.getActProbationMoney())
          //                .add(reportSalaryDim.getActJobCompensateMonry())
          //                .add(reportSalaryDim.getActEvalAwardMoney())
          //);
          //扣除-平均值
          reportSalaryDim.setActPenaltyMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActPenaltyMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActNecessaryMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActNecessaryMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActPersonTaxMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActPersonTaxMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          reportSalaryDim.setActAccumulationFundMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActAccumulationFundMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          //总扣除合计平均值
          reportSalaryDim.setActDeductTotalMoney(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getActDeductTotalMoney()).orElse(BigDecimal.ZERO).doubleValue()));
          //reportSalaryDim.setActDeductTotalMoney(
          //        reportSalaryDim.getActPenaltyMoney()
          //                .add(reportSalaryDim.getActNecessaryMoney())
          //                .add(reportSalaryDim.getActPersonTaxMoney())
          //                .add(reportSalaryDim.getActAccumulationFundMoney())
          //);
          //总薪酬平均值 = 总收入合计 - 总扣除合计 or 直接取平均值
          reportSalaryDim.setTotalReward(calcAverage(filterUserDims, e -> Optional.ofNullable(e.getTotalReward()).orElse(BigDecimal.ZERO).doubleValue()));
          //reportSalaryDim.setTotalReward(
          //        reportSalaryDim.getActRevenueTotalMoney()
          //                .subtract(reportSalaryDim.getActDeductTotalMoney()));
      }
  
      /**
       * 计算人员的
       * 增加 薪资类型相关项目处理 ++
       * @param salaryPoolDetails
       * @param reportSalaryDim
       */
      private void extCaleUserMoney(List<SalaryPoolDetail> salaryPoolDetails, ReportSalaryDim reportSalaryDim) {
          //额外计算项++
          Map<SalaryTypeEnum, List<SalaryPoolDetail>> salaryTypeEnumListMap = salaryPoolDetails
                  .stream()
                  .collect(Collectors.groupingBy(SalaryPoolDetail::getType));
          //收入
          reportSalaryDim.setActKpiMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.ROYALTIES));
          reportSalaryDim.setActAwardMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.AWARD));
          reportSalaryDim.setActSubsidyMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.SUBSIDY));
          reportSalaryDim.setActProbationMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.PROBATION));
          reportSalaryDim.setActJobCompensateMoney(BigDecimal.ZERO);
          reportSalaryDim.setActEvalAwardMoney(BigDecimal.ZERO);
          //总收入合计
          reportSalaryDim.setActRevenueTotalMoney(
                  reportSalaryDim.getActKpiMoney()
                          .add(reportSalaryDim.getActAwardMoney())
                          .add(reportSalaryDim.getActSubsidyMoney())
                          .add(reportSalaryDim.getActProbationMoney())
                          .add(reportSalaryDim.getActJobCompensateMoney())
                          .add(reportSalaryDim.getActEvalAwardMoney())
          );
          //扣除
          reportSalaryDim.setActPenaltyMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.PENALTY));
          reportSalaryDim.setActNecessaryMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.NECESSARY));
          reportSalaryDim.setActPersonTaxMoney(getSalaryTypeEnumMoney(salaryTypeEnumListMap,SalaryTypeEnum.PERSON_TAX));
          reportSalaryDim.setActAccumulationFundMoney(BigDecimal.ZERO);
          //总扣除合计
          reportSalaryDim.setActDeductTotalMoney(
                  reportSalaryDim.getActPenaltyMoney()
                          .add(reportSalaryDim.getActNecessaryMoney())
                          .add(reportSalaryDim.getActPersonTaxMoney())
                          .add(reportSalaryDim.getActAccumulationFundMoney())
          );
          //总薪酬 = 总收入合计 - 总扣除合计
          reportSalaryDim.setTotalReward(
                  reportSalaryDim.getActRevenueTotalMoney()
                          .subtract(reportSalaryDim.getActDeductTotalMoney()));
      }
  
  

      public Long saveManagerDimDB(ManagerDTO manager,
                                   LocalDate date,
                                   Long reportSalaryId,
                                   Map<Long, StaffBaseInfoDTO> managerMap,

                                   List<Long> manageStaffIds,
                                   Set<Long> managerStaffDimReportIds,
                                   List<ReportSalaryDim> userDims) {

          ReportSalaryDim reportSalaryDim = new ReportSalaryDim();
          reportSalaryDim.setDimension(ReportDimensionEnum.MANAGER);
          reportSalaryDim.setUserId(manager.getStaffId());
          reportSalaryDim.setUserName(manager.getStaffName());

          //计算平均值薪酬的额外项
          extCalcAverage(userDims, managerStaffDimReportIds, reportSalaryDim);

          reportSalaryDim.setDataDate(date);
          reportSalaryDim.setReportSalaryId(reportSalaryId);
          if (managerMap.containsKey(manager.getStaffId())) {
              StaffBaseInfoDTO staffInfo = managerMap.get(manager.getStaffId());
              reportSalaryDim.setShopId(staffInfo.getShopId());
              reportSalaryDim.setShopName(staffInfo.getShopName());

              reportSalaryDim.setPostId(staffInfo.getPostId());
              reportSalaryDim.setPostName(staffInfo.getPostName());

          }

  
          List<String> roleCodes = manager.getScopeList().stream()
                  .flatMap(managerStaffVo -> managerStaffVo.getRoleList().stream())
                  .map(ManagerStaffRoleDTO::getRoleCode)
                  .distinct()
                  .collect(Collectors.toList());
          List<String> roleNames = manager.getScopeList().stream()
                  .flatMap(managerStaffVo -> managerStaffVo.getRoleList().stream())
                  .map(ManagerStaffRoleDTO::getRoleName)
                  .distinct()
                  .collect(Collectors.toList());
          List<Long> shopIds = manager.getScopeList().stream()
                  .flatMap(managerStaffVo -> managerStaffVo.getShopList().stream())
                  .map(ManagerStaffShopDTO::getShopId)
                  .distinct()
                  .collect(Collectors.toList());
  
          reportSalaryDimService.save(reportSalaryDim);
          ReportSalaryDimExtra reportSalaryDimExtra = new ReportSalaryDimExtra();
          reportSalaryDimExtra.setReportSalaryDimId(reportSalaryDim.getId());
          ReportSalaryDimExtra dimExtra = ReportSalaryDimExtra.builder()
                  .reportSalaryDimId(reportSalaryDim.getId())
                  .roleCodes(roleCodes)
                  .roleNames(roleNames)
                  .shopIds(shopIds)
                  .staffIds(manageStaffIds)
                  .build();
          reportSalaryDimExtraService.save(dimExtra);

          return reportSalaryDim.getId();

      }

      public ReportSalaryDimValue convertProjectValueDB(SalaryGroupProjectBO salaryGroupProject, BigDecimal value) {

          ReportSalaryDimValue reportSalaryValue = new ReportSalaryDimValue();

          reportSalaryValue.setCode(salaryGroupProject.getId().toString());

          reportSalaryValue.setCodeType(salaryGroupProject.getCodeType());

          reportSalaryValue.setValue(value);

          reportSalaryValue.setSalaryGroupProjectId(salaryGroupProject.getId());

          return reportSalaryValue;
      }

      public ReportSalaryDimValue convertShopValueDBPcode(SalaryGroupProjectParamVO salaryGroupProjectParam, BigDecimal value,SalaryGroupProjectBO salaryGroupProject) {

          ReportSalaryDimValue reportSalaryValue = new ReportSalaryDimValue();
          reportSalaryValue.setCode(salaryGroupProjectParam.getIndicatorCode());

          reportSalaryValue.setCodeType(IndicatorCodeTypeEnum.INDICATOR);
          reportSalaryValue.setValue(value);

          reportSalaryValue.setSalaryGroupProjectId(salaryGroupProjectParam.getSalaryGroupProjectId());

          reportSalaryValue.setParentCode(salaryGroupProject.getId().toString());

          return reportSalaryValue;
      }

      public ReportSalaryDimValue convertDB(SalaryGroupProjectBO salaryGroupProject, Long reportSalaryDimId, LocalDate date, BigDecimal salaryValue) {

          ReportSalaryDimValue reportSalaryValue = new ReportSalaryDimValue();

          reportSalaryValue.setCode(salaryGroupProject.getId().toString());

          reportSalaryValue.setCodeType(salaryGroupProject.getCodeType());

          if (PublicUtil.isEmpty(salaryValue)) {
              reportSalaryValue.setValue(BigDecimal.ZERO);
          } else {
              reportSalaryValue.setValue(salaryValue);
          }

          reportSalaryValue.setDataDate(date);
          reportSalaryValue.setReportSalaryDimId(reportSalaryDimId);

          reportSalaryValue.setSalaryGroupProjectId(salaryGroupProject.getId());

          return reportSalaryValue;
      }

      public ReportSalaryDimValue convertNoTargetDB(SalaryGroupProjectBO salaryGroupProject,

                                              SalaryGroupProjectParamVO salaryGroupProjectParam,

                                              LocalDate date,
                                              Long reportSalaryDimId,
                                              BigDecimal value) {

          ReportSalaryDimValue reportSalaryValue = new ReportSalaryDimValue();
          reportSalaryValue.setCode(salaryGroupProjectParam.getIndicatorCode());

          reportSalaryValue.setCodeType(IndicatorCodeTypeEnum.INDICATOR);

          reportSalaryValue.setParentCode(salaryGroupProject.getId().toString());

          reportSalaryValue.setValue(value);
          //百分数处理

          if (DataTypeEnum.RATIO.equals(salaryGroupProjectParam.getDataType())){

              reportSalaryValue.setValue(value.multiply(Constant.ONE_HUNDRED));