351 lines
12 KiB
Python
351 lines
12 KiB
Python
"""加班套件：工作日/休息日窗口重叠小时（与前端 oa-overtime-hours.ts 对齐）"""
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from datetime import datetime, timedelta
|
|
from typing import Any, Callable, Dict, List, Optional, Tuple
|
|
|
|
Interval = Tuple[float, float]
|
|
|
|
_DT_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})$")
|
|
_HM_RE = re.compile(r"^(\d{1,2}):(\d{2})$")
|
|
|
|
DEFAULT_OVERTIME_WINDOWS = {
|
|
"workdayOvertimeStart": "17:30",
|
|
"workdayOvertimeEnd": "08:30",
|
|
"restBreakStart": "11:30",
|
|
"restBreakEnd": "13:30",
|
|
}
|
|
|
|
MANUAL_PREFIX = "__manual_"
|
|
|
|
|
|
def _parse_hm(hm: Any) -> Optional[int]:
|
|
m = _HM_RE.match(str(hm or "").strip())
|
|
if not m:
|
|
return None
|
|
h, mi = int(m.group(1)), int(m.group(2))
|
|
if h < 0 or h > 23 or mi < 0 or mi > 59:
|
|
return None
|
|
return h * 60 + mi
|
|
|
|
|
|
def _parse_dt(s: Any) -> Optional[datetime]:
|
|
m = _DT_RE.match(str(s or "").strip())
|
|
if not m:
|
|
return None
|
|
try:
|
|
return datetime(
|
|
int(m.group(1)),
|
|
int(m.group(2)),
|
|
int(m.group(3)),
|
|
int(m.group(4)),
|
|
int(m.group(5)),
|
|
)
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
def _format_ymd(d: datetime) -> str:
|
|
return d.strftime("%Y-%m-%d")
|
|
|
|
|
|
def _day_start_ms(d: datetime) -> float:
|
|
day0 = datetime(d.year, d.month, d.day)
|
|
return day0.timestamp() * 1000
|
|
|
|
|
|
def _day_at_minutes(d: datetime, minutes: int) -> float:
|
|
return _day_start_ms(d) + minutes * 60000
|
|
|
|
|
|
def _merge_intervals(intervals: List[Interval]) -> List[Interval]:
|
|
if not intervals:
|
|
return []
|
|
sorted_iv = sorted(intervals, key=lambda x: x[0])
|
|
merged: List[Interval] = [(sorted_iv[0][0], sorted_iv[0][1])]
|
|
for s, e in sorted_iv[1:]:
|
|
last = merged[-1]
|
|
if s <= last[1]:
|
|
merged[-1] = (last[0], max(last[1], e))
|
|
else:
|
|
merged.append((s, e))
|
|
return merged
|
|
|
|
|
|
def _intersect_interval(a: Interval, b: Interval) -> Optional[Interval]:
|
|
lo = max(a[0], b[0])
|
|
hi = min(a[1], b[1])
|
|
return (lo, hi) if hi > lo else None
|
|
|
|
|
|
def _subtract_interval(base: Interval, sub: Interval) -> List[Interval]:
|
|
bs, be = base
|
|
ss, se = sub
|
|
if se <= bs or ss >= be:
|
|
return [base]
|
|
out: List[Interval] = []
|
|
if ss > bs:
|
|
out.append((bs, ss))
|
|
if se < be:
|
|
out.append((se, be))
|
|
return out
|
|
|
|
|
|
def _subtract_intervals(base: Interval, subs: List[Interval]) -> List[Interval]:
|
|
result: List[Interval] = [base]
|
|
for sub in subs:
|
|
nxt: List[Interval] = []
|
|
for r in result:
|
|
nxt.extend(_subtract_interval(r, sub))
|
|
result = nxt
|
|
return result
|
|
|
|
|
|
def _interval_minutes(intervals: List[Interval]) -> float:
|
|
return sum((b - a) / 60000 for a, b in intervals)
|
|
|
|
|
|
def _build_workday_windows(anchor_day: datetime, windows: Dict[str, str]) -> Optional[Interval]:
|
|
start_min = _parse_hm(windows.get("workdayOvertimeStart"))
|
|
end_min = _parse_hm(windows.get("workdayOvertimeEnd"))
|
|
if start_min is None or end_min is None:
|
|
return None
|
|
anchor_start = _day_at_minutes(anchor_day, start_min)
|
|
next_day = anchor_day + timedelta(days=1)
|
|
anchor_end = _day_at_minutes(next_day, end_min)
|
|
if anchor_end <= anchor_start:
|
|
return None
|
|
return (anchor_start, anchor_end)
|
|
|
|
|
|
def _build_rest_day_segments(day: datetime, windows: Dict[str, str]) -> List[Interval]:
|
|
break_start = _parse_hm(windows.get("restBreakStart"))
|
|
break_end = _parse_hm(windows.get("restBreakEnd"))
|
|
if break_start is None or break_end is None:
|
|
return []
|
|
|
|
day0 = _day_start_ms(day)
|
|
next_day = day + timedelta(days=1)
|
|
day_end = _day_start_ms(next_day)
|
|
|
|
segments: List[Interval] = []
|
|
if break_start > 0:
|
|
segments.append((day0, _day_at_minutes(day, break_start)))
|
|
if break_end < 24 * 60:
|
|
segments.append((_day_at_minutes(day, break_end), day_end))
|
|
return [(a, b) for a, b in segments if b > a]
|
|
|
|
|
|
def calc_overtime_hours(
|
|
start_str: Any,
|
|
end_str: Any,
|
|
windows: Optional[Dict[str, str]] = None,
|
|
is_rest_day_fn: Optional[Callable[[str], bool]] = None,
|
|
) -> Optional[float]:
|
|
"""返回 1 位小数小时；非法或 end<=start 返回 None。"""
|
|
if is_rest_day_fn is None:
|
|
raise TypeError("is_rest_day_fn is required")
|
|
|
|
win = dict(DEFAULT_OVERTIME_WINDOWS)
|
|
if isinstance(windows, dict):
|
|
win.update({k: str(windows.get(k) or win[k]) for k in DEFAULT_OVERTIME_WINDOWS})
|
|
|
|
start = _parse_dt(start_str)
|
|
end = _parse_dt(end_str)
|
|
if not start or not end or end <= start:
|
|
return None
|
|
|
|
query: Interval = (start.timestamp() * 1000, end.timestamp() * 1000)
|
|
start_day = datetime(start.year, start.month, start.day)
|
|
end_day = datetime(end.year, end.month, end.day)
|
|
|
|
workday_intervals: List[Interval] = []
|
|
anchor = start_day - timedelta(days=1)
|
|
last_anchor = end_day
|
|
while anchor <= last_anchor:
|
|
ymd = _format_ymd(anchor)
|
|
if not is_rest_day_fn(ymd):
|
|
win_iv = _build_workday_windows(anchor, win)
|
|
if win_iv:
|
|
hit = _intersect_interval(win_iv, query)
|
|
if hit:
|
|
workday_intervals.append(hit)
|
|
anchor += timedelta(days=1)
|
|
|
|
workday_merged = _merge_intervals(workday_intervals)
|
|
|
|
rest_intervals: List[Interval] = []
|
|
day = start_day
|
|
while day <= end_day:
|
|
ymd = _format_ymd(day)
|
|
if is_rest_day_fn(ymd):
|
|
for seg in _build_rest_day_segments(day, win):
|
|
hit = _intersect_interval(seg, query)
|
|
if hit:
|
|
rest_intervals.extend(_subtract_intervals(hit, workday_merged))
|
|
day += timedelta(days=1)
|
|
|
|
total_minutes = _interval_minutes(workday_merged) + _interval_minutes(rest_intervals)
|
|
return round(total_minutes / 60.0, 1)
|
|
|
|
|
|
def _extract_rules(form_schema: Any) -> List[Dict[str, Any]]:
|
|
if isinstance(form_schema, list):
|
|
return [r for r in form_schema if isinstance(r, dict)]
|
|
if isinstance(form_schema, dict):
|
|
rules = form_schema.get("rule") or form_schema.get("rules") or form_schema.get("fields")
|
|
if isinstance(rules, list):
|
|
return [r for r in rules if isinstance(r, dict)]
|
|
if form_schema.get("type") or form_schema.get("field"):
|
|
return [form_schema]
|
|
return []
|
|
|
|
|
|
def _walk(rules: List[Dict[str, Any]], out: List[Dict[str, Any]]) -> None:
|
|
for r in rules:
|
|
if not isinstance(r, dict):
|
|
continue
|
|
out.append(r)
|
|
children = r.get("children")
|
|
if isinstance(children, list):
|
|
_walk([c for c in children if isinstance(c, dict)], out)
|
|
props = r.get("props") if isinstance(r.get("props"), dict) else {}
|
|
nested = props.get("rule")
|
|
if isinstance(nested, list):
|
|
_walk([c for c in nested if isinstance(c, dict)], out)
|
|
|
|
|
|
def _kit_child_fields(kit: Dict[str, Any]) -> Tuple[Optional[str], Optional[str], Optional[str]]:
|
|
"""返回 (start_field, end_field, duration_field)。"""
|
|
props = kit.get("props") if isinstance(kit.get("props"), dict) else {}
|
|
start_f = props.get("startField")
|
|
end_f = props.get("endField")
|
|
dur_f = props.get("durationField")
|
|
if start_f and end_f and dur_f:
|
|
return str(start_f), str(end_f), str(dur_f)
|
|
|
|
children = kit.get("children")
|
|
if not isinstance(children, list):
|
|
children = []
|
|
p_rule = props.get("rule")
|
|
if isinstance(p_rule, list):
|
|
children = p_rule
|
|
|
|
start_field: Optional[str] = None
|
|
end_field: Optional[str] = None
|
|
duration_field: Optional[str] = None
|
|
date_fields: List[str] = []
|
|
|
|
for c in children:
|
|
if not isinstance(c, dict):
|
|
continue
|
|
field = c.get("field")
|
|
if not field:
|
|
continue
|
|
c_props = c.get("props") if isinstance(c.get("props"), dict) else {}
|
|
kit_field = c_props.get("_fc_kit_field")
|
|
if kit_field == "overtimeStart":
|
|
start_field = str(field)
|
|
continue
|
|
if kit_field == "overtimeEnd":
|
|
end_field = str(field)
|
|
continue
|
|
if kit_field == "overtimeDuration":
|
|
duration_field = str(field)
|
|
continue
|
|
t = str(c.get("type") or "")
|
|
if t in ("datePicker", "date", "timePicker", "time"):
|
|
date_fields.append(str(field))
|
|
elif t in ("inputNumber", "number") and duration_field is None:
|
|
duration_field = str(field)
|
|
elif t in ("inputNumber", "number") and "时长" in str(c.get("title") or ""):
|
|
duration_field = str(field)
|
|
|
|
if start_field is None and len(date_fields) >= 1:
|
|
start_field = date_fields[0]
|
|
if end_field is None and len(date_fields) >= 2:
|
|
end_field = date_fields[1]
|
|
return start_field, end_field, duration_field
|
|
|
|
|
|
def _round1(v: Any) -> Optional[float]:
|
|
try:
|
|
n = float(v)
|
|
except (TypeError, ValueError):
|
|
return None
|
|
if n < 0:
|
|
return None
|
|
return round(n, 1)
|
|
|
|
|
|
def apply_overtime_kit_hours(
|
|
form_schema: Any,
|
|
form_data: Dict[str, Any],
|
|
is_rest_day_fn: Callable[[str], bool],
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
遍历 overtimeKit：未手改则覆盖时长；已手改（form_data[__manual_<durationField>]）则仅规范化一位小数。
|
|
"""
|
|
data = dict(form_data or {})
|
|
flat: List[Dict[str, Any]] = []
|
|
_walk(_extract_rules(form_schema), flat)
|
|
for rule in flat:
|
|
if str(rule.get("type") or "") != "overtimeKit":
|
|
continue
|
|
start_f, end_f, dur_f = _kit_child_fields(rule)
|
|
if not start_f or not end_f or not dur_f:
|
|
continue
|
|
props = rule.get("props") if isinstance(rule.get("props"), dict) else {}
|
|
win = {
|
|
"workdayOvertimeStart": str(
|
|
props.get("workdayOvertimeStart") or DEFAULT_OVERTIME_WINDOWS["workdayOvertimeStart"]
|
|
),
|
|
"workdayOvertimeEnd": str(
|
|
props.get("workdayOvertimeEnd") or DEFAULT_OVERTIME_WINDOWS["workdayOvertimeEnd"]
|
|
),
|
|
"restBreakStart": str(
|
|
props.get("restBreakStart") or DEFAULT_OVERTIME_WINDOWS["restBreakStart"]
|
|
),
|
|
"restBreakEnd": str(
|
|
props.get("restBreakEnd") or DEFAULT_OVERTIME_WINDOWS["restBreakEnd"]
|
|
),
|
|
}
|
|
manual_key = MANUAL_PREFIX + dur_f
|
|
is_manual = bool(data.get(manual_key))
|
|
if is_manual:
|
|
rounded = _round1(data.get(dur_f))
|
|
if rounded is not None:
|
|
data[dur_f] = rounded
|
|
continue
|
|
hours = calc_overtime_hours(data.get(start_f), data.get(end_f), win, is_rest_day_fn)
|
|
if hours is not None:
|
|
data[dur_f] = hours
|
|
return data
|
|
|
|
|
|
def validate_overtime_kit_form_values(form_schema: Any, form_data: Dict[str, Any]) -> List[str]:
|
|
"""提交校验：结束>开始；手改时长合法。"""
|
|
errors: List[str] = []
|
|
data = form_data or {}
|
|
flat: List[Dict[str, Any]] = []
|
|
_walk(_extract_rules(form_schema), flat)
|
|
for rule in flat:
|
|
if str(rule.get("type") or "") != "overtimeKit":
|
|
continue
|
|
start_f, end_f, dur_f = _kit_child_fields(rule)
|
|
if not start_f or not end_f or not dur_f:
|
|
continue
|
|
start = _parse_dt(data.get(start_f))
|
|
end = _parse_dt(data.get(end_f))
|
|
if data.get(start_f) and data.get(end_f):
|
|
if not start or not end:
|
|
errors.append("加班起止时间格式须为 YYYY-MM-DD HH:mm")
|
|
elif end <= start:
|
|
errors.append("加班结束时间须晚于开始时间")
|
|
if MANUAL_PREFIX + dur_f in data or data.get(MANUAL_PREFIX + dur_f):
|
|
if data.get(dur_f) is not None and data.get(dur_f) != "":
|
|
if _round1(data.get(dur_f)) is None:
|
|
errors.append("加班时长须为非负数字（1 位小数）")
|
|
return errors
|