manatee/src/main/java/com/galaxis/manatee/service/LogStandardService.java

package com.galaxis.manatee.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.galaxis.manatee.constant.ChuanYunConstant;
import com.galaxis.manatee.dao.*;
import com.galaxis.manatee.entity.chuanyun.data.object.*;
import com.galaxis.manatee.entity.chuanyun.dto.Filter;
import com.galaxis.manatee.manager.ChuanYunManager;
import com.galaxis.manatee.mapper.WorkHourMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 更新日志中所用到的服务
 *
 * @author zcj
 * @version 0.1
 * @date 2021/3/4 1:54 上午
 */
@Slf4j
@Service
public class LogStandardService {

    @Autowired
    private ChuanYunManager chuanYunManager;

    @Autowired
    private WorkHourMapper workHourMapper;

    @Autowired
    private WorkGroupService workGroupService;

    @Autowired
    private ChuanyunProjectDao chuanyunProjectDao;

    private final DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private final ChuanyunWorkHourDao chuanyunWorkHourDao;
    private final ChuanyunSelfCostDao chuanyunSelfCostDao;
    private final ChuanyunSelfWorkHourDao chuanyunSelfWorkHourDao;
    private final ChuanyunGroupProjectDao chuanyunGroupProjectDao;
    private final ChuanyunWeekMemberHourDao chuanyunWeekMemberHourDao;
    private final ChuanyunUserCompanyDao chuanyunUserCompanyDao;
    private final DataArcherService dataArcherService;

    public LogStandardService(ChuanyunWorkHourDao chuanyunWorkHourDao, ChuanyunSelfCostDao chuanyunSelfCostDao, ChuanyunSelfWorkHourDao chuanyunSelfWorkHourDao, ChuanyunGroupProjectDao chuanyunGroupProjectDao, ChuanyunWeekMemberHourDao chuanyunWeekMemberHourDao, ChuanyunUserCompanyDao chuanyunUserCompanyDao, DataArcherService dataArcherService) {
        this.chuanyunWorkHourDao = chuanyunWorkHourDao;
        this.chuanyunSelfCostDao = chuanyunSelfCostDao;
        this.chuanyunSelfWorkHourDao = chuanyunSelfWorkHourDao;
        this.chuanyunGroupProjectDao = chuanyunGroupProjectDao;
        this.chuanyunWeekMemberHourDao = chuanyunWeekMemberHourDao;
        this.chuanyunUserCompanyDao = chuanyunUserCompanyDao;
        this.dataArcherService = dataArcherService;
    }

    /**
     * 员工单日、各个项目工时标准化,并保存
     *
     * @param isRecent              是否只标准化最近一个月的数据
     * @param chuanyunUserCompanyDO 员工信息
     */
    @Async("threadPoolTaskExecutor")
    public void standardHourByUserCompanyAndIsRecent(ChuanyunUserCompanyDO chuanyunUserCompanyDO, boolean isRecent) {
        if (!StringUtils.isEmpty(chuanyunUserCompanyDO.getUserId())) {
            long start = Instant.now().getEpochSecond();
            //从日志原始数据中获取每人每个项目每天工时。
            //由isRecent判断是否只获取最近30天的数据
            List<ChuanyunWorkHourDO> selfList = isRecent ? chuanyunWorkHourDao.getSelfWorkHourRecently(chuanyunUserCompanyDO.getUserId()) : chuanyunWorkHourDao.getSelfWorkHour(chuanyunUserCompanyDO.getUserId());
            this.generateSelfWorkHourByWorkHourList(selfList);
            log.info("每日工时标准化" + chuanyunUserCompanyDO.getUserName() + (Instant.now().getEpochSecond() - start) + "秒");
        } else {
            log.warn("用户信息中userId缺失");
        }
    }

    /**
     * 标准化最近一个月每周工时
     */
    @Async("threadPoolTaskExecutor")
    public void standardWeekMemberHourRecent() {
        List<ChuanyunWeekMemberHourDO> list = chuanyunWeekMemberHourDao.getWeekMemberHourRecently();
        this.generateWeekMemberHourByWeekMemberHourList(list);
    }

