4b2defac3a
- store.leave_grants/leave_period/leave_status: 1년 미만 월 1일 = 입사일부터 1년까지, 근속 n년 연차 = 생긴 날부터 1년까지(근로기준법 제60조) - 승인된 연차·반차를 날짜별(usage_units = compute_days 규칙)로 나눠 그날 쓸 수 있는 연차 중 먼저 소멸하는 것부터 차감, 생기기 전이면 당겨 씀 - 화면: 지금 연차 기간 · 생기는 연차(오늘까지 +앞으로) · 사용 · 오늘 쓸 수 있는 잔여 · 먼저 소멸(날짜·일수), 해 이동 없음, 달력 위 내 연차도 같은 값 - 직접 입력 = 지금 연차 기간이 시작한 해 줄(override_year), 시스템 전 사용 = 2026 줄(도입일에 쓴 것으로) - 테스트: 규칙(10/12 입사 사례·먼저 소멸·당겨 씀·시스템 전·입사일 없음), 실제 PG, 실제 앱, 브라우저 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
627 lines
31 KiB
Python
627 lines
31 KiB
Python
"""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, 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, SYSTEM_START_YEAR, VACATION_TYPES, compute_days, leave_period, leave_status,
|
|
normalize_half, usage_units,
|
|
)
|
|
|
|
|
|
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 usage_events(self, *, user_email: str) -> list[tuple[date, float]]:
|
|
"""쓴 연차 = 승인된 연차·오전반차·오후반차(DEDUCT_TYPES)를 날짜별 [(날짜, 1|0.5)]로(store.usage_units — compute_days 와 같은 규칙).
|
|
병가·경조·대체휴무·기타는 빼지 않는다. 앞날짜로 승인된 휴가도 넣는다(승인되면 차감). 어느 연차에서 빼는지는 store.leave_status."""
|
|
with self._pool.connection() as conn:
|
|
rows = conn.execute(
|
|
"SELECT start_date, end_date, start_half, end_half, vacation_type FROM vacation_requests "
|
|
"WHERE owner = %s AND status = '승인' AND vacation_type = ANY(%s) ORDER BY start_date",
|
|
(user_email.lower().strip(), list(DEDUCT_TYPES)),
|
|
).fetchall()
|
|
if not rows:
|
|
return []
|
|
holidays = self.red_holiday_set(date_from=min(r["start_date"] for r in rows).isoformat(),
|
|
date_to=max(r["end_date"] for r in rows).isoformat())
|
|
out: list[tuple[date, float]] = []
|
|
for r in rows:
|
|
out += usage_units(start_date=r["start_date"], end_date=r["end_date"], start_half=r["start_half"],
|
|
end_half=r["end_half"], vacation_type=r["vacation_type"], holidays=holidays)
|
|
return out
|
|
|
|
def used_days(self, *, user_email: str, year: int) -> float:
|
|
"""그해(1/1~12/31) 쓴 연차 합 — 엑셀·참고용(잔여 계산은 입사일 기준 balance_summary)."""
|
|
return round(sum(a for d, a in self.usage_events(user_email=user_email) if d.year == year), 2)
|
|
|
|
def save_balances(self, *, rows: list[dict[str, Any]], by: str = "", as_of: date | None = None) -> int:
|
|
"""잔여 연차 한꺼번에 저장 — 한 트랜잭션, 한 줄이라도 틀리면 전부 안 함. 저장한 줄 수.
|
|
|
|
row = {user_email, total_days(None = 입사일 기준 법정 연차), prior_used(시스템 전 사용, None = 0), memo,
|
|
hire_date("YYYY-MM-DD" | "" = 지움 | 키 없음 = 그대로)}.
|
|
직접 입력·메모는 그 사람의 **지금 연차 기간이 시작한 해** 줄에(override_year — 바꾼 입사일 기준으로 서버가 계산),
|
|
시스템 전 사용은 SYSTEM_START_YEAR 줄에. 002 전이면 입사일·시스템 전 사용은 무시하고 total_days 가 없는 줄은 건너뛴다.
|
|
"""
|
|
from app.timezone import today_kst # noqa: WPS433
|
|
|
|
as_of = as_of or today_kst()
|
|
year = as_of.year
|
|
v002 = self.hire_ready()
|
|
old_hires = self.hire_dates()
|
|
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
|
|
hire_iso = (hire.isoformat() if hire else None) if hire is not ... else old_hires.get(email)
|
|
key_year = self.override_year(hire_iso, as_of) if v002 else year
|
|
clean.append((email, None if total is None else float(total), float(prior or 0),
|
|
(r.get("memo") or "").strip()[:200], hire, key_year))
|
|
who = (by or "").lower().strip()
|
|
with self._pool.connection() as conn:
|
|
with conn.transaction():
|
|
for email, total, prior, memo, hire, key_year 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, key_year, total, memo),
|
|
)
|
|
continue
|
|
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, key_year, total, memo),
|
|
)
|
|
conn.execute( # 시스템 전 사용 — 도입 해 줄(직접 입력·메모는 건드리지 않음)
|
|
"INSERT INTO vacation_balances (user_email, year, total_days, prior_used) VALUES (%s, %s, NULL, %s) "
|
|
"ON CONFLICT (user_email, year) DO UPDATE SET prior_used = EXCLUDED.prior_used",
|
|
(email, SYSTEM_START_YEAR, prior),
|
|
)
|
|
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}
|
|
|
|
@staticmethod
|
|
def override_year(hire_date: str | None, as_of: date) -> int:
|
|
"""직접 입력 연차를 둘 해 = 지금 연차 기간이 시작한 해(입사일 없으면 as_of 의 해) — vacation_balances.year 키."""
|
|
if not hire_date:
|
|
return as_of.year
|
|
hire = date.fromisoformat(hire_date)
|
|
return as_of.year if as_of < hire else leave_period(hire, as_of)[1].year
|
|
|
|
def balance_summary(self, *, user_email: str, as_of: date | None = None, hire_date: Any = ...) -> dict[str, Any]:
|
|
"""입사일 기준 연차 현황(2026-10-27 — 12/31 소멸 없음, store.leave_status): 지금 연차 기간·생긴 연차·쓴 연차·
|
|
지금 쓸 수 있는 잔여·가장 먼저 소멸할 잔여. 직접 입력(그 기간 시작한 해 줄의 total_days)이 있으면 그 기간 법정 연차 대신,
|
|
시스템 전 사용 = SYSTEM_START_YEAR 줄의 prior_used. hire_date 를 넘기면(목록에서 한 번에 읽은 값, None = 없음) 다시 읽지 않는다."""
|
|
from app.timezone import today_kst # noqa: WPS433
|
|
|
|
email = user_email.lower().strip()
|
|
as_of = as_of or today_kst()
|
|
if hire_date is ...:
|
|
hire_date = self.hire_dates().get(email)
|
|
key_year = self.override_year(hire_date, as_of)
|
|
bal = self.get_balance(user_email=email, year=key_year)
|
|
prior_row = bal if key_year == SYSTEM_START_YEAR else self.get_balance(user_email=email, year=SYSTEM_START_YEAR)
|
|
manual = bal["total_days"] if bal and bal.get("total_days") is not None else None
|
|
prior = float((prior_row or {}).get("prior_used") or 0)
|
|
st = leave_status(hire=date.fromisoformat(hire_date) if hire_date else None, as_of=as_of,
|
|
usages=self.usage_events(user_email=email), prior=prior, override=manual)
|
|
return {
|
|
**st,
|
|
"as_of": as_of.isoformat(),
|
|
"hire_date": hire_date or "",
|
|
"key_year": key_year,
|
|
"manual_total": manual,
|
|
"prior_used": prior,
|
|
"memo": (bal or {}).get("memo") or "",
|
|
# 예전 이름(달력 잔여 줄) — 총 = 이번 기간 생기는 연차, 사용 = 이번 기간 쓴 날, 잔여 = 지금 쓸 수 있는 연차
|
|
"total_days": st["granted"], "used_days": st["used"], "remaining_days": st["available"],
|
|
}
|
|
|
|
# ════════════════════════════════════════════════════════════
|
|
# 휴가 신청 (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
|