"""vacation_db PostgreSQL 저장소. - 드라이버: psycopg 3 (`psycopg[binary,pool]`) — expense/cupang 모듈과 동일 패턴. - 연결 정보: 환경변수 `VACATION_DB_URL` (예: postgresql://vacation_app:@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