    /**
     * 根据用户Id标准化某个人的日工时
     *
     * @param userId 用户Id
     */
    @Async("threadPoolTaskExecutor")
    public void standardSelfWorkHourByUserId(String userId) {
        if (!Objects.isNull(userId) && !userId.isBlank()) {
            log.info("标准化用户日工时 userId: {}", userId);
            //从日志原始数据中获取每人每个项目每天工时。
            List<ChuanyunWorkHourDO> selfList = chuanyunWorkHourDao.getSelfWorkHour(userId);
            this.generateSelfWorkHourByWorkHourList(selfList);
        } else {
            log.warn("用户信息中userId缺失");
        }
    }

    /**
     * 根据用户Id标准化某个人所有的周工时
     *
     * @param userId 用户Id
     */
    public void standardAllWeekMemberHourByUserId(String userId) {
        if (!StringUtils.hasLength(userId)) {
            long start = Instant.now().getEpochSecond();
            //更新数据库
            List<ChuanyunWeekMemberHourDO> list = chuanyunWeekMemberHourDao.getWeekMemberHourByUserId(userId);
            this.generateWeekMemberHourByWeekMemberHourList(list);
            log.info(userId + "统一周工时标准化" + (Instant.now().getEpochSecond() - start) + "秒");
        } else {
            log.warn("用户信息中userId缺失");
        }
    }

    /**
     * 根据用户Id标准化某个人一年内的周工时
     *
     * @param userId 用户Id
     */
    public void standardWeekMemberHourByUserId(String userId) {
        if (!StringUtils.isEmpty(userId)) {
            long start = Instant.now().getEpochSecond();
            //更新数据库
            List<ChuanyunWeekMemberHourDO> list = chuanyunWeekMemberHourDao.getOneYearAgoWeekMemberHourByUserId(userId);
            this.generateWeekMemberHourByWeekMemberHourList(list);
            log.info(userId + "统一周工时标准化" + (Instant.now().getEpochSecond() - start) + "秒");
        } else {
            log.warn("用户信息中userId缺失");
        }
    }

