Files
dbx-main/app/modules/vacation/db.py
T
king d20ce1efac feat(vacation): 입사일(이름 옆 날짜) · 근로기준법 연차 자동 · 2026 시스템 전 사용 연차
- 잔여 연차 표 이름 옆 입사일 날짜 버튼(ErpDatePop.enhance, « » 1년씩) → vacation_employees(마이그레이션 002)
- 법정 연차 = 근로기준법 제60조 입사일 기준(1년 미만 월 1일·최대 11, 근속 n년 min(25, 15+(n-1)//2)), 그해 생기는 날을 모음
  (store.legal_annual_leave, 화면도 같은 계산으로 바로 표시) — 연차 칸을 비우면 법정, 숫자면 직접 입력(total_days NULL 허용)
- 2026(도입 해)만 "시스템 전 사용"(prior_used) 칸 — 잔여 = 총 − 시스템 전 사용 − 승인된 연차·반차(db.balance_summary 한 곳)
- 테스트: 법정 연차 규칙, 실제 PG(입사일·법정·직접·시스템 전·검증), 실제 앱 저장, 브라우저(입사일 버튼·바로 계산·전송)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 15:53:45 +09:00

614 lines
29 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""vacation_db PostgreSQL 저장소.
- 드라이버: psycopg 3 (`psycopg[binary,pool]`) — expense/cupang 모듈과 동일 패턴.
- 연결 정보: 환경변수 `VACATION_DB_URL`
(예: postgresql://vacation_app:<pwd>@postgres-db:5432/vacation_db)
- 스키마(테이블/인덱스/트리거/seed)는 앱이 만들지 않는다.
`scripts/sql/vacation_db_init.sql` 을 superuser 가 사전 적용한다.
앱 계정(vacation_app)은 SELECT/INSERT/UPDATE/DELETE 권한만 받는다.
- 연결 풀은 lazy open — 부팅 시 DB 가 잠시 끊겨도 컨테이너가 죽지 않게.
휴가 일수는 서버에서 `store.compute_days` 로 재계산하여 저장한다.
공휴일 집합은 대한민국 국경일·대체공휴일 표(holiday_map)를 계산에 넘긴다(holiday provider).
"""
from __future__ import annotations
import uuid
from datetime import date, datetime, timedelta, timezone
from decimal import Decimal
from typing import Any
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from app.timezone import KST
from .store import (
DEDUCT_TYPES, EDITABLE_STATUSES, STATUSES, VACATION_TYPES, compute_days, legal_annual_leave, normalize_half,
)
def _email_list(value: Any) -> list[str]:
"""이메일 목록 정리 — 소문자·공백 제거·@ 있는 것만·중복 제거(순서 유지)."""
out: list[str] = []
for v in value or []:
e = str(v or "").strip().lower()
if "@" in e and e not in out:
out.append(e)
return out
class VacationDBStore:
def __init__(self, dsn: str, *, min_size: int = 1, max_size: int = 5):
self._pool = ConnectionPool(
conninfo=dsn,
min_size=min_size,
max_size=max_size,
kwargs={"row_factory": dict_row, "autocommit": True},
open=False,
)
self._pool.open(wait=False)
def close(self) -> None:
self._pool.close()
# ════════════════════════════════════════════════════════════
# 옵션 · 메일 기록 (마이그레이션 001, 2026-10-27) — 테이블이 없으면 옵션 없음·기록 없음
# ════════════════════════════════════════════════════════════
OPTION_KEY = "approval"
def options_ready(self) -> bool:
with self._pool.connection() as conn:
row = conn.execute("SELECT to_regclass('public.vacation_options') AS r").fetchone()
return bool(row and row["r"])
def get_options(self) -> dict[str, Any]:
"""{"approvers": [이메일], "notifiers": [이메일], "updated_by", "updated_at", "ready": 001 적용 여부}."""
out: dict[str, Any] = {"approvers": [], "notifiers": [], "updated_by": "", "updated_at": "", "ready": False}
if not self.options_ready():
return out
out["ready"] = True
with self._pool.connection() as conn:
row = conn.execute("SELECT value, updated_by, updated_at FROM vacation_options WHERE key = %s",
(self.OPTION_KEY,)).fetchone()
if row:
value = row["value"] if isinstance(row["value"], dict) else {}
out["approvers"] = _email_list(value.get("approvers"))
out["notifiers"] = _email_list(value.get("notifiers"))
out["updated_by"] = row["updated_by"] or ""
if isinstance(row["updated_at"], datetime):
out["updated_at"] = row["updated_at"].astimezone(KST).isoformat(timespec="seconds")
return out
def save_options(self, *, approvers: list[str], notifiers: list[str], by: str) -> dict[str, Any]:
if not self.options_ready():
raise RuntimeError("휴가 옵션은 vacation_db_001 마이그레이션 뒤에 저장할 수 있습니다.")
from psycopg.types.json import Jsonb # noqa: WPS433
value = {"approvers": _email_list(approvers), "notifiers": _email_list(notifiers)}
with self._pool.connection() as conn:
conn.execute(
"INSERT INTO vacation_options (key, value, updated_by, updated_at) VALUES (%s, %s, %s, now()) "
"ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_by = EXCLUDED.updated_by, updated_at = now()",
(self.OPTION_KEY, Jsonb(value), (by or "").lower().strip()),
)
return self.get_options()
def add_mail_log(self, *, request_id: str, event: str, sender: str, via: str, recipients: list[str],
subject: str, ok: bool, error: str = "") -> None:
if not self.options_ready():
return
with self._pool.connection() as conn:
conn.execute(
"INSERT INTO vacation_mail_log (request_id, event, sender, via, recipients, subject, ok, error) "
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s)",
(request_id, event, (sender or "").lower(), via, ", ".join(recipients)[:2000], (subject or "")[:300],
bool(ok), (error or "")[:500]),
)
def list_mail_log(self, *, request_id: str) -> list[dict[str, Any]]:
if not self.options_ready():
return []
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM vacation_mail_log WHERE request_id = %s ORDER BY sent_at, id", (request_id,)).fetchall()
out = []
for r in rows:
d = dict(r)
if isinstance(d.get("sent_at"), datetime):
d["sent_at"] = d["sent_at"].astimezone(KST).isoformat(timespec="seconds")
out.append(d)
return out
# ════════════════════════════════════════════════════════════
# 공휴일 — 대한민국 국경일·대체공휴일 표(holiday provider, 설정 화면 없음)
# ════════════════════════════════════════════════════════════
def holiday_map(self, *, date_from: str, date_to: str) -> dict[str, str]:
"""[date_from, date_to] 범위의 쉬는 날 {ISO 날짜: 이름} — 휴가일수 계산·달력·날짜 팝업의 단일 진실 공급원.
= 대한민국 국경일·대체공휴일(프로젝트 모듈 `KR_HOLIDAYS`, 2026~2030 — 새 연도는 그 표에 추가).
휴가 공휴일 설정 화면은 2026-10-27 없앴다 — vacation_holidays 표는 남아 있지만 읽지 않는다.
"""
from app.modules.project.store import KR_HOLIDAYS # noqa: WPS433
date_from, date_to = str(date_from)[:10], str(date_to)[:10]
return {d: n for d, n in sorted(KR_HOLIDAYS.items()) if date_from <= d <= date_to}
def red_holiday_set(self, *, date_from: str, date_to: str) -> set[str]:
"""[date_from, date_to] 범위의 쉬는 날 ISO 날짜 집합(holiday_map 과 같은 기준)."""
return set(self.holiday_map(date_from=date_from, date_to=date_to))
# ════════════════════════════════════════════════════════════
# 잔여 연차 (vacation_balances)
# ════════════════════════════════════════════════════════════
def get_balance(self, *, user_email: str, year: int) -> dict[str, Any] | None:
with self._pool.connection() as conn:
row = conn.execute(
"SELECT * FROM vacation_balances WHERE user_email = %s AND year = %s",
(user_email.lower().strip(), year),
).fetchone()
return self._balance_serialize(row) if row else None
def list_balances(self, *, year: int) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM vacation_balances WHERE year = %s ORDER BY user_email ASC",
(year,),
).fetchall()
return [self._balance_serialize(r) for r in rows]
def used_days(self, *, user_email: str, year: int) -> float:
"""그해 사용 연차 = 승인된 연차·반차(DEDUCT_TYPES)의 그해 날짜분 합계(2026-10-27).
병가·경조·대체휴무·기타는 빼지 않는다. 해를 넘는 신청(12/30~1/2)은 해마다 그 해 날짜만큼 나눠 센다
(예전엔 모든 승인 휴가를 시작일 연도에 통째로 셌다). 그해 안에 다 들어가는 신청은 저장된 일수 그대로.
"""
y0, y1 = date(year, 1, 1), date(year, 12, 31)
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT start_date, end_date, start_half, end_half, vacation_type, days FROM vacation_requests "
"WHERE owner = %s AND status = '승인' AND vacation_type = ANY(%s) "
"AND start_date <= %s AND end_date >= %s",
(user_email.lower().strip(), list(DEDUCT_TYPES), y1, y0),
).fetchall()
total = 0.0
holidays: set[str] | None = None
for r in rows:
sd, ed = r["start_date"], r["end_date"]
if sd >= y0 and ed <= y1:
total += self._num(r["days"])
continue
if holidays is None:
holidays = self.red_holiday_set(date_from=(y0 - timedelta(days=7)).isoformat(),
date_to=(y1 + timedelta(days=7)).isoformat())
total += compute_days(
start_date=max(sd, y0), end_date=min(ed, y1),
start_half=r["start_half"] if sd >= y0 else "full",
end_half=r["end_half"] if ed <= y1 else "full",
vacation_type=r["vacation_type"], holidays=holidays,
)
return round(total, 2)
def save_balances(self, *, year: int, rows: list[dict[str, Any]], by: str = "") -> int:
"""잔여 연차 한꺼번에 저장 — 한 트랜잭션, 한 줄이라도 틀리면 전부 안 함. 저장한 줄 수.
row = {user_email, total_days(None = 입사일 기준 법정 연차), prior_used(시스템 전 사용, None = 0), memo,
hire_date("YYYY-MM-DD" | "" = 지움 | 키 없음 = 그대로)}. 002 전이면 입사일·시스템 전 사용은 무시하고
total_days 가 없는 줄은 건너뛴다(예전처럼).
"""
v002 = self.hire_ready()
clean = []
for r in rows:
email = (r.get("user_email") or "").lower().strip()
if "@" not in email:
raise ValueError(f"올바른 이메일이 아닙니다: {email}")
total, prior = r.get("total_days"), r.get("prior_used")
for label, v in (("연차", total), ("시스템 전 사용", prior)):
if v is not None and (float(v) < 0 or float(v) > 365 or round(float(v) * 2) != float(v) * 2):
raise ValueError(f"{label} 일수는 0~365, 0.5일 단위입니다: {email}")
hire: Any = ...
if "hire_date" in r:
hv = str(r.get("hire_date") or "").strip()
hire = None
if hv:
try:
hire = date.fromisoformat(hv)
except ValueError:
raise ValueError(f"입사일이 올바르지 않습니다: {email} {hv}") from None
if not date(1950, 1, 1) <= hire <= date(year + 1, 12, 31):
raise ValueError(f"입사일이 올바르지 않습니다: {email} {hv}")
if not v002 and total is None:
continue
clean.append((email, None if total is None else float(total), float(prior or 0),
(r.get("memo") or "").strip()[:200], hire))
who = (by or "").lower().strip()
with self._pool.connection() as conn:
with conn.transaction():
for email, total, prior, memo, hire in clean:
if not v002:
conn.execute(
"INSERT INTO vacation_balances (user_email, year, total_days, memo) VALUES (%s, %s, %s, %s) "
"ON CONFLICT (user_email, year) DO UPDATE SET total_days = EXCLUDED.total_days, memo = EXCLUDED.memo",
(email, year, total, memo),
)
continue
conn.execute(
"INSERT INTO vacation_balances (user_email, year, total_days, prior_used, memo) VALUES (%s, %s, %s, %s, %s) "
"ON CONFLICT (user_email, year) DO UPDATE SET total_days = EXCLUDED.total_days, "
"prior_used = EXCLUDED.prior_used, memo = EXCLUDED.memo",
(email, year, total, prior, memo),
)
if hire is not ...:
conn.execute(
"INSERT INTO vacation_employees (user_email, hire_date, updated_by, updated_at) VALUES (%s, %s, %s, now()) "
"ON CONFLICT (user_email) DO UPDATE SET hire_date = EXCLUDED.hire_date, "
"updated_by = EXCLUDED.updated_by, updated_at = now()",
(email, hire, who),
)
return len(clean)
# ── 입사일(마이그레이션 002 vacation_employees) — 없으면 입사일 없음 ──
def hire_ready(self) -> bool:
with self._pool.connection() as conn:
row = conn.execute("SELECT to_regclass('public.vacation_employees') AS r").fetchone()
return bool(row and row["r"])
def hire_dates(self) -> dict[str, str]:
"""{이메일: 입사일 ISO}."""
if not self.hire_ready():
return {}
with self._pool.connection() as conn:
rows = conn.execute("SELECT user_email, hire_date FROM vacation_employees WHERE hire_date IS NOT NULL").fetchall()
return {r["user_email"]: r["hire_date"].isoformat() for r in rows}
def balance_summary(self, *, user_email: str, year: int, hire_date: Any = ...) -> dict[str, Any]:
"""그해 연차(2026-10-27) — 총 = 직접 입력(있으면) 아니면 입사일 기준 법정 연차(근로기준법 제60조, store.legal_annual_leave),
사용 = 시스템 전 사용(prior_used, 002) + 승인된 연차·반차(used_days), 잔여 = 총 − 사용.
hire_date 를 넘기면(목록에서 한 번에 읽은 값, None = 없음) 다시 읽지 않는다."""
email = user_email.lower().strip()
bal = self.get_balance(user_email=email, year=year)
if hire_date is ...:
hire_date = self.hire_dates().get(email)
legal = legal_annual_leave(date.fromisoformat(hire_date) if hire_date else None, year)
manual = bal["total_days"] if bal and bal.get("total_days") is not None else None
total = manual if manual is not None else (legal["days"] if hire_date else 0.0)
prior = float(bal.get("prior_used") or 0) if bal else 0.0
erp_used = self.used_days(user_email=email, year=year)
return {
"year": year,
"total_days": round(float(total), 2),
"manual_total": manual,
"legal_days": legal["days"] if hire_date else None,
"legal_items": legal["items"],
"service_years": legal["service_years"],
"hire_date": hire_date or "",
"prior_used": prior,
"erp_used": erp_used,
"used_days": round(prior + erp_used, 2),
"remaining_days": round(float(total) - prior - erp_used, 2),
"memo": bal["memo"] if bal else "",
}
# ════════════════════════════════════════════════════════════
# 휴가 신청 (vacation_requests)
# ════════════════════════════════════════════════════════════
def list_for(self, owner: str) -> list[dict[str, Any]]:
owner = owner.lower().strip()
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM vacation_requests WHERE owner = %s "
"ORDER BY start_date DESC, created_at DESC",
(owner,),
).fetchall()
return [self._req_serialize(r) for r in rows]
def list_overlapping(self, *, date_from: str, date_to: str) -> list[dict[str, Any]]:
"""[date_from, date_to] 와 겹치는 모든 신청(달력 bar 표시용).
취소 포함(흐리게 표시). 범위가 한 칸이라도 겹치면 포함.
"""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM vacation_requests "
"WHERE start_date <= %s AND end_date >= %s "
"ORDER BY start_date ASC, owner ASC",
(date_to, date_from),
).fetchall()
return [self._req_serialize(r) for r in rows]
def get_request(self, *, request_id: str) -> dict[str, Any] | None:
with self._pool.connection() as conn:
row = conn.execute(
"SELECT * FROM vacation_requests WHERE id = %s", (request_id,)
).fetchone()
return self._req_serialize(row) if row else None
def create_request(
self, *, owner: str, owner_name: str, payload: dict[str, Any], status: str = "작성중"
) -> dict[str, Any]:
h = self._normalize_payload(payload)
if status not in STATUSES:
status = "작성중"
days = self._calc_days(h)
req_id = uuid.uuid4().hex[:12]
with self._pool.connection() as conn:
row = conn.execute(
"""
INSERT INTO vacation_requests
(id, owner, owner_name, vacation_type, start_date, end_date,
start_half, end_half, days, reason, status)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
RETURNING *
""",
(
req_id,
owner.lower().strip(),
(owner_name or "").strip(),
h["vacation_type"],
h["start_date"],
h["end_date"],
h["start_half"],
h["end_half"],
days,
h["reason"],
status,
),
).fetchone()
return self._req_serialize(row)
def update_request(
self, *, request_id: str, owner: str, payload: dict[str, Any]
) -> dict[str, Any]:
"""작성중/반려 상태에서만 본인이 수정 가능."""
owner = owner.lower().strip()
current = self.get_request(request_id=request_id)
if not current:
raise KeyError(request_id)
if current["owner"] != owner:
raise PermissionError("본인 신청만 수정할 수 있습니다.")
if current["status"] not in EDITABLE_STATUSES:
raise ValueError(f"{current['status']} 상태에서는 수정할 수 없습니다.")
h = self._normalize_payload(payload)
days = self._calc_days(h)
with self._pool.connection() as conn:
row = conn.execute(
"""
UPDATE vacation_requests
SET vacation_type = %s, start_date = %s, end_date = %s,
start_half = %s, end_half = %s, days = %s, reason = %s,
status = '작성중', reject_reason = '',
approver_email = NULL, decided_at = NULL
WHERE id = %s AND owner = %s
RETURNING *
""",
(
h["vacation_type"],
h["start_date"],
h["end_date"],
h["start_half"],
h["end_half"],
days,
h["reason"],
request_id,
owner,
),
).fetchone()
if not row:
raise KeyError(request_id)
return self._req_serialize(row)
# ── 워크플로 ──
def submit(self, *, request_id: str, owner: str) -> dict[str, Any]:
"""작성중/반려 → 제출 (본인)."""
owner = owner.lower().strip()
with self._pool.connection() as conn:
row = conn.execute(
"""
UPDATE vacation_requests
SET status = '제출', reject_reason = '',
approver_email = NULL, decided_at = NULL
WHERE id = %s AND owner = %s AND status IN ('작성중', '반려')
RETURNING *
""",
(request_id, owner),
).fetchone()
if not row:
raise ValueError("작성중/반려 상태에서만 제출할 수 있습니다.")
return self._req_serialize(row)
def approve(self, *, request_id: str, approver_email: str) -> dict[str, Any]:
approver_email = approver_email.lower().strip()
with self._pool.connection() as conn:
row = conn.execute(
"""
UPDATE vacation_requests
SET status = '승인', approver_email = %s, decided_at = now(),
reject_reason = ''
WHERE id = %s AND status = '제출'
RETURNING *
""",
(approver_email, request_id),
).fetchone()
if not row:
raise ValueError("제출 상태가 아니거나 신청이 없습니다.")
return self._req_serialize(row)
def reject(
self, *, request_id: str, approver_email: str, reason: str
) -> dict[str, Any]:
if not (reason or "").strip():
raise ValueError("반려 사유는 필수입니다.")
approver_email = approver_email.lower().strip()
with self._pool.connection() as conn:
row = conn.execute(
"""
UPDATE vacation_requests
SET status = '반려', approver_email = %s, decided_at = now(),
reject_reason = %s
WHERE id = %s AND status = '제출'
RETURNING *
""",
(approver_email, reason.strip(), request_id),
).fetchone()
if not row:
raise ValueError("제출 상태가 아니거나 신청이 없습니다.")
return self._req_serialize(row)
def cancel(self, *, request_id: str, user_email: str, is_admin: bool) -> dict[str, Any]:
"""soft delete — status='취소'. owner 또는 admin 만."""
user_email = user_email.lower().strip()
current = self.get_request(request_id=request_id)
if not current:
raise KeyError(request_id)
if not is_admin and current["owner"] != user_email:
raise PermissionError("본인 신청만 취소할 수 있습니다.")
with self._pool.connection() as conn:
row = conn.execute(
"UPDATE vacation_requests SET status = '취소' WHERE id = %s RETURNING *",
(request_id,),
).fetchone()
return self._req_serialize(row)
def hard_delete(self, *, request_id: str, user_email: str, is_admin: bool) -> None:
"""완전 삭제.
- 관리자(is_admin): 모든 상태 삭제 가능.
- 일반 사용자: 본인 + 승인 전(작성중/제출/반려)만. 승인/취소 건은 불가.
"""
user_email = user_email.lower().strip()
current = self.get_request(request_id=request_id)
if not current:
raise KeyError(request_id)
if not is_admin:
if current["owner"] != user_email:
raise PermissionError("본인 신청만 삭제할 수 있습니다.")
if current["status"] not in ("작성중", "제출", "반려"):
raise ValueError("승인/취소된 휴가는 삭제할 수 없습니다. (관리자 문의)")
with self._pool.connection() as conn:
cur = conn.execute(
"DELETE FROM vacation_requests WHERE id = %s", (request_id,)
)
if cur.rowcount == 0:
raise KeyError(request_id)
def list_pending(self) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM vacation_requests WHERE status = '제출' "
"ORDER BY start_date ASC, created_at ASC"
).fetchall()
return [self._req_serialize(r) for r in rows]
def list_for_export(
self, *, date_from: str | None = None, date_to: str | None = None
) -> list[dict[str, Any]]:
clauses: list[str] = []
params: list[Any] = []
if date_from:
clauses.append("end_date >= %s")
params.append(date_from)
if date_to:
clauses.append("start_date <= %s")
params.append(date_to)
where = ("WHERE " + " AND ".join(clauses)) if clauses else ""
with self._pool.connection() as conn:
rows = conn.execute(
f"SELECT * FROM vacation_requests {where} "
"ORDER BY start_date ASC, owner ASC",
params,
).fetchall()
return [self._req_serialize(r) for r in rows]
# ════════════════════════════════════════════════════════════
# 정규화 / 계산 / 직렬화 helpers
# ════════════════════════════════════════════════════════════
def _calc_days(self, h: dict[str, Any]) -> float:
holidays = self.red_holiday_set(
date_from=h["start_date"], date_to=h["end_date"]
)
return compute_days(
start_date=date.fromisoformat(h["start_date"]),
end_date=date.fromisoformat(h["end_date"]),
start_half=h["start_half"],
end_half=h["end_half"],
vacation_type=h["vacation_type"],
holidays=holidays,
)
@staticmethod
def _normalize_payload(payload: dict[str, Any]) -> dict[str, Any]:
vtype = str(payload.get("vacation_type") or "연차").strip()
if vtype not in VACATION_TYPES:
vtype = "연차"
start_date = str(payload.get("start_date") or "").strip()
end_date = str(payload.get("end_date") or "").strip()
if not start_date:
raise ValueError("시작일은 필수입니다.")
if not end_date:
end_date = start_date
# 날짜 형식/순서 검증
try:
sd = date.fromisoformat(start_date)
ed = date.fromisoformat(end_date)
except ValueError:
raise ValueError("날짜 형식이 올바르지 않습니다 (YYYY-MM-DD).")
if ed < sd:
raise ValueError("종료일이 시작일보다 빠를 수 없습니다.")
start_half = normalize_half(payload.get("start_half"))
end_half = normalize_half(payload.get("end_half"))
# 반차 종류면 단일 일자로 강제
if vtype in ("오전반차", "오후반차"):
end_date = start_date
start_half = "am" if vtype == "오전반차" else "pm"
end_half = start_half
return {
"vacation_type": vtype,
"start_date": start_date,
"end_date": end_date,
"start_half": start_half,
"end_half": end_half,
"reason": str(payload.get("reason") or "").strip(),
}
@staticmethod
def _num(v: Any) -> float:
if isinstance(v, Decimal):
return float(v)
try:
return float(v)
except (TypeError, ValueError):
return 0.0
@classmethod
def _req_serialize(cls, row: dict[str, Any] | None) -> dict[str, Any] | None:
if row is None:
return None
out = dict(row)
for k in ("start_date", "end_date"):
v = out.get(k)
if isinstance(v, date):
out[k] = v.isoformat()
for k in ("created_at", "updated_at", "decided_at"):
v = out.get(k)
if isinstance(v, datetime):
out[k] = v.astimezone(KST).isoformat(timespec="seconds")
out["days"] = cls._num(out.get("days", 0))
return out
@classmethod
def _balance_serialize(cls, row: dict[str, Any] | None) -> dict[str, Any] | None:
if row is None:
return None
out = dict(row)
out["id"] = int(out["id"])
out["year"] = int(out["year"])
out["total_days"] = None if out.get("total_days") is None else cls._num(out["total_days"]) # 002: NULL = 법정 연차
out["used_days"] = cls._num(out.get("used_days", 0))
out["prior_used"] = cls._num(out.get("prior_used", 0))
for k in ("created_at", "updated_at"):
v = out.get(k)
if isinstance(v, datetime):
out[k] = v.astimezone(KST).isoformat(timespec="seconds")
return out