九鸿：工资表按客户口径重构 + 修复考勤汇总生成、新增节假日报错

gaoluyang

2026-11-04 f81b963f9d1b7d4757446970830cb72264c6dc0c

 yudao-module-hrm/src/main/java/cn/iocoder/yudao/module/hrm/service/salary/HrmSalaryCalculationServiceImpl.java

@@ -6,6 +6,7 @@
import cn.iocoder.yudao.module.hrm.controller.admin.salary.vo.HrmSalaryCalculationPageReqVO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.approval.HrmLeaveApplicationDO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.approval.HrmOvertimeApplicationDO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.attendance.HrmAttendanceRecordDO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.attendance.HrmEmployeeScheduleDO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.attendance.HrmShiftDO;
import cn.iocoder.yudao.module.hrm.dal.dataobject.employee.HrmEmployeeDO;
@@ -21,6 +22,7 @@
import cn.iocoder.yudao.module.hrm.dal.mysql.attendance.HrmEmployeeScheduleMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.attendance.HrmShiftMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.approval.HrmOvertimeApplicationMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.attendance.HrmAttendanceRecordMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.employee.HrmEmployeeMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.salary.HrmEmployeeSalaryMapper;
import cn.iocoder.yudao.module.hrm.dal.mysql.salary.HrmEmployeeSocialSecurityMapper;
@@ -32,6 +34,7 @@
import cn.iocoder.yudao.module.hrm.dal.mysql.salary.HrmSalaryStructureMapper;
import cn.iocoder.yudao.module.hrm.dal.redis.HrmNoRedisDAO;
import cn.iocoder.yudao.module.system.api.dept.DeptApi;
import cn.iocoder.yudao.module.hrm.enums.HrmAttendanceClockTypeEnum;
import cn.iocoder.yudao.module.hrm.enums.HrmOvertimeTypeEnum;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
@@ -110,6 +113,8 @@
    private HrmEmployeeScheduleMapper employeeScheduleMapper;
    @Resource
    private HrmShiftMapper shiftMapper;
    @Resource
    private HrmAttendanceRecordMapper attendanceRecordMapper;

    @Override
    public PageResult<HrmSalaryCalculationDO> getSalaryCalculationPage(HrmSalaryCalculationPageReqVO pageReqVO) {
@@ -235,17 +240,65 @@
        BigDecimal mealAllowance = employeeSalary.getMealAllowance() != null ? employeeSalary.getMealAllowance() : BigDecimal.ZERO;
        BigDecimal transportAllowance = employeeSalary.getTransportAllowance() != null ? employeeSalary.getTransportAllowance() : BigDecimal.ZERO;
        BigDecimal otherAllowance = employeeSalary.getOtherAllowance() != null ? employeeSalary.getOtherAllowance() : BigDecimal.ZERO;
        OvertimeSalary overtimeSalary = calculateOvertimeSalary(employee, employeeSalary, period, baseSalary);
        BigDecimal overtimePay = overtimeSalary.pay();

        // 按排班累计出勤天数与排班总工时（无排班时出勤天数回退默认 22）
        // ========== 九泓工资表：标准项取自员工档案 ==========
        BigDecimal standardSalary = nvl(employee.getStandardSalary());
        BigDecimal postSalary = nvl(employee.getPostSalary());
        BigDecimal overtimeHourlyRate = employee.getOvertimeHourlyRate();
        BigDecimal safetyAwardStandard = nvl(employee.getSafetyAwardStandard());
        BigDecimal performanceStandard = nvl(employee.getPerformanceStandard());
        // 标准工资未单独维护时，按「基本工资 + 岗位工资」合成
        if (standardSalary.signum() == 0 && (baseSalary.signum() > 0 || postSalary.signum() > 0)) {
            standardSalary = baseSalary.add(postSalary);
        }

        // 按排班累计应出勤天数与标准工时（无排班时回退 22 天 × 8 小时）
        ScheduleStat scheduleStat = calculateScheduleStat(employeeId, period);
        Integer workDays = scheduleStat.scheduledDays() > 0 ? scheduleStat.scheduledDays() : 22;
        BigDecimal totalWorkHours = scheduleStat.totalWorkHours();
        BigDecimal standardWorkHours = scheduleStat.scheduledDays() > 0
                ? scheduleStat.totalWorkHours()
                : BigDecimal.valueOf(workDays).multiply(BigDecimal.valueOf(8));

        // 应发工资总额
        BigDecimal totalIncome = baseSalary.add(performanceSalary).add(mealAllowance)
                .add(transportAllowance).add(otherAllowance).add(overtimePay);
        // 计薪出勤 = 标准出勤天数 - 缺勤天数（考勤记录中缺卡的天数，按天去重）
        int absentDays = countAbsentDays(employeeId, period);
        BigDecimal paidAttendanceDays = BigDecimal.valueOf(Math.max(workDays - absentDays, 0));

        // 加班工资 / 法定假工资（加班工资标准为空时回退到 基本工资 / 21.75 / 8 × 倍率）
        OvertimeSalary overtimeSalary = calculateOvertimeSalary(employee, employeeSalary, period, baseSalary, overtimeHourlyRate);
        BigDecimal overtimeHours = overtimeSalary.hours();
        BigDecimal overtimePay = overtimeSalary.pay();
        BigDecimal legalHolidayHours = overtimeSalary.legalHolidayHours();
        BigDecimal legalHolidayPay = overtimeSalary.legalHolidayPay();

        // 出勤折算比例，用于按实际计薪出勤折算标准项
        BigDecimal attendanceRatio = workDays > 0
                ? paidAttendanceDays.divide(BigDecimal.valueOf(workDays), 6, RoundingMode.HALF_UP)
                : BigDecimal.ZERO;
        BigDecimal standardAttendancePay = standardSalary.multiply(attendanceRatio).setScale(2, RoundingMode.HALF_UP);
        BigDecimal safetyAward = safetyAwardStandard.multiply(attendanceRatio).setScale(2, RoundingMode.HALF_UP);
        BigDecimal floatingPerformancePay = performanceStandard.multiply(attendanceRatio).setScale(2, RoundingMode.HALF_UP);

        // 应付工资 = 标准出勤工资 + 加班工资 + 法定假工资 + 安全环保奖 + 浮动绩效工资
        BigDecimal payableSalary = standardAttendancePay.add(overtimePay).add(legalHolidayPay)
                .add(safetyAward).add(floatingPerformancePay);

        // 加项（工龄工资/夜班补助/学历补贴/体检/优秀员工奖/其他补助/部门绩效）与扣项
        // （漏打卡/迟到早退/其他扣款）生成时默认为 0，核算页可手工调整后保存
        BigDecimal seniorityPay = BigDecimal.ZERO;
        BigDecimal nightShiftAllowance = BigDecimal.ZERO;
        BigDecimal educationAllowance = BigDecimal.ZERO;
        BigDecimal healthCheckAllowance = BigDecimal.ZERO;
        BigDecimal excellentEmployeeAward = BigDecimal.ZERO;
        BigDecimal otherSubsidy = BigDecimal.ZERO;
        BigDecimal deptPerformance = BigDecimal.ZERO;
        BigDecimal additionTotal = BigDecimal.ZERO;
        BigDecimal missedPunchDeduction = BigDecimal.ZERO;
        BigDecimal lateEarlyDeduction = BigDecimal.ZERO;
        BigDecimal deductionTotal = BigDecimal.ZERO;

        // 计税口径：应付工资 + 加项合计 - 扣款合计
        BigDecimal totalIncome = payableSalary.add(additionTotal).subtract(deductionTotal);

        // 获取社保基数：员工社保档案 > 方案默认缴费基数 > 员工基本工资
        BigDecimal socialSecurityBase = (socialSecurity != null && socialSecurity.getSocialSecurityBase() != null)
@@ -284,8 +337,8 @@
        // 公积金扣除 = 基数 × 公积金个人比例
        BigDecimal housingFundDeduction = housingFundBase.multiply(housingFundPersonalRatio).setScale(2, RoundingMode.HALF_UP);

        // 计算请假扣款
        BigDecimal leaveDeduction = calculateLeaveDeduction(employee, period, baseSalary);
        // 请假扣款：新版工资表按「计薪出勤」折减标准出勤工资，不再单独重复扣一次，保留字段兼容旧数据
        BigDecimal leaveDeduction = BigDecimal.ZERO;

        // 计算个税扣除
        // 应纳税所得额 = 应发工资 - 社保扣除 - 公积金扣除 - 起征点(5000)
@@ -301,15 +354,43 @@

        BigDecimal otherDeduction = BigDecimal.ZERO;

        // 计算实发工资 = 应发 - 扣除
        BigDecimal totalDeduction = socialSecurityDeduction.add(housingFundDeduction)
                .add(taxDeduction).add(otherDeduction).add(leaveDeduction);
        BigDecimal actualSalary = totalIncome.subtract(totalDeduction);
        // 税后工资 = 应付工资 + 加项合计 - 扣款合计 - 社保 - 公积金 - 个税
        BigDecimal actualSalary = payableSalary.add(additionTotal).subtract(deductionTotal)
                .subtract(socialSecurityDeduction).subtract(housingFundDeduction)
                .subtract(taxDeduction);

        return HrmSalaryCalculationDO.builder()
                .period(period)
                .userId(employeeId) // 使用员工ID
                .deptId(employee.getDeptId())
                // 九泓工资表：标准项
                .standardSalary(standardSalary)
                .postSalary(postSalary)
                .overtimeHourlyRate(overtimeHourlyRate)
                .safetyAwardStandard(safetyAwardStandard)
                .performanceStandard(performanceStandard)
                // 九泓工资表：出勤与计薪
                .paidAttendanceDays(paidAttendanceDays)
                .standardWorkHours(standardWorkHours)
                .legalHolidayHours(legalHolidayHours)
                .standardAttendancePay(standardAttendancePay)
                .legalHolidayPay(legalHolidayPay)
                .safetyAward(safetyAward)
                .floatingPerformancePay(floatingPerformancePay)
                .payableSalary(payableSalary)
                // 九泓工资表：加项 / 扣项
                .seniorityPay(seniorityPay)
                .nightShiftAllowance(nightShiftAllowance)
                .educationAllowance(educationAllowance)
                .healthCheckAllowance(healthCheckAllowance)
                .excellentEmployeeAward(excellentEmployeeAward)
                .otherSubsidy(otherSubsidy)
                .deptPerformance(deptPerformance)
                .additionTotal(additionTotal)
                .missedPunchDeduction(missedPunchDeduction)
                .lateEarlyDeduction(lateEarlyDeduction)
                .deductionTotal(deductionTotal)
                // 兼容旧字段
                .baseSalary(baseSalary)
                .performanceSalary(performanceSalary)
                .overtimePay(overtimePay)
@@ -323,7 +404,7 @@
                .leaveDeduction(leaveDeduction)
                .actualSalary(actualSalary)
                .workDays(workDays) // 按排班累计应出勤天数，无排班时回退 22
                .overtimeHours(overtimeSalary.hours())
                .overtimeHours(overtimeHours)
                .totalWorkHours(totalWorkHours)
                .status(0) // 待确认
                .build();
@@ -406,19 +487,24 @@
    }

    /**
     * 汇总当月审批通过的加班申请。小时工资按基本工资 / 21.75 / 8 计算；
     * 工作日默认 1.5 倍、休息日默认 2 倍、法定节假日默认 3 倍，均可由薪酬结构覆盖。
     * 汇总当月审批通过的加班申请。
     *
     * 员工档案维护了「加班工资标准（元/小时）」时：加班工资 = 加班时长 × 单价，
     * 法定假工资 = 法定假日时长 × 单价 × 法定节假日倍率（默认 3）。
     * 未维护单价时回退旧口径：基本工资 / 21.75 / 8 × 各类型倍率。
     *
     * 法定节假日加班单独统计，不计入「加班时长」列，避免与「法定假工资」重复计薪。
     */
    private OvertimeSalary calculateOvertimeSalary(HrmEmployeeDO employee, HrmEmployeeSalaryDO employeeSalary,
                                                    String period, BigDecimal baseSalary) {
                                                    String period, BigDecimal baseSalary, BigDecimal overtimeHourlyRate) {
        if (employee.getUserId() == null) {
            return new OvertimeSalary(BigDecimal.ZERO, BigDecimal.ZERO);
            return OvertimeSalary.EMPTY;
        }
        YearMonth month = YearMonth.parse(period);
        List<HrmOvertimeApplicationDO> applications = overtimeApplicationMapper.selectApprovedByUserAndDateRange(
                employee.getUserId(), month.atDay(1), month.atEndOfMonth());
        if (CollUtil.isEmpty(applications)) {
            return new OvertimeSalary(BigDecimal.ZERO, BigDecimal.ZERO);
            return OvertimeSalary.EMPTY;
        }
        Long structureId = employeeSalary.getSalaryStructureId() != null
                ? employeeSalary.getSalaryStructureId() : employee.getSalaryStructureId();
@@ -429,29 +515,62 @@
                ? structure.getRestDayOvertimePayRatio() : HrmOvertimeTypeEnum.REST_DAY.getSalaryMultiplier();
        BigDecimal legalHolidayMultiplier = structure != null && structure.getLegalHolidayOvertimePayRatio() != null
                ? structure.getLegalHolidayOvertimePayRatio() : HrmOvertimeTypeEnum.LEGAL_HOLIDAY.getSalaryMultiplier();
        BigDecimal hourlySalary = baseSalary.divide(new BigDecimal("21.75"), 8, RoundingMode.HALF_UP)
        BigDecimal hourlySalary = overtimeHourlyRate != null && overtimeHourlyRate.signum() > 0
                ? overtimeHourlyRate
                : baseSalary.divide(new BigDecimal("21.75"), 8, RoundingMode.HALF_UP)
                .divide(new BigDecimal("8"), 8, RoundingMode.HALF_UP);
        BigDecimal totalHours = BigDecimal.ZERO;
        BigDecimal totalPay = BigDecimal.ZERO;
        BigDecimal legalHolidayHours = BigDecimal.ZERO;
        BigDecimal legalHolidayPay = BigDecimal.ZERO;
        for (HrmOvertimeApplicationDO application : applications) {
            BigDecimal hours = application.getDuration() == null ? BigDecimal.ZERO : application.getDuration();
            HrmOvertimeTypeEnum type = HrmOvertimeTypeEnum.valueOfType(application.getOvertimeType());
            if (type == null || hours.signum() <= 0) {
                continue;
            }
            BigDecimal multiplier = switch (type) {
                case WORKDAY -> workdayMultiplier;
                case REST_DAY -> restDayMultiplier;
                case LEGAL_HOLIDAY -> legalHolidayMultiplier;
            };
            if (type == HrmOvertimeTypeEnum.LEGAL_HOLIDAY) {
                legalHolidayHours = legalHolidayHours.add(hours);
                legalHolidayPay = legalHolidayPay.add(hourlySalary.multiply(hours).multiply(legalHolidayMultiplier));
                continue;
            }
            BigDecimal multiplier = type == HrmOvertimeTypeEnum.WORKDAY ? workdayMultiplier : restDayMultiplier;
            totalHours = totalHours.add(hours);
            totalPay = totalPay.add(hourlySalary.multiply(hours).multiply(multiplier));
        }
        return new OvertimeSalary(totalHours.setScale(1, RoundingMode.HALF_UP),
                totalPay.setScale(2, RoundingMode.HALF_UP));
                totalPay.setScale(2, RoundingMode.HALF_UP),
                legalHolidayHours.setScale(1, RoundingMode.HALF_UP),
                legalHolidayPay.setScale(2, RoundingMode.HALF_UP));
    }

    private record OvertimeSalary(BigDecimal hours, BigDecimal pay) {}
    /**
     * 统计当月考勤记录中缺卡的天数（同一日期多次缺卡只算一天）
     */
    private int countAbsentDays(Long employeeId, String period) {
        YearMonth month = YearMonth.parse(period);
        List<HrmAttendanceRecordDO> records = attendanceRecordMapper.selectListByUserIdAndDateBetween(
                employeeId, month.atDay(1), month.atEndOfMonth());
        if (CollUtil.isEmpty(records)) {
            return 0;
        }
        return (int) records.stream()
                .filter(record -> HrmAttendanceClockTypeEnum.MISSING.getType().equals(record.getClockInType())
                        || HrmAttendanceClockTypeEnum.MISSING.getType().equals(record.getClockOutType()))
                .map(HrmAttendanceRecordDO::getDate)
                .distinct()
                .count();
    }

    private static BigDecimal nvl(BigDecimal value) {
        return value == null ? BigDecimal.ZERO : value;
    }

    private record OvertimeSalary(BigDecimal hours, BigDecimal pay,
                                  BigDecimal legalHolidayHours, BigDecimal legalHolidayPay) {
        private static final OvertimeSalary EMPTY = new OvertimeSalary(
                BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO);
    }

    private record ScheduleStat(int scheduledDays, BigDecimal totalWorkHours) {}