    /**
     * 根据用户Id标准化某个人的月工时
     * 1.删除审核中的月工时
     * 2.将新工时数据保存在manatee中
     *
     * @param userId 用户Id
     */
    public void standardSelfCostByUserId(String userId) {
        long start = Instant.now().getEpochSecond();
        //删除上一次状态为审核中，但本次已经审核通过的数据
        chuanyunSelfCostDao.findAllByStatusAndUserId(ChuanYunConstant.IN_PROCESS, userId).forEach(chuanyunSelfCostDO -> {
            List<ChuanyunSelfWorkHourDO> chuanyunSelfWorkHourList = chuanyunSelfWorkHourDao.findAllByUserIdAndProjectIdAndProjectTypeAndStatusAndDayLogDateBetween(
                    chuanyunSelfCostDO.getUserId(),
                    chuanyunSelfCostDO.getProjectId(),
                    chuanyunSelfCostDO.getProjectType(),
                    ChuanYunConstant.IN_PROCESS,
                    chuanyunSelfCostDO.getDayLogDate(),
                    chuanyunSelfCostDO.getDayLogDate().plusMonths(1L));
            //如果没有仍在审批中的每日工时，则将该月、该项目的审核中的月工时统计删除，manatee数据库与氚云
            if (chuanyunSelfWorkHourList.size() == 0) {
                //删除manatee中的在审核工时
                chuanyunSelfCostDao.delete(chuanyunSelfCostDO);
                dataArcherService.deleteSelfCostInProcess(chuanyunSelfCostDO);
            }
        });

        // 获取单人月度各项目总工时
//        List<ChuanyunSelfWorkHourDO> userAllSelfWorkHours = chuanyunSelfWorkHourDao.findByUserId(userId);
        // 修改为获取一年内的记录
        // 获取一年前的时间节点
//        LocalDateTime aYearAgo = LocalDateTime.now().minusYears(1);
//        List<ChuanyunSelfWorkHourDO> userAllSelfWorkHours = chuanyunSelfWorkHourDao.findByUserIdAndDayLogDateAfter(userId, aYearAgo);
        List<ChuanyunSelfWorkHourDO> userAllSelfWorkHours = chuanyunSelfWorkHourDao.findByUserId(userId);
        Map<LocalDate, Map<String, Map<String, Map<String, BigDecimal>>>> map = userAllSelfWorkHours.stream().filter(selfWorkHourDO ->
                StringUtils.hasLength(selfWorkHourDO.getProjectId()) &&
                        StringUtils.hasLength(selfWorkHourDO.getProjectType()) &&
                        StringUtils.hasLength(selfWorkHourDO.getStatus()) &&
                        selfWorkHourDO.getStandardWorkHour() != null &&
                        selfWorkHourDO.getDayLogDate() != null).collect(
                Collectors.groupingBy(chuanyunSelfWorkHourDO -> LocalDate.of(chuanyunSelfWorkHourDO.getDayLogDate().getYear(), chuanyunSelfWorkHourDO.getDayLogDate().getMonth(), 1),
                        Collectors.groupingBy(ChuanyunSelfWorkHourDO::getProjectId,
                                Collectors.groupingBy(ChuanyunSelfWorkHourDO::getProjectType,
                                        Collectors.groupingBy(ChuanyunSelfWorkHourDO::getStatus, Collectors.reducing(BigDecimal.ZERO, ChuanyunSelfWorkHourDO::getStandardWorkHour, BigDecimal::add)
                                        )))));


        // 每月每项目工时,按月-项目-用户分组统计标准工时
        // List<ChuanyunSelfWorkHourDO> list = chuanyunSelfWorkHourDao.getMonthProjectHour(userId);
        ArrayList<ChuanyunSelfWorkHourDO> list1 = new ArrayList<>();
        map.forEach((localDate, projectIdMapMap) ->
                projectIdMapMap.forEach((projectId, projectTypeMapMap) ->
                        projectTypeMapMap.forEach((projectType, statusBigDecimalMap) ->
                                statusBigDecimalMap.forEach((status, standardWorkHour) -> {
                                    ChuanyunSelfWorkHourDO chuanyunSelfWorkHourDO = new ChuanyunSelfWorkHourDO();
                                    chuanyunSelfWorkHourDO.setStandardWorkHour(standardWorkHour);
                                    chuanyunSelfWorkHourDO.setStatus(status);
                                    chuanyunSelfWorkHourDO.setProjectId(projectId);
                                    // 设置项目类型
                                    chuanyunSelfWorkHourDO.setProjectType(projectType);
                                    chuanyunSelfWorkHourDO.setDayLogDate(localDate.atStartOfDay());
                                    chuanyunSelfWorkHourDO.setUserId(userId);
                                    list1.add(chuanyunSelfWorkHourDO);
                                }))));

        list1.forEach(projectMonth -> {
            ChuanyunSelfCostDO chuanyunSelfCostDO = this.fromChuanyunSelfWorkHourDO(projectMonth);
            //获取人员-月度-相同工时状态标准工时汇总
            ChuanyunSelfCostDO oldSelfDO = chuanyunSelfCostDao.getOldSelfDO(userId,
                    projectMonth.getProjectId(),
                    projectMonth.getProjectType(),
                    df.format(projectMonth.getDayLogDate()),
                    projectMonth.getStatus());
            if (oldSelfDO != null) {
                chuanyunSelfCostDao.delete(oldSelfDO);
            }
            chuanyunSelfCostDao.saveAndFlush(chuanyunSelfCostDO);
        });
        log.info(userId + "统一月工时标准化" + (Instant.now().getEpochSecond() - start) + "秒");
    }

