unis_hrms/app/services/lifecycle.py

412 lines
19 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

"""员工全生命周期服务。
把「入职建档 → 登记人事信息 → 发薪 → 异动 → 离职」这条主线上必须自动发生的
连带动作集中在这里,避免花名册新增、Offer 转档案、异动审批三个入口各写一套:
- ``onboard_employee`` : 入职时自动生成劳动合同 + 薪资标准 + 参保登记
- ``ensure_contract`` : 补齐当前有效劳动合同(幂等)
- ``ensure_salary_standard``: 补齐薪资标准(算薪引擎的必需前置条件)
- ``ensure_enrollment`` : 补齐五险一金参保登记
- ``close_resignation`` : 离职收尾(终止合同 / 停保 / 失效薪资标准 / 停用账号)
- ``apply_adjustment`` : 调薪生效(补全调前薪资,写入薪资标准并留痕)
"""
from __future__ import annotations
from datetime import date, timedelta
from decimal import Decimal
from typing import Any
from sqlalchemy import delete as sa_delete
from sqlalchemy import func, select, update as sa_update
from ..models.benefits import (BenefitRecord as BenefitRecord_, Enrollment, InsurancePlan,
LeaveBalance as LeaveBalance_, LeaveRequest as LeaveRequest_)
from ..models.employee import (
Employee,
EmployeeCertificate as EmployeeCertificate_,
EmployeeChange as EmployeeChange_,
EmployeeContract,
EmployeeDocument as EmployeeDocument_,
EmployeeEducation as EmployeeEducation_,
EmployeeFamily as EmployeeFamily_,
EmployeeSalaryAdjustment,
EmployeeWorkHistory as EmployeeWorkHistory_,
)
from ..models.org import JobLevel
from ..models.payroll import EmployeeSalary, Payslip as Payslip_, SalaryPlan
from ..models.rbac import RefreshToken, User
from ..models.recruitment import Candidate as Candidate_
from ..models.selfservice import (ProfileRequest as ProfileRequest_,
TaskReminder as TaskReminder_)
# 用工形式字典:正式 / 试用 / 实习 / 劳务 / 外包 / 兼职
# 实习、外包、兼职不签劳动合同也不缴五险一金;劳务只签劳务合同
INSURED_ENGAGE = (None, "", "正式", "试用")
CONTRACT_ENGAGE = (None, "", "正式", "试用", "劳务")
CONTRACT_TYPES = {"劳务": "劳务合同"}
def q2(value: Any) -> Decimal:
return Decimal(str(value if value is not None else 0)).quantize(Decimal("0.01"))
def _plus_months(day: date, months: int | None) -> date | None:
if not months or months <= 0:
return None
total = day.month - 1 + int(months)
year, month = day.year + total // 12, total % 12 + 1
return date(year, month, min(day.day, 28))
def _plus_years(day: date, years: float) -> date:
whole = max(int(years or 3), 1)
return date(day.year + whole, day.month, min(day.day, 28))
async def _single(session, stmt):
return (await session.execute(stmt)).scalars().first()
# --------------------------------------------------------------------- 劳动合同
def _probation_end(emp: Employee, start: date | None) -> date | None:
"""试用期到期日:已转正取转正日,否则按入职日 + 试用期月数推算。"""
if emp.regular_date:
return emp.regular_date
if emp.status != "probation" or not start:
return None
return _plus_months(start, emp.probation_months)
async def ensure_contract(session, emp: Employee, *, signed_by: str | None = None,
silent: bool = True) -> EmployeeContract | None:
"""员工缺少「当前有效」劳动合同时补一份首签合同(幂等)。"""
if emp.engage_form not in CONTRACT_ENGAGE:
return None
exists = await _single(session, select(EmployeeContract).where(
EmployeeContract.employee_id == emp.id, EmployeeContract.status == "active"))
if exists:
return None if silent else exists
start = emp.contract_start or emp.hire_date or date.today()
end = emp.contract_end
if not end and emp.contract_term_years:
end = _plus_years(start, float(emp.contract_term_years))
if not end and start:
end = _plus_years(start, 3)
# 导入历史花名册时,不能把多年前的到期日直接挂到「生效中」合同上。
# 按合同年限依次续到当前周期,保留一份当前有效合同,避免 H5 出现负数剩余天数。
term_years = max(int(emp.contract_term_years or 3), 1)
while end and end < date.today():
start = end + timedelta(days=1)
end = _plus_years(start, term_years)
count = (await session.execute(
select(func.count()).select_from(EmployeeContract)
.where(EmployeeContract.employee_id == emp.id))).scalar() or 0
contract_no = f"HT{emp.work_no}" if count == 0 else f"HT{emp.work_no}-R{count}"
contract = EmployeeContract(
employee_id=emp.id, contract_no=contract_no,
contract_type=CONTRACT_TYPES.get(emp.engage_form or "", "固定期限"),
start_date=start, end_date=end,
probation_end=_probation_end(emp, start),
status="active", signed_by=signed_by,
remark="入职自动生成" if emp.status == "probation" else "系统补齐",
)
session.add(contract)
emp.contract_start, emp.contract_end = start, end
await session.flush()
return contract
# --------------------------------------------------------------------- 薪资标准
async def _plan_id_for(session, emp: Employee) -> int | None:
"""按部门/职级挑一个启用的账套,找不到就退回最小 id 的启用账套。"""
grade = 3
if emp.job_level_id:
level = await session.get(JobLevel, emp.job_level_id)
grade = level.grade if level and level.grade else 3
plan = await _single(session, select(SalaryPlan).where(
SalaryPlan.is_active.is_(True), SalaryPlan.department_id == emp.department_id)
.order_by((SalaryPlan.job_level_id.is_(None)).desc(), SalaryPlan.id))
if plan is None:
plan = await _single(session, select(SalaryPlan).where(
SalaryPlan.is_active.is_(True), SalaryPlan.department_id.is_(None))
.order_by((SalaryPlan.job_level_id <= grade).desc(), SalaryPlan.id))
if plan is None:
plan = await _single(session, select(SalaryPlan).where(
SalaryPlan.is_active.is_(True)).order_by(SalaryPlan.id))
return plan.id if plan else None
async def ensure_salary_standard(session, emp: Employee, monthly_salary: float | None = None,
*, silent: bool = True) -> EmployeeSalary | None:
"""补齐员工薪资标准;已有生效标准时只补 base 缺省值。"""
std = await _single(session, select(EmployeeSalary).where(
EmployeeSalary.employee_id == emp.id, EmployeeSalary.is_active.is_(True)))
if std:
return None if silent else std
plan_id = await _plan_id_for(session, emp)
if plan_id is None:
return None
base = monthly_salary
if base is None:
base = (emp.custom_fields or {}).get("base_salary")
if base is None:
adj = await _single(session, select(EmployeeSalaryAdjustment).where(
EmployeeSalaryAdjustment.employee_id == emp.id,
EmployeeSalaryAdjustment.status == "approved").order_by(
EmployeeSalaryAdjustment.effective_date.desc(),
EmployeeSalaryAdjustment.id.desc()))
base = float(adj.after_amount) if adj and adj.after_amount else None
overrides: dict[str, float] = {}
if base:
base = float(base)
overrides = {"base_salary": round(base * 0.72 / 100) * 100,
"perf_salary": round(base * 0.28 / 100) * 100}
std = EmployeeSalary(employee_id=emp.id, plan_id=plan_id, overrides=overrides,
effective_date=emp.hire_date or date.today(),
special_deduction=None, is_active=True, remark="入职自动生成")
session.add(std)
await session.flush()
return std
# --------------------------------------------------------------------- 参保登记
async def ensure_enrollment(session, emp: Employee, monthly_salary: float | None = None,
*, silent: bool = True) -> Enrollment | None:
"""按默认参保方案补齐五险一金登记。"""
if emp.engage_form not in INSURED_ENGAGE:
return None
exists = await _single(session, select(Enrollment).where(
Enrollment.employee_id == emp.id, Enrollment.status == "active"))
if exists:
return None if silent else exists
plan = await _single(session, select(InsurancePlan).where(
InsurancePlan.is_active.is_(True)).order_by(InsurancePlan.is_default.desc(),
InsurancePlan.id))
if plan is None:
return None
base = monthly_salary or (emp.custom_fields or {}).get("base_salary") or 0
base = float(base)
if not base:
std = await _single(session, select(EmployeeSalary).where(
EmployeeSalary.employee_id == emp.id, EmployeeSalary.is_active.is_(True)))
if std and std.overrides:
base = float(sum(float(v or 0) for v in std.overrides.values()))
if not base:
# 未定薪的员工不自动参保,避免凭空生成社保成本
return None
social = min(max(base, float(plan.base_floor or 0)), float(plan.base_ceiling or base))
fund = min(max(base, float(plan.fund_base_floor or 0)), float(plan.fund_base_ceiling or base))
row = Enrollment(employee_id=emp.id, plan_id=plan.id, social_base=q2(social),
fund_base=q2(fund), start_date=emp.hire_date or date.today(),
end_date=None, status="active", include_in_payroll=True,
remark="入职自动参保")
session.add(row)
await session.flush()
return row
async def onboard_employee(session, emp: Employee, *, monthly_salary: float | None = None,
signed_by: str | None = None) -> dict[str, int | None]:
"""入职三件套:合同 + 薪资标准 + 参保(幂等,可在多处安全重复调用)。"""
await ensure_contract(session, emp, signed_by=signed_by)
std = await ensure_salary_standard(session, emp, monthly_salary)
enr = await ensure_enrollment(session, emp, monthly_salary)
return {"contract": 1, "salary_standard": std.id if std else None,
"enrollment": enr.id if enr else None}
# ------------------------------------------------------------------ 档案删除清理
# 随员工一起清理的子表(按 employee_id 归属)
OWNED_MODELS = (
EmployeeContract, EmployeeEducation_, EmployeeWorkHistory_, EmployeeFamily_,
EmployeeCertificate_, EmployeeDocument_, EmployeeChange_, EmployeeSalaryAdjustment,
EmployeeSalary, Enrollment, BenefitRecord_, LeaveBalance_, LeaveRequest_,
ProfileRequest_, TaskReminder_, Payslip_,
)
# 需要保留、但必须解除员工绑定的表
DETACH_MODELS = (User, Candidate_)
async def purge_employee_records(session, employee_id: int) -> dict:
"""删除员工档案时清理附属记录。
SQLite 默认不强制外键,直接删除员工会留下孤儿数据,而自增主键被新员工复用时
会让「幂等补齐」逻辑误判为新员工已有合同/薪资标准,因此必须显式级联清理。
工资条随员工删除后,所属批次的合计数不会自动重算(重新算薪即可对齐)。
"""
stats: dict[str, int] = {}
for model in OWNED_MODELS:
result = await session.execute(sa_delete(model).where(model.employee_id == employee_id))
if result.rowcount:
stats[model.__tablename__] = result.rowcount
for model in DETACH_MODELS:
await session.execute(sa_update(model).where(model.employee_id == employee_id)
.values(employee_id=None))
return stats
# --------------------------------------------------------------------- 离职收尾
async def close_resignation(session, emp: Employee, leave_date: date | None = None) -> dict:
"""离职结算:终止合同、停保、薪资标准失效、停用登录账号。"""
leave_date = leave_date or emp.leave_date or date.today()
result = {"contracts": 0, "enrollments": 0, "standards": 0, "users": 0}
contracts = list((await session.execute(
select(EmployeeContract).where(EmployeeContract.employee_id == emp.id,
EmployeeContract.status == "active"))).scalars().all())
for c in contracts:
c.status = "terminated"
if c.end_date is None or c.end_date > leave_date:
c.end_date = leave_date
c.probation_end = None
c.remark = (c.remark + ";" if c.remark else "") + "离职终止"
result["contracts"] += 1
enrolls = list((await session.execute(
select(Enrollment).where(Enrollment.employee_id == emp.id,
Enrollment.status == "active"))).scalars().all())
for e in enrolls:
e.status = "stopped"
e.end_date = leave_date
e.include_in_payroll = False
e.remark = (e.remark + ";" if e.remark else "") + "离职停保"
result["enrollments"] += 1
stds = list((await session.execute(
select(EmployeeSalary).where(EmployeeSalary.employee_id == emp.id,
EmployeeSalary.is_active.is_(True)))).scalars().all())
for s in stds:
s.is_active = False
s.remark = (s.remark + ";" if s.remark else "") + f"离职失效({leave_date})"
result["standards"] += 1
users = list((await session.execute(
select(User).where(User.employee_id == emp.id,
User.is_superuser.is_(False)))).scalars().all())
for u in users:
if u.is_active:
u.is_active = False
u.remark = (u.remark + ";" if u.remark else "") + "员工离职,账号停用"
result["users"] += 1
emp.is_active = False
await session.flush()
return result
# 档案停用(非离职)时给账号留下的备注标记:重新启用只恢复被它停用的账号,
# 不会把 HR 手工停用的账号一起放出来。
DEACTIVATED_MARK = "档案停用,账号停用"
async def set_account_state(session, emp: Employee, active: bool) -> int:
"""档案启停联动账号:停用档案 -> 停用其非超管账号;启用档案 -> 恢复由档案停用掉的账号。"""
users = list((await session.execute(
select(User).where(User.employee_id == emp.id, User.is_superuser.is_(False))
)).scalars().all())
changed = 0
for user in users:
if not active:
if user.is_active:
user.is_active = False
user.remark = ((user.remark + ";") if user.remark else "") + DEACTIVATED_MARK
await session.execute(sa_delete(RefreshToken).where(RefreshToken.user_id == user.id))
changed += 1
elif DEACTIVATED_MARK in (user.remark or ""):
user.is_active = True
user.remark = ";".join(
seg for seg in (user.remark or "").split(";") if seg and seg != DEACTIVATED_MARK) or None
await session.execute(sa_delete(RefreshToken).where(RefreshToken.user_id == user.id))
changed += 1
if changed:
await session.flush()
return changed
async def reopen_active(session, emp: Employee) -> dict:
"""复职/返聘:重新激活档案、续签合同、恢复薪资标准与参保。"""
result = {"contracts": 0, "salary": 0, "enrollment": 0}
today = emp.hire_date or date.today()
emp.is_active = True
if not await _single(session, select(EmployeeContract).where(
EmployeeContract.employee_id == emp.id, EmployeeContract.status == "active")):
emp.contract_start, emp.contract_end = today, None
if await ensure_contract(session, emp, silent=False):
result["contracts"] = 1
std = await ensure_salary_standard(session, emp)
if std:
result["salary"] = 1
else:
prior = await _single(session, select(EmployeeSalary).where(
EmployeeSalary.employee_id == emp.id).order_by(EmployeeSalary.id.desc()))
if prior and not prior.is_active:
prior.is_active = True
prior.effective_date = today
prior.remark = (prior.remark or "") .replace(";离职失效", ";复职恢复")
result["salary"] = 1
enr = await ensure_enrollment(session, emp)
if enr:
result["enrollment"] = 1
else:
prior_e = await _single(session, select(Enrollment).where(
Enrollment.employee_id == emp.id).order_by(Enrollment.id.desc()))
if prior_e and prior_e.status == "stopped":
prior_e.status, prior_e.end_date = "active", None
prior_e.include_in_payroll = True
result["enrollment"] = 1
return result
# --------------------------------------------------------------------- 调薪生效
async def apply_adjustment(session, adj: EmployeeSalaryAdjustment) -> str:
"""调薪生效:补全调前薪资、写入生效标准,无标准时按默认账套新建。
返回 ``updated`` / ``created``,调用方据此提示。历史轨迹由
``hr_employee_salary_adjustment``(approved 记录)承担。
"""
std = await _single(session, select(EmployeeSalary).where(
EmployeeSalary.employee_id == adj.employee_id,
EmployeeSalary.is_active.is_(True)).order_by(EmployeeSalary.effective_date.desc()))
created = std is None
if std is None:
emp = await session.get(Employee, adj.employee_id)
if emp is None:
return "skipped"
std = await ensure_salary_standard(session, emp, silent=False)
if std is None:
return "skipped"
if not adj.before_amount:
adj.before_amount = q2(sum(float(v or 0) for v in (std.overrides or {}).values()))
# 调薪金额 = 「基本 + 绩效」薪酬包(与账套津贴分开),按原结构等比缩放
overrides = {k: float(v or 0) for k, v in (std.overrides or {}).items()}
target = float(adj.after_amount or 0)
total_now = sum(v for v in overrides.values() if v > 0)
if target <= 0:
overrides = {}
elif total_now > 0:
ratio = target / total_now
overrides = {k: round(v * ratio, 2) for k, v in overrides.items() if v}
else:
overrides = {"base_salary": round(target * 0.72 / 100) * 100,
"perf_salary": round(target * 0.28 / 100) * 100}
std.overrides = overrides
std.effective_date = adj.effective_date or std.effective_date
std.remark = f"{adj.adjust_type} 调薪生效({adj.reason or ''})"
await session.flush()
return "created" if created else "updated"
__all__ = [
"apply_adjustment",
"close_resignation",
"ensure_contract",
"ensure_enrollment",
"ensure_salary_standard",
"onboard_employee",
"purge_employee_records",
"reopen_active",
"set_account_state",
]