@@ -594,6 +713,7 @@
    @Transactional(rollbackFor = Exception.class)
    public void saveSalaryCalculationList(List<HrmSalaryCalculationDO> calculationList) {
        for (HrmSalaryCalculationDO calculation : calculationList) {
            normalizeSalaryTotals(calculation);
            if (calculation.getId() == null) {
                // 新增记录，生成核算单号
                String no = noRedisDAO.generateSalaryCalculationNo();
@@ -611,6 +731,50 @@
    }

    /**
     * 保存前按九泓工资表口径重算合计，避免前端漏算或旧客户端传入不一致的合计值。
     *
     * 加项合计 = 工龄工资 + 夜班补助 + 学历补贴 + 体检 + 优秀员工奖 + 其他补助 + 部门绩效
     * 扣款合计 = 漏打卡 + 迟到早退 + 其他扣款
     * 税后工资 = 应付工资 + 加项合计 - 扣款合计 - 社保 - 公积金 - 个税
     *
     * 仅当本次记录带有「应付工资」时重算；只有旧字段的老数据保持原样，避免把未维护的新字段清成 0。
     */
    private void normalizeSalaryTotals(HrmSalaryCalculationDO calculation) {
        if (calculation.getPayableSalary() == null) {
            return;
        }
        // 应付工资 = 标准出勤工资 + 加班工资 + 法定假工资 + 安全环保奖 + 浮动绩效工资
        // 仅当本次记录带新版标准项时重算，避免旧数据（无这些列）被清零
        if (calculation.getStandardAttendancePay() != null) {
            calculation.setPayableSalary(nvl(calculation.getStandardAttendancePay())
                    .add(nvl(calculation.getOvertimePay()))
                    .add(nvl(calculation.getLegalHolidayPay()))
                    .add(nvl(calculation.getSafetyAward()))
                    .add(nvl(calculation.getFloatingPerformancePay()))
                    .setScale(2, RoundingMode.HALF_UP));
        }
        BigDecimal additionTotal = nvl(calculation.getSeniorityPay())
                .add(nvl(calculation.getNightShiftAllowance()))
                .add(nvl(calculation.getEducationAllowance()))
                .add(nvl(calculation.getHealthCheckAllowance()))
                .add(nvl(calculation.getExcellentEmployeeAward()))
                .add(nvl(calculation.getOtherSubsidy()))
                .add(nvl(calculation.getDeptPerformance()));
        BigDecimal deductionTotal = nvl(calculation.getMissedPunchDeduction())
                .add(nvl(calculation.getLateEarlyDeduction()))
                .add(nvl(calculation.getOtherDeduction()));
        calculation.setAdditionTotal(additionTotal.setScale(2, RoundingMode.HALF_UP));
        calculation.setDeductionTotal(deductionTotal.setScale(2, RoundingMode.HALF_UP));
        calculation.setActualSalary(calculation.getPayableSalary()
                .add(calculation.getAdditionTotal())
                .subtract(calculation.getDeductionTotal())
                .subtract(nvl(calculation.getSocialSecurityDeduction()))
                .subtract(nvl(calculation.getHousingFundDeduction()))
                .subtract(nvl(calculation.getTaxDeduction()))
                .setScale(2, RoundingMode.HALF_UP));
    }

    /**
     * 内部生成发放台账方法（供自动生成调用）
     */
    private void generatePaymentInternal(String period, List<HrmSalaryCalculationDO> calculationList) {