    /**
     * 根据日工时列表生成
     *
     * @param updateList 待更新列表
     */
    private void generateSelfWorkHourByWorkHourList(List<ChuanyunWorkHourDO> updateList) {
        //逐一将原始工时数据标准化后，更新到标准化工时表和氚云中
        updateList.parallelStream().forEach(self -> {
            try {
                //新建标准化工时对象，并将原始数据更新到此对象中，并计算标准化之后的工时
                ChuanyunSelfWorkHourDO chuanyunSelfWorkHourDO = this.fromChuanyunWorkHourDO(self);
                // 设置工作组和子工作组
                String workGroupId = self.getWorkGroupId();
                if (!Objects.isNull(workGroupId) && !workGroupId.isBlank()) {

                    ChuanyunWorkGroupDO workGroupDO = workGroupService.findByObjectId(workGroupId);
                    if (!Objects.isNull(workGroupDO)) {
                        chuanyunSelfWorkHourDO.setWorkGroupName(workGroupDO.getWorkGroupName());
                        chuanyunSelfWorkHourDO.setSubWorkGroupName(workGroupDO.getSubWorkGroup());
                    } else {
                        // 从历史数据中查找
                        ChuanyunHistoryWorkGroupDO historyWorkGroup = workGroupService.findInHistoryByObjectId(workGroupId);
                        if (!Objects.isNull(historyWorkGroup)) {
                            chuanyunSelfWorkHourDO.setWorkGroupName(historyWorkGroup.getWorkGroupName());
                            chuanyunSelfWorkHourDO.setSubWorkGroupName(historyWorkGroup.getSubWorkGroup());
                        }

                    }

                }
                //查询系统中是否有重复的标准化工时数据，如果有重复的人、天、项目数据，将原数据删除后更新为最新的数据
                try {
                    List<ChuanyunSelfWorkHourDO> list;
                    if (self.getStatus().equals("3")) {
                        list = chuanyunSelfWorkHourDao.findByUserIdAndProjectIdAndDayLogDateAndProjectTypeAndStatus(chuanyunSelfWorkHourDO.getUserId(), ChuanYunConstant.PRODUCTION_PROJECT.equals(self.getProjectType()) ? ChuanYunConstant.PRODUCTION_PROJECT_ID : self.getProjectId(), self.getDayLogDate(), self.getProjectType(), self.getStatus());
                    } else {
                        list = chuanyunSelfWorkHourDao.findByUserIdAndProjectIdAndDayLogDateAndProjectType(chuanyunSelfWorkHourDO.getUserId(), ChuanYunConstant.PRODUCTION_PROJECT.equals(self.getProjectType()) ? ChuanYunConstant.PRODUCTION_PROJECT_ID : self.getProjectId(), self.getDayLogDate(), self.getProjectType());
                    }
                    if (list != null && list.size() > 0) {
                        chuanyunSelfWorkHourDao.deleteAll(list);
                    }
                    chuanyunSelfWorkHourDao.saveAndFlush(chuanyunSelfWorkHourDO);
                } catch (Exception e) {
                    log.error(e.getMessage());
                }
            } catch (Exception e) {
                log.error(e.getMessage());
                log.error("" + self);
            }
        });
    }

