412 lines
19 KiB
Python
412 lines
19 KiB
Python
"""员工全生命周期服务。
|
||
|
||
把「入职建档 → 登记人事信息 → 发薪 → 异动 → 离职」这条主线上必须自动发生的
|
||
连带动作集中在这里,避免花名册新增、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",
|
||
]
|