    /**
     * 根据周工时列表
     *
     * @param updateList 待更新的周工时列表
     */
    private void generateWeekMemberHourByWeekMemberHourList(List<ChuanyunWeekMemberHourDO> updateList) {
        updateList.forEach(chuanyunWeekMemberHourDO -> {
            try {
                if (chuanyunWeekMemberHourDO != null) {
                    ChuanyunWeekMemberHourDO weekMemberHourDO = ChuanyunWeekMemberHourDO.fromChuanyunWeekMemberHourDO(chuanyunWeekMemberHourDO);
                    ChuanyunWeekMemberHourDO oldWeekHour = chuanyunWeekMemberHourDao.findByProjectIdAndUserIdAndWeekAndStatusAndProjectTypeAndYear(chuanyunWeekMemberHourDO.getProjectId(), chuanyunWeekMemberHourDO.getUserId(), chuanyunWeekMemberHourDO.getWeek(), chuanyunWeekMemberHourDO.getStatus(), chuanyunWeekMemberHourDO.getProjectType(), chuanyunWeekMemberHourDO.getYear());
                    if (oldWeekHour != null) {
                        chuanyunWeekMemberHourDao.delete(oldWeekHour);
                    }
                    chuanyunWeekMemberHourDao.saveAndFlush(weekMemberHourDO);
                    //搜索是否还有处于审批中的数据
                    ChuanyunWeekMemberHourDO processWeekHour = chuanyunWeekMemberHourDao.getProcessWeekHour(chuanyunWeekMemberHourDO.getProjectId(), chuanyunWeekMemberHourDO.getUserId(), chuanyunWeekMemberHourDO.getYear(), chuanyunWeekMemberHourDO.getWeek(), chuanyunWeekMemberHourDO.getProjectType());

                    if (processWeekHour == null) {
                        chuanyunWeekMemberHourDao.deleteByProjectIdAndUserIdAndYearAndWeekAndStatusAndProjectType(chuanyunWeekMemberHourDO.getProjectId(), chuanyunWeekMemberHourDO.getUserId(), chuanyunWeekMemberHourDO.getYear(), chuanyunWeekMemberHourDO.getWeek(), "2", chuanyunWeekMemberHourDO.getProjectType());
                        //同时删除氚云钟数据
                        dataArcherService.deleteExamineStatus(ChuanyunProjectMemberWeekHourDO.SCHEMA_CODE, "F0000007", "F0000001", chuanyunWeekMemberHourDO.getProjectId(), "F0000002", chuanyunWeekMemberHourDO.getUserId(), "F0000008", chuanyunWeekMemberHourDO.getYear(), "", "", "F0000006", chuanyunWeekMemberHourDO.getWeek(), "F0000003", chuanyunWeekMemberHourDO.getProjectType());
                    }
                }
            } catch (Exception e) {
                log.error("chuanyunWeekMemberHourDO: {}", chuanyunWeekMemberHourDO);
                log.error(e.getMessage() + "周工时标准化异常");
            }
        });
    }

    /**
     * 根据日志原始数据统计的每日每人工时获取工时标准化后的标准化对象
     *
     * @param chuanyunWorkHourDO 日志原始统计数据
     * @return 工时标准化对象
     */
    private ChuanyunSelfWorkHourDO fromChuanyunWorkHourDO(ChuanyunWorkHourDO chuanyunWorkHourDO) throws Exception {
        //由于日志原始工时可能存在项目类型不准确的情况，需要根据项目ID获取真实的项目类型
        String projectType;
        String projectCode = null;
        try {
            var chuanyunGroupProject = chuanyunGroupProjectDao.findByObjectId(chuanyunWorkHourDO.getProjectId());
            if (chuanyunGroupProject == null) {
                log.info("没有找到该项目");
                // 查询总况表中的数据
                Optional<ChuanyunProjectDO> projectDO = chuanyunProjectDao.findById(chuanyunWorkHourDO.getProjectId());
                if (projectDO.isPresent()){
                    projectCode = projectDO.get().getProjectCode();
                    ChuanyunGroupProjectDO projectByCode = chuanyunGroupProjectDao.findByProjectCode(projectCode);
                    projectType = projectByCode.getProjectType();
                }else {
                    throw new Exception("没有找到对应的项目");
                }
            }else {
                //如果找到相应的项目，则使用项目实际的项目类型
                projectType = chuanyunGroupProject.getProjectType();
                projectCode = chuanyunGroupProject.getProjectCode();
            }
        } catch (Exception e) {
            //没有找到对应项目，使用原项目类型
            projectType = chuanyunWorkHourDO.getProjectType();
        }

        ChuanyunSelfWorkHourDO chuanyunSelfWorkHourDO = ChuanyunSelfWorkHourDO.fromChuanyunWorkHourDO(chuanyunWorkHourDO, projectType);
        if (projectCode != null) {
            chuanyunSelfWorkHourDO.setProjectCode(projectCode);
        }
        //获取每人每天总工时
//        ChuanyunWorkHourDO oneDayTotalHour = chuanyunWorkHourDao.getDayWorkHour(chuanyunWorkHourDO.getUserId(), chuanyunWorkHourDO.getDayLogDate());

        // 获取每天总工时
//        ChuanyunWorkHourDO oneDayTotalHour = chuanyunWorkHourDao.getOneDayTotalHour(chuanyunWorkHourDO.getUserId(), chuanyunWorkHourDO.getDayLogDate());
        ChuanyunWorkHourDO oneDayTotalHour = workHourMapper.selectByUserIdAndDayLogDate(chuanyunWorkHourDO.getUserId(), chuanyunWorkHourDO.getDayLogDate());

        //工时标准化
        if (oneDayTotalHour != null) {
            BigDecimal hoursWorked = oneDayTotalHour.getHoursWorked();
            if (hoursWorked.compareTo(BigDecimal.ZERO) == 0) {
                throw new Exception("每日工时为0");
            }
            BigDecimal standard = new BigDecimal("8.00");
            if (hoursWorked.compareTo(standard) <= 0) {
                chuanyunSelfWorkHourDO.setStandardWorkHour(chuanyunWorkHourDO.getHoursWorked());
            } else {
                BigDecimal worked = chuanyunWorkHourDO.getHoursWorked();
                BigDecimal divide = worked.divide(hoursWorked, 2, RoundingMode.HALF_UP);
                BigDecimal personDays = divide.multiply(standard);
                chuanyunSelfWorkHourDO.setStandardWorkHour(personDays);
            }
        } else {
            throw new Exception("获取每日总工时失败");
        }
        //获取人员所属BG
        if (StringUtils.isEmpty(chuanyunWorkHourDO.getBgName())) {
            List<ChuanyunSelfWorkHourDO> list = chuanyunSelfWorkHourDao.findByUserIdAndProjectIdAndDayLogDateAndProjectType(chuanyunWorkHourDO.getUserId(), chuanyunWorkHourDO.getProjectId(), chuanyunWorkHourDO.getDayLogDate(), chuanyunWorkHourDO.getProjectType());
            if (!Objects.isNull(list) && !list.isEmpty()) {
                chuanyunSelfWorkHourDO.setBg(list.get(0).getBg());
            }
        } else {
            chuanyunSelfWorkHourDO.setBg(chuanyunWorkHourDO.getBgName());
        }
        return chuanyunSelfWorkHourDO;
    }

    /**
     * 根据ChuanyunSelfWorkHourDO获取ChuanyunSelfCostDO对象
     *
     * @param chuanyunSelfWorkHourDO 统计月工时对象
     * @return 待保存的月工时对象
     */
    private ChuanyunSelfCostDO fromChuanyunSelfWorkHourDO(ChuanyunSelfWorkHourDO chuanyunSelfWorkHourDO) {

        ChuanyunSelfCostDO chuanyunSelfCostDO = new ChuanyunSelfCostDO();
        chuanyunSelfCostDO.setStatus(chuanyunSelfWorkHourDO.getStatus());
        if (chuanyunSelfWorkHourDO.getStandardWorkHour() != null) {
            chuanyunSelfCostDO.setMonthlyTotalHour(chuanyunSelfWorkHourDO.getStandardWorkHour());
        }
        chuanyunSelfCostDO.setProjectId(chuanyunSelfWorkHourDO.getProjectId());
        chuanyunSelfCostDO.setProjectType(chuanyunSelfWorkHourDO.getProjectType());
        chuanyunSelfCostDO.setUserId(chuanyunSelfWorkHourDO.getUserId());
        chuanyunSelfCostDO.setDayLogDate(chuanyunSelfWorkHourDO.getDayLogDate().withDayOfMonth(1));
        chuanyunSelfCostDO.setTotalHour(chuanyunSelfWorkHourDO.getStandardWorkHour());
        Optional<ChuanyunUserCompanyDO> chuanyunUserCompanyDO = chuanyunUserCompanyDao.findAllByUserIdOrderByModifiedTimeDesc(chuanyunSelfWorkHourDO.getUserId()).stream().findFirst();
        chuanyunUserCompanyDO.ifPresent(userCompanyDO -> chuanyunSelfCostDO.setDepartmentId(userCompanyDO.getDepartmentId()));
        return chuanyunSelfCostDO;
    }

    /**
     * 标准化半年内每日工时
     */
    public void standardHalfYearWorkHour() {
//        chuanyunUserCompanyDao.findAll().parallelStream().forEach(chuanyunUserCompanyDO -> this.standardHalfYearDayWorkHour(chuanyunUserCompanyDO.getUserId()));
        List<String> userIdList = chuanyunUserCompanyDao.findAll().stream().map(ChuanyunUserCompanyDO::getUserId).collect(Collectors.toList());
        List<String> distinctUserIdList = userIdList.stream().distinct().collect(Collectors.toList());
        distinctUserIdList.parallelStream().forEach(this::standardHalfYearDayWorkHour);
    }

    public void standardHalfYearWorkHourByUserId(String userId) {
        this.standardHalfYearDayWorkHour(userId);
    }

    /**
     * 标准化半年内日志
     *
     * @param userId 用户id
     */
    private void standardHalfYearDayWorkHour(String userId) {
        //逐一将原始工时数据标准化后，更新到标准化工时表和氚云中
        log.info("标准化用户日工时 userId: {}", userId);
        List<ChuanyunWorkHourDO> halfYearSelfWorkHour = chuanyunWorkHourDao.getHalfYearSelfWorkHour(userId);
        halfYearSelfWorkHour.forEach(self -> {
            try {
                //新建标准化工时对象，并将原始数据更新到此对象中，并计算标准化之后的工时
                ChuanyunSelfWorkHourDO chuanyunSelfWorkHourDO = this.fromChuanyunWorkHourDO(self);
                // 设置工作组和子工作组
                String workGroupId = self.getWorkGroupId();
                if (!Objects.isNull(workGroupId) && !workGroupId.isBlank()) {

                    ChuanyunWorkGroupDO workGroupDO = workGroupService.findByObjectId(workGroupId);
                    if (!Objects.isNull(workGroupDO)) {
                        chuanyunSelfWorkHourDO.setWorkGroupName(workGroupDO.getWorkGroupName());
                        chuanyunSelfWorkHourDO.setSubWorkGroupName(workGroupDO.getSubWorkGroup());
                    } else {
                        // 从历史数据中查找
                        ChuanyunHistoryWorkGroupDO historyWorkGroup = workGroupService.findInHistoryByObjectId(workGroupId);
                        if (!Objects.isNull(historyWorkGroup)) {
                            chuanyunSelfWorkHourDO.setWorkGroupName(historyWorkGroup.getWorkGroupName());
                            chuanyunSelfWorkHourDO.setSubWorkGroupName(historyWorkGroup.getSubWorkGroup());
                        }

                    }

                }
                //查询系统中是否有重复的标准化工时数据，如果有重复的人、天、项目数据，将原数据删除后更新为最新的数据
                try {
                    List<ChuanyunSelfWorkHourDO> list;
                    if (self.getStatus().equals("3")) {
                        list = chuanyunSelfWorkHourDao.findByUserIdAndProjectIdAndDayLogDateAndProjectTypeAndStatus(chuanyunSelfWorkHourDO.getUserId(), ChuanYunConstant.PRODUCTION_PROJECT.equals(self.getProjectType()) ? ChuanYunConstant.PRODUCTION_PROJECT_ID : self.getProjectId(), self.getDayLogDate(), self.getProjectType(), self.getStatus());
                    } else {
                        list = chuanyunSelfWorkHourDao.findByUserIdAndProjectIdAndDayLogDateAndProjectType(chuanyunSelfWorkHourDO.getUserId(), ChuanYunConstant.PRODUCTION_PROJECT.equals(self.getProjectType()) ? ChuanYunConstant.PRODUCTION_PROJECT_ID : self.getProjectId(), self.getDayLogDate(), self.getProjectType());
                    }
                    if (list != null && list.size() > 0) {
                        chuanyunSelfWorkHourDao.deleteAll(list);
                    }
                    chuanyunSelfWorkHourDao.saveAndFlush(chuanyunSelfWorkHourDO);
                } catch (Exception e) {
                    log.error(e.getMessage());
                }
            } catch (Exception e) {
                log.error(e.getMessage());
                log.error("" + self);
                e.printStackTrace();
            }
        });
        log.info("标准化用户日工时完成 userId: {}", userId);
    }

}