feat(vacation): 연차 12/31 소멸 삭제 — 입사일 기준, 연차마다 쓸 수 있는 기한

- 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>
This commit is contained in:
2026-10-26 16:27:50 +09:00
parent 197c3c13a3
commit 4b2defac3a
16 changed files with 500 additions and 311 deletions
+18 -15
View File
@@ -19,24 +19,27 @@
`vacation_holidays` 표(예전 seed·직접 넣은 줄)는 남아 있지만 읽지 않는다. 예전엔 그 표만 써서 seed 가 없는 해·제헌절은 근무일로 셌다.
이미 저장된 신청의 일수는 그대로(새로 저장·수정할 때 다시 계산).
- 메인 달력: 공휴일 이름이 **날짜 숫자 아래**(`.vac-hol-name`), 그 주는 `.vac-week.has-hol`(휴가 막대 top 38 → 54px).
- **연차 차감** = 승인된 `DEDUCT_TYPES`(연차·오전반차·오후반차)만(`db.used_days`, 병가·경조·대체휴무·기타는 안 뺌 — 예전엔 모든 승인 휴가를 뺐다),
제출·작성중은 안 뺌. 해를 넘는 신청은 해마다 그 해 날짜만큼 나눔(예전엔 시작일 연도에 통째로). **연차는 그해 것만 — 12/31 소멸**, 다음 해로 넘기지 않음
(`vacation_balances` 가 연도별, 새해는 새로 등록. 달력 잔여 옆 "yyyy.12.31 소멸").
- **잔여 연차 등록 = 옵션**(설정에서 옮김, 옵션 수정 권한자만 보기·저장) — 참여자(휴가 모듈 사용자) 전원을 아이콘·이름·이메일과 함께 미리 보여 주는 표
(연차 입력·사용·잔여(음수 빨강)·메모, 아직 없으면 작년 연차를 회색 참고, 예전에 등록됐지만 권한이 없는 사람도 아래에), 연도 ‹ › 이동,
`POST /vacation/options/balances` 한꺼번에(`db.save_balances` 한 트랜잭션 — 0~365·0.5일 단위, 빈 칸 = 그대로). 예전 `POST /settings/balances` 는 없앴다.
- **연차 = 입사일 기준, 12/31 소멸 없음**(2026-10-27 — 그 전 판의 "그해 1/1~12/31, 12/31 소멸"은 근로기준법보다 짧아 없앴다).
`store.leave_grants`(연차마다 생긴 날·쓸 수 있는 마지막 날) · `leave_period`(입사일/기념일 ~ 다음 기념일 전날) · `leave_status` 한 곳:
· 입사 1년 미만 = 입사일 + 1~11개월마다 1일, **입사일부터 1년(첫 기념일 전날)까지** 사용(제60조 ②·⑦ 단서)
· 근속 n년이 되는 날 = `min(25, 15 + (n−1)//2)`일, **그날부터 1년(다음 기념일 전날)까지**(제60조 ①④⑦). 출근율은 모두 채운 것으로 본다.
· 쓴 연차 = 승인된 `DEDUCT_TYPES`(연차·오전반차·오후반차)만(`db.usage_events` → 날짜별 1·0.5, `store.usage_units` = compute_days 규칙,
병가·경조·대체휴무·기타·제출·작성중은 안 뺌, 앞날짜 승인도 차감). 쓴 날마다 그날 쓸 수 있는 연차 중 **먼저 소멸하는 것부터** 빼고,
생기기 전에 쓰면 다음 연차를 당겨 씀(지금 잔여가 음수).
· 화면 = 지금 연차 기간·이번 기간에 생기는 연차(오늘까지 +앞으로)·이번 기간 쓴 날·**오늘 쓸 수 있는 잔여**·먼저 소멸할 잔여(날짜·일수).
달력 위 내 연차 줄도 같은 값(`db.balance_summary(as_of=오늘)`, 보고 있는 달력의 해와 무관). `db.used_days(연도)` 는 참고용 합계만.
- **잔여 연차 등록 = 옵션**(옵션 수정 권한자만 보기·저장) — 참여자(휴가 모듈 사용자) 전원을 아이콘·이름·이메일과 함께 미리 보여 주는 표
(예전에 등록됐지만 권한이 없는 사람도 아래에), 오늘 기준 하나(해 이동 없음). `POST /vacation/options/balances` 한꺼번에(`db.save_balances`).
## 입사일 · 근로기준법 연차 · 시스템 전 사용 (2026-10-27, 마이그레이션 `vacation_db_002_hire_prior.sql`)
## 입사일 · 직접 입력 · 시스템 전 사용 (2026-10-27, 마이그레이션 `vacation_db_002_hire_prior.sql`)
- 옵션 잔여 연차 표 **이름 옆 입사일** = 날짜 버튼(`ErpDatePop.enhance`, « » 1년씩·직접 입력 2020-03-02 Enter, 지우기) → `vacation_employees`(사람마다 하나).
- **법정 연차** = `store.legal_annual_leave(입사일, 연도)` — 근로기준법 제60조를 **입사일 기준으로 생기는 날을 그해(1/1~12/31)에 모음**
(12/31 소멸 규칙과 맞춤): 입사 1년 미만 = 입사일 + 1~11개월마다 1일, 입사일이 돌아올 때마다(근속 n년) `min(25, 15 + (n−1)//2)`.
출근율(개근·80%)은 따지지 않음(모두 채운 것으로). 화면(vacation.js)도 같은 계산으로 입사일을 고르는 즉시 근속·법정·잔여를 다시 보여 줌.
- 연차 칸 = 직접 입력(값이 있으면 그 값), **비우면 법정 연차**(`vacation_balances.total_days` NULL). 입사일도 연차도 없으면 0.
- **시스템 전 사용**(`prior_used`) — 이 시스템을 쓰기 전에 그해 이미 쓴 연차, **도입 해(`store.SYSTEM_START_YEAR` = 2026)만** 표에 칸.
- 잔여 = 총(직접 또는 법정) − 시스템 전 사용 − 승인된 연차·반차 — `db.balance_summary` 한 곳(달력 잔여·옵션 표 모두).
- 저장 `POST /vacation/options/balances` 줄마다 email·hire·total·prior·memo(칸 수가 다르면 400, 한 줄이라도 틀리면 전부 안 함 — `db.save_balances`).
002 전이면 입사일·시스템 전 사용은 무시(입사일 칸은 숨김 칸, 안내 문구), 연차 직접 입력만 예전처럼.
입사일을 고르면 화면(vacation.js)이 같은 규칙으로 근속·연차 기간·생기는 연차를 바로 다시 보여 주고, 사용·잔여·소멸은 "저장 후"(서버가 휴가를 연차마다 나눠 계산).
- **직접 입력** = 그 사람의 **지금 연차 기간** 연차를 법정 대신 그 값으로(비우면 법정) — `vacation_balances` 의 **그 기간이 시작한 해** 줄
`total_days`(`db.override_year`, 저장 때 바꾼 입사일로 서버가 계산). 입사일 없이 직접 입력만 있으면 그해 연차로 셈(소멸일 없음 — 입사일을 넣어야 계산).
- **시스템 전 사용**(`prior_used`) — 이 시스템을 쓰기 전(2026)에 이미 쓴 연차, `SYSTEM_START_YEAR`(2026) 줄에. 도입일 `SYSTEM_START_DATE`(2026-10-27)에 쓴 것으로
쳐서 그날 쓸 수 있는 연차에서 뺀다. 표 칸은 도입 다음 해까지(또는 값이 남아 있으면).
- 저장 줄마다 email·hire·total·prior·memo(칸 수가 다르면 400, 한 줄이라도 틀리면 전부 안 함). 002 전이면 입사일·시스템 전 사용은 무시(입사일 칸은 숨김 칸, 안내 문구).
## 휴가 옵션 · 휴가 메일 (2026-10-27, 마이그레이션 `vacation_db_001_options_mail.sql`)
+71 -58
View File
@@ -15,7 +15,7 @@
from __future__ import annotations
import uuid
from datetime import date, datetime, timedelta, timezone
from datetime import date, datetime, timezone
from decimal import Decimal
from typing import Any
@@ -25,7 +25,8 @@ 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,
DEDUCT_TYPES, EDITABLE_STATUSES, STATUSES, SYSTEM_START_YEAR, VACATION_TYPES, compute_days, leave_period, leave_status,
normalize_half, usage_units,
)
@@ -158,46 +159,43 @@ class VacationDBStore:
).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)
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, 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),
"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()
total = 0.0
holidays: set[str] | None = None
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:
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)
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 save_balances(self, *, year: int, rows: list[dict[str, Any]], by: str = "") -> int:
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" | "" = 지움 | 키 없음 = 그대로)}. 002 전이면 입사일·시스템 전 사용은 무시하고
total_days 가 없는 줄은 건너뛴다(예전처럼).
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()
@@ -220,24 +218,30 @@ class VacationDBStore:
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))
(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 in clean:
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, year, total, memo),
(email, key_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),
"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(
@@ -262,32 +266,41 @@ class VacationDBStore:
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 = 없음) 다시 읽지 않는다."""
@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()
bal = self.get_balance(user_email=email, year=year)
as_of = as_of or today_kst()
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)
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
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)
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 {
"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"],
**st,
"as_of": as_of.isoformat(),
"hire_date": hire_date or "",
"key_year": key_year,
"manual_total": manual,
"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 "",
"memo": (bal or {}).get("memo") or "",
# 예전 이름(달력 잔여 줄) — 총 = 이번 기간 생기는 연차, 사용 = 이번 기간 쓴 날, 잔여 = 지금 쓸 수 있는 연차
"total_days": st["granted"], "used_days": st["used"], "remaining_days": st["available"],
}
# ════════════════════════════════════════════════════════════
+22 -29
View File
@@ -311,7 +311,7 @@ def index(request: Request) -> HTMLResponse:
prev_y, prev_m = (year - 1, 12) if month == 1 else (year, month - 1)
next_y, next_m = (year + 1, 1) if month == 12 else (year, month + 1)
summary = store.balance_summary(user_email=user["email"], year=year)
summary = store.balance_summary(user_email=user["email"]) # 입사일 기준 — 오늘 쓸 수 있는 연차(달력의 해와 무관)
is_approver = _is_approver(request, user)
pending_count = len(store.list_pending()) if is_approver else 0
@@ -497,12 +497,6 @@ async def balances_save(request: Request) -> RedirectResponse:
if store is None:
raise HTTPException(status_code=503, detail="vacation_db 미설정")
form = await request.form()
try:
year = int(str(form.get("year") or ""))
except ValueError:
raise HTTPException(status_code=400, detail="연도가 올바르지 않습니다.")
if not 2000 <= year <= 2100:
raise HTTPException(status_code=400, detail="연도가 올바르지 않습니다.")
emails, memos = form.getlist("email"), form.getlist("memo")
totals, priors, hires = form.getlist("total"), form.getlist("prior"), form.getlist("hire")
if not (len(emails) == len(totals) == len(memos) == len(priors) == len(hires)):
@@ -523,34 +517,34 @@ async def balances_save(request: Request) -> RedirectResponse:
from starlette.concurrency import run_in_threadpool # noqa: WPS433 — 폼 배열을 읽으려 async, DB 는 동기라 스레드에서
try:
n = await run_in_threadpool(store.save_balances, year=year, rows=rows, by=user["email"])
n = await run_in_threadpool(store.save_balances, rows=rows, by=user["email"])
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return RedirectResponse(url="/vacation/options?" + urlencode({"year": year, "msg": f"{year}년 잔여 연차 {n}명을 저장했습니다."})
return RedirectResponse(url="/vacation/options?" + urlencode({"msg": f"잔여 연차 {n}명을 저장했습니다."})
+ "#balances", status_code=303)
def _balance_rows(store: Any, year: int) -> list[dict[str, Any]]:
"""옵션 잔여 연차 표 — 참여자(휴가 모듈 사용자) 전원 + 예전에 등록됐지만 지금 권한이 없는 사람.
줄마다 입사일·근속·법정 연차(근로기준법, 입사일 기준)·연차(직접 입력)·시스템 전 사용·사용·잔여·메모(db.balance_summary 한 곳)."""
def _balance_rows(store: Any, as_of: date) -> list[dict[str, Any]]:
"""옵션 잔여 연차 표 — 참여자(휴가 모듈 사용자) 전원 + 예전에 등록됐지만 지금 권한이 없는 사람(2026-10-27 입사일 기준).
줄마다 입사일·근속·이번 연차 기간·생기는 연차(법정, 오늘까지/앞으로)·직접 입력·시스템 전 사용·사용·지금 잔여·먼저 소멸할 잔여·메모
(db.balance_summary → store.leave_status 한 곳)."""
users = _vacation_users()
this_year = {b["user_email"]: b for b in store.list_balances(year=year)}
last_year = {b["user_email"]: b for b in store.list_balances(year=year - 1)}
registered = {b["user_email"] for y in (as_of.year - 1, as_of.year) for b in store.list_balances(year=y)}
hires = store.hire_dates()
rows = []
people = [(u["email"].lower(), u.get("name") or u["email"].split("@")[0], u.get("picture") or "", True) for u in users]
known = {p[0] for p in people}
people += [(e, e.split("@")[0], "", False) for e in sorted(this_year) if e not in known]
people += [(e, e.split("@")[0], "", False) for e in sorted(registered | set(hires)) if e not in known]
for email, name, picture, active in people:
s = store.balance_summary(user_email=email, year=year, hire_date=hires.get(email))
last = last_year.get(email)
s = store.balance_summary(user_email=email, as_of=as_of, hire_date=hires.get(email))
counted = s["has_hire"] or s["manual_total"] is not None
rows.append({"email": email, "name": name, "picture": picture, "active": active,
"hire_date": s["hire_date"], "service_years": s["service_years"],
"legal": s["legal_days"], "legal_tip": ", ".join(f"{i['date'][5:]} {i['label']} {i['days']:g}일" for i in s["legal_items"]),
"total": s["manual_total"], "effective_total": s["total_days"], "prior": s["prior_used"],
"used": s["erp_used"], "remaining": s["remaining_days"] if (s["manual_total"] is not None or s["hire_date"]) else None,
"memo": s["memo"],
"last_total": last["total_days"] if last and last.get("total_days") is not None else None})
"period_start": s["period_start"], "period_end": s["period_end"],
"granted": s["granted"], "granted_so_far": s["granted_so_far"], "upcoming": s["upcoming"],
"grants_tip": ", ".join(f"{g['date'][2:]} {g['label']} {g['days']:g}일(~{g['expires'][2:]})" for g in s["grants"]),
"total": s["manual_total"], "prior": s["prior_used"], "used": s["used"],
"available": s["available"] if counted else None, "expiring": s["expiring"], "memo": s["memo"]})
return rows
@@ -679,10 +673,7 @@ def options_page(request: Request) -> HTMLResponse:
users = _vacation_users()
can_edit = _can_edit_options(request, user, opts, users)
today = today_kst()
try:
bal_year = int(request.query_params.get("year") or today.year)
except ValueError:
bal_year = today.year
bal_rows = _balance_rows(store, today) if can_edit else []
return render_template(
request,
"vacation/options.html",
@@ -699,11 +690,13 @@ def options_page(request: Request) -> HTMLResponse:
"effective_approvers": notify.approver_emails(opts, users),
"gmail": _gmail_state(request, user),
"msg": request.query_params.get("msg", ""),
"bal_year": bal_year,
"bal_prior_year": bal_year == SYSTEM_START_YEAR, # 시스템 도입 해만 "시스템 전 사용" 칸
"bal_today": today.isoformat(),
# "시스템 전 사용"(도입 해 2026 에 이미 쓴 연차) 칸 — 도입 다음 해까지, 또는 값이 남아 있으면
"bal_prior_col": today.year <= SYSTEM_START_YEAR + 1 or any(r["prior"] for r in bal_rows),
"system_start_year": SYSTEM_START_YEAR,
"hire_ready": store.hire_ready() if can_edit else False,
"can_edit": can_edit,
"bal_rows": _balance_rows(store, bal_year) if can_edit else [],
"bal_rows": bal_rows,
},
)
+115 -23
View File
@@ -33,8 +33,8 @@ HALF_LABELS: dict[str, str] = {"full": "종일", "am": "오전", "pm": "오후"}
# 수정/삭제(취소) 가능한 상태 — 본인 편집 허용
EDITABLE_STATUSES: tuple[str, ...] = ("작성중", "반려")
# 연차에서 차감하는 휴가 종류(2026-10-27) — 승인되면 그해 연차에서 빠진다. 병가·경조·대체휴무·기타는 차감하지 않는다.
# 연차는 그해(1/1~12/31) 것만 쓰고 다음 해로 넘기지 않는다(12/31 소멸 — 해마다 잔여 연차를 새로 등록).
# 연차에서 차감하는 휴가 종류(2026-10-27) — 승인되면 연차에서 빠진다. 병가·경조·대체휴무·기타는 차감하지 않는다.
# 연차는 입사일 기준(leave_grants·leave_status) — 연차마다 쓸 수 있는 기한이 따로(12/31 소멸 규칙은 2026-10-27 없앰).
DEDUCT_TYPES: tuple[str, ...] = ("연차", "오전반차", "오후반차")
# 이 시스템을 쓰기 시작한 해 — 그해만 잔여 연차 표에 "시스템 전 사용"(도입 전에 이미 쓴 연차) 칸(2026-10-27)
@@ -49,34 +49,126 @@ def add_months(d: date, n: int) -> date:
return date(y, m, min(d.day, last))
def legal_annual_leave(hire: date | None, year: int) -> dict:
"""근로기준법 제60조 연차 — 입사일 기준으로 생기는 날을 그해(1/1~12/31)에 모은다(연차는 12/31 소멸 규칙과 맞춤).
# 시스템 전 사용(prior_used)을 쓴 것으로 치는 날 — 이 시스템을 쓰기 시작한 날(그때까지 쓴 연차)
SYSTEM_START_DATE = date(2026, 10, 27)
· 입사 1년 미만: 1개월 개근마다 1일(입사일 + 1~11개월 되는 날, 최대 11일) — 제60조 ②
· 입사일이 돌아올 때마다(근속 n년): 15일 + 최초 1년을 넘는 근속 2년마다 1일, 최대 25일 = min(25, 15 + (n−1)//2) — 제60조 ①④
출근율(1개월 개근·1년 80%)은 따지지 않는다(모두 채운 것으로 본다). 입사일이 없거나 그해 뒤면 0일.
반환 {"days", "items": [{"date", "days", "label"}], "service_years"(12/31 기준 만 근속 연수)}.
def leave_grants(hire: date, until: date) -> list[dict]:
"""입사일부터 until 까지 생기는 연차(근로기준법 제60조) — 생긴 날마다 한 줄, 쓸 수 있는 마지막 날(expires) 포함.
· 입사 1년 미만: 입사일 + m개월(m = 1~11)마다 1일 — 입사일부터 1년(첫 입사 기념일 전날)까지 사용(제60조 ②·⑦ 단서)
· 근속 n년이 되는 날: min(25, 15 + (n−1)//2)일 — 그날부터 1년(다음 입사 기념일 전날)까지 사용(제60조 ①④⑦)
출근율(1개월 개근·1년 80%)은 따지지 않는다(모두 채운 것으로 본다).
"""
out: dict = {"days": 0.0, "items": [], "service_years": 0}
if hire is None:
return out
y0, y1 = date(year, 1, 1), date(year, 12, 31)
items = []
out: list[dict] = []
first_end = add_months(hire, 12) - timedelta(days=1)
for m in range(1, 12):
d = add_months(hire, m)
if y0 <= d <= y1:
items.append({"date": d.isoformat(), "days": 1.0, "label": f"입사 {m}개월(월 1일)"})
g = add_months(hire, m)
if g > until:
break
out.append({"date": g, "expires": first_end, "days": 1.0, "label": f"입사 {m}개월(월 1일)", "period": 0})
n = 1
while True:
d = add_months(hire, 12 * n)
if d > y1:
g = add_months(hire, 12 * n)
if g > until:
break
if d >= y0:
items.append({"date": d.isoformat(), "days": float(min(25, 15 + (n - 1) // 2)), "label": f"근속 {n}년"})
out.append({"date": g, "expires": add_months(hire, 12 * (n + 1)) - timedelta(days=1),
"days": float(min(25, 15 + (n - 1) // 2)), "label": f"근속 {n}년", "period": n})
n += 1
out["items"] = items
out["days"] = float(sum(i["days"] for i in items))
out["service_years"] = max(0, n - 1)
return out
def leave_period(hire: date, as_of: date) -> tuple[int, date, date]:
"""as_of 가 든 연차 기간 = (만 근속 n, 시작, 끝) — 입사일(또는 입사 기념일)부터 다음 기념일 전날까지."""
n = 0
while add_months(hire, 12 * (n + 1)) <= as_of:
n += 1
start = hire if n == 0 else add_months(hire, 12 * n)
return n, start, add_months(hire, 12 * (n + 1)) - timedelta(days=1)
def usage_units(*, start_date: date, end_date: date, start_half: str = "full", end_half: str = "full",
vacation_type: str = "연차", holidays: set[str] | None = None) -> list[tuple[date, float]]:
"""휴가 하나를 날짜별 사용량 [(날짜, 1 또는 0.5)]으로 — compute_days 와 같은 규칙(합계가 같다)."""
holidays = holidays or set()
if end_date < start_date:
return []
if vacation_type in _HALF_DAY_TYPES:
return [(start_date, 0.5)] if is_working_day(start_date, holidays) else []
days = [d for d in _daterange(start_date, end_date) if is_working_day(d, holidays)]
if start_date == end_date:
return [(start_date, 0.5 if start_half in ("am", "pm") else 1.0)] if days else []
out = []
for d in days:
amt = 1.0
if (d == start_date and start_half in ("am", "pm")) or (d == end_date and end_half in ("am", "pm")):
amt = 0.5
out.append((d, amt))
return out
def leave_status(*, hire: date | None, as_of: date, usages: list[tuple[date, float]], prior: float = 0.0,
override: float | None = None) -> dict:
"""입사일 기준 연차 현황(2026-10-27 — 12/31 소멸 없음). 연차마다 생긴 날·쓸 수 있는 마지막 날을 따로 두고,
쓴 날(usages, 승인된 연차·반차)마다 그날 쓸 수 있는 연차 중 **먼저 소멸하는 것부터** 뺀다(없으면 다음에 생길 연차를 당겨 씀).
prior = 시스템 전 사용(SYSTEM_START_DATE 에 쓴 것으로 침). override = 이번 연차 기간 연차를 직접 입력(그 기간 법정 연차 대신).
반환: period(n, start, end) · granted(이번 기간 생기는 연차 합) · granted_so_far(오늘까지 생긴 것) · upcoming(앞으로 생길 것)
· used(이번 기간에 쓴 날 합) · available(지금 쓸 수 있는 잔여) · expiring({date, days} 가장 먼저 소멸할 잔여) · grants(이번 기간 줄).
"""
out = {"has_hire": hire is not None, "service_years": 0, "period_start": "", "period_end": "", "granted": 0.0,
"granted_so_far": 0.0, "upcoming": 0.0, "used": 0.0, "available": 0.0, "expiring": None, "grants": []}
if hire is None or as_of < hire:
if override is not None: # 입사일 없음 — 직접 입력 연차만(기간 = 그해), 사용 = 그해 쓴 날
y0, y1 = date(as_of.year, 1, 1), date(as_of.year, 12, 31)
used = sum(a for d, a in usages if y0 <= d <= y1) + (prior if y0 <= SYSTEM_START_DATE <= y1 else 0.0)
out.update(period_start=y0.isoformat(), period_end=y1.isoformat(), granted=float(override),
granted_so_far=float(override), used=round(float(used), 2), available=round(float(override) - used, 2))
return out
n, p0, p1 = leave_period(hire, as_of)
grants = leave_grants(hire, p1)
if override is not None:
grants = [g for g in grants if not p0 <= g["date"] <= p1]
grants.append({"date": p0, "expires": p1, "days": float(override), "label": "직접 입력", "period": n})
grants.sort(key=lambda g: g["date"])
for g in grants:
g["left"] = g["days"]
events = sorted(usages)
if prior and hire <= SYSTEM_START_DATE:
events = sorted(events + [(SYSTEM_START_DATE, float(prior))])
short = 0.0 # 어느 연차로도 못 채운 날
advance = 0.0 # 오늘까지 쓴 날 중 아직 안 생긴(오늘 뒤에 생기는) 연차를 당겨 쓴 만큼 — 지금 잔여에서 뺀다
for d, amt in events:
rem = amt
now = sorted((g for g in grants if g["date"] <= d <= g["expires"] and g["left"] > 0), key=lambda g: (g["expires"], g["date"]))
later = sorted((g for g in grants if g["date"] > d and g["left"] > 0), key=lambda g: g["date"])
for g in now + later:
take = min(g["left"], rem)
g["left"] -= take
rem -= take
if d <= as_of < g["date"]:
advance += take
if rem <= 0:
break
short += rem
active = [g for g in grants if g["date"] <= as_of <= g["expires"]]
in_period = [g for g in grants if p0 <= g["date"] <= p1]
left = [g for g in active if g["left"] > 0]
expiring = None
if left:
first = min(g["expires"] for g in left)
expiring = {"date": first.isoformat(), "days": round(sum(g["left"] for g in left if g["expires"] == first), 2)}
out.update(
service_years=n, period_start=p0.isoformat(), period_end=p1.isoformat(),
granted=round(float(sum(g["days"] for g in in_period)), 2),
granted_so_far=round(float(sum(g["days"] for g in in_period if g["date"] <= as_of)), 2),
upcoming=round(float(sum(g["days"] for g in in_period if g["date"] > as_of)), 2),
used=round(float(sum(a for d, a in events if p0 <= d <= p1)), 2),
available=round(float(sum(g["left"] for g in active)) - advance - short, 2),
expiring=expiring,
grants=[{"date": g["date"].isoformat(), "expires": g["expires"].isoformat(), "days": g["days"], "label": g["label"],
"left": round(g["left"], 2)} for g in grants if p0 <= g["date"] <= p1 or (g["date"] <= as_of <= g["expires"])],
)
return out
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027d" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block content %}
<section class="vac">
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027d" />
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
{#- 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop) -#}
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %}
@@ -73,4 +73,4 @@
{% block scripts %}<script type="application/json" id="vac-holidays">{{ holidays | tojson }}</script>
<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027b" defer></script>{% endblock %}
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027d" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block content %}
<section class="vac">
@@ -19,13 +19,15 @@
<a class="erp-btn erp-btn-outline" href="/vacation/options">옵션</a>
</div>
<div class="vac-balance">
<span class="vac-bal-item">총 <strong>{{ balance.total_days }}</strong></span>
{#- 내 연차 — 입사일 기준(2026-10-27, 12/31 소멸 없음): 이번 연차 기간에 생기는 연차·쓴 날·지금 쓸 수 있는 잔여·먼저 소멸할 잔여 -#}
{% set gt = '%g' % balance.granted_so_far ~ ((' (+%g 예정)' % balance.upcoming) if balance.upcoming else '') %}
<span class="vac-bal-item" title="이번 연차 기간 {{ balance.period_start }} ~ {{ balance.period_end }}에 생기는 연차(오늘까지 생긴 것 + 앞으로 생길 것)">발생 <strong>{{ gt }}</strong></span>
<span class="vac-bal-sep">·</span>
<span class="vac-bal-item">사용 <strong>{{ balance.used_days }}</strong></span>
<span class="vac-bal-item" title="승인된 연차·오전반차·오후반차(병가·경조·대체휴무·기타는 빼지 않음)">사용 <strong>{{ '%g' % balance.used_days }}</strong></span>
<span class="vac-bal-sep">·</span>
<span class="vac-bal-item vac-bal-remain">잔여 <strong>{{ balance.remaining_days }}</strong></span>
{#- 연차는 그해 것만 — 12/31 소멸, 다음 해로 넘어가지 않음(2026-10-27). 사용 = 승인된 연차·반차 -#}
<span class="erp-muted vac-bal-year" title="사용 = 승인된 연차·오전반차·오후반차(병가·경조·대체휴무·기타는 빼지 않음)">{{ year }}년 · {{ year }}.12.31 소멸</span>
<span class="vac-bal-item vac-bal-remain{% if balance.remaining_days < 0 %} is-minus{% endif %}" title="오늘 쓸 수 있는 연차">잔여 <strong>{{ '%g' % balance.remaining_days }}</strong></span>
{% if balance.expiring %}<span class="erp-muted vac-bal-year">{{ balance.expiring.date | replace('-', '.') }} 소멸 {{ '%g' % balance.expiring.days }}일</span>
{% elif not balance.has_hire and balance.manual_total is none %}<span class="erp-muted vac-bal-year">입사일 미등록(옵션)</span>{% endif %}
</div>
</div>
@@ -2,7 +2,7 @@
{#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나).
메일: 제출 = 승인자·통보자, 승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027d" />
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %}
@@ -63,27 +63,24 @@
{#- 잔여 연차(2026-10-27, 설정에서 옮김) — 참여자(휴가 모듈 사용자) 전원을 미리 보여 주고 줄마다 연차 입력. 관리자·승인자·통보자만 보임·저장. -#}
<form method="post" action="/vacation/options/balances" class="erp-card vac-opt-card vac-opt-balcard" id="balances">
<div class="vac-card-head vac-bal-head">
<h2>잔여 연차 <span class="erp-muted vac-opt-count">{{ bal_year }}년 · 참여자 {{ bal_rows | selectattr('active') | list | length }}명</span></h2>
<span class="vac-bal-years">
<a class="erp-btn erp-btn-outline erp-btn-sm" href="/vacation/options?year={{ bal_year - 1 }}#balances">‹ {{ bal_year - 1 }}</a>
<a class="erp-btn erp-btn-outline erp-btn-sm" href="/vacation/options?year={{ bal_year + 1 }}#balances">{{ bal_year + 1 }} ›</a>
</span>
<h2>잔여 연차 <span class="erp-muted vac-opt-count">{{ bal_today | replace('-', '.') }} 기준 · 참여자 {{ bal_rows | selectattr('active') | list | length }}명</span></h2>
</div>
<p class="erp-muted vac-opt-hint">이름 옆 <b>입사일</b>을 고르면 <b>근로기준법 제60조</b>대로 {{ bal_year }}년에 생기는 연차를 계산합니다
(입사 1년 미만 = 1개월마다 1일·최대 11일, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일·최대 25일, 출근율은 모두 채운 것으로 봄).
<b>연차</b> 칸을 비우면 법정 연차를 쓰고, 숫자를 넣으면 그 값을 씁니다. 휴가가 <b>승인되면</b> 차감됩니다(연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 차감 안 함).
{{ bal_year }}년 연차는 <b>{{ bal_year }}.12.31 에 소멸</b>하고 다음 해로 넘어가지 않습니다.
{% if bal_prior_year %}<b>시스템 전 사용</b> = 이 시스템을 쓰기 전에 {{ bal_year }}년에 이미 쓴 연차(잔여에서 뺍니다).{% endif %}</p>
<p class="erp-muted vac-opt-hint">연차는 사람마다 <b>입사일 기준</b>입니다(근로기준법 제60조 — 출근율은 모두 채운 것으로 봄).
입사 1년 미만은 입사일 + 1~11개월마다 1일씩 생기고 <b>입사일부터 1년</b>까지, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일(최대 25일)이
생겨 <b>그날부터 1년</b>까지 씁니다(12/31 에 없어지지 않음). 휴가가 <b>승인되면</b> 그날 쓸 수 있는 연차 중 <b>먼저 소멸하는 것부터</b> 뺍니다
(연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 안 뺌, 생기기 전에 쓰면 다음 연차를 당겨 씀).
<b>직접 입력</b> = 이번 연차 기간 연차를 법정 대신 그 값으로(비우면 법정).
{% if bal_prior_col %}<b>시스템 전 사용</b> = 이 시스템을 쓰기 전({{ system_start_year }}년)에 이미 쓴 연차.{% endif %}</p>
{% if not hire_ready %}<p class="vac-opt-msg is-warn" role="alert">입사일·시스템 전 사용 칸은 <code>scripts/sql/vacation_db_002_hire_prior.sql</code> 적용 뒤 저장됩니다(지금은 연차 직접 입력만).</p>{% endif %}
<input type="hidden" name="year" value="{{ bal_year }}" />
<div class="erp-table-wrap">
<table class="erp-table vac-bal-table" data-year="{{ bal_year }}">
<thead><tr><th>참여자 · 입사일</th><th>근속</th><th title="입사일 기준 근로기준법 제60조">법정 연차</th><th>연차</th>
{% if bal_prior_year %}<th title="이 시스템을 쓰기 전에 그해 이미 쓴 연차">시스템 전 사용</th>{% endif %}
<th title="ERP 에서 승인된 연차·반차">사용</th><th>잔여</th><th>메모</th></tr></thead>
<table class="erp-table vac-bal-table" data-today="{{ bal_today }}">
<thead><tr><th>참여자 · 입사일</th><th>근속</th><th>이번 연차 기간</th>
<th title="이번 연차 기간에 생기는 법정 연차 — 오늘까지 생긴 것 (+ 앞으로 생길 것)">생기는 연차</th><th title="비우면 법정 연차">직접 입력</th>
{% if bal_prior_col %}<th title="이 시스템을 쓰기 전에 이미 쓴 연차">시스템 전 사용</th>{% endif %}
<th title="이번 연차 기간에 승인된 연차·반차">사용</th><th title="오늘 쓸 수 있는 연차">잔여</th><th>먼저 소멸</th><th>메모</th></tr></thead>
<tbody>
{% for b in bal_rows %}
<tr class="vac-bal-row{{ '' if b.active else ' is-inactive' }}" data-used="{{ '%g' % b.used }}">
<tr class="vac-bal-row{{ '' if b.active else ' is-inactive' }}">
<td>
<span class="vac-bal-person">
{% if b.picture %}<img class="vac-opt-face" src="{{ b.picture }}" alt="" referrerpolicy="no-referrer" />
@@ -92,33 +89,34 @@
<span class="vac-opt-name">{{ b.name }}</span>
<span class="erp-muted vac-opt-mail">{{ b.email }}{% if not b.active %} · 휴가 권한 없음{% endif %}</span>
</span>
{#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값) -#}
{#- 002 전이면 숨김 칸만(서버가 무시) — disabled 는 폼에서 빠져 칸 수가 어긋나므로 쓰지 않는다 -#}
{#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값). 002 전이면 숨김 칸만(서버가 무시) -#}
<input class="vac-hire-input" type="{{ 'date' if hire_ready else 'hidden' }}" name="hire" value="{{ b.hire_date }}" aria-label="{{ b.name }} 입사일" />
</span>
<input type="hidden" name="email" value="{{ b.email }}" />
</td>
<td class="vac-bal-num vac-bal-years-cell">{% if b.hire_date %}{{ b.service_years }}년{% else %}—{% endif %}</td>
<td class="vac-bal-num vac-bal-legal"{% if b.legal_tip %} title="{{ b.legal_tip }}"{% endif %}>{{ '%g' % b.legal if b.legal is not none else '—' }}</td>
<td class="vac-bal-period">{% if b.period_start %}{{ b.period_start[2:] | replace('-', '.') }} ~ {{ b.period_end[2:] | replace('-', '.') }}{% else %}—{% endif %}</td>
<td class="vac-bal-num vac-bal-legal"{% if b.grants_tip %} title="{{ b.grants_tip }}"{% endif %}>{% if b.period_start %}{{ '%g' % b.granted_so_far }}{% if b.upcoming %} <small>(+{{ '%g' % b.upcoming }})</small>{% endif %}{% else %}—{% endif %}</td>
<td><input class="erp-input vac-bal-input" type="number" name="total" step="0.5" min="0" max="365"
value="{{ '%g' % b.total if b.total is not none else '' }}"
placeholder="{{ ('%g' % b.legal) if b.legal is not none else (('%g' % b.last_total) if b.last_total is not none else '') }}"
aria-label="{{ b.name }} 연차(비우면 법정 연차)" /></td>
{% if bal_prior_year %}
value="{{ '%g' % b.total if b.total is not none else '' }}" placeholder="{{ '%g' % b.granted if b.hire_date else '' }}"
aria-label="{{ b.name }} 이번 연차 기간 직접 입력(비우면 법정)" /></td>
{% if bal_prior_col %}
<td><input class="erp-input vac-bal-input vac-bal-prior" type="number" name="prior" step="0.5" min="0" max="365"
value="{{ '%g' % b.prior if b.prior else '' }}" placeholder="0" aria-label="{{ b.name }} 시스템 전 사용"{% if not hire_ready %} readonly{% endif %} /></td>
{% else %}<input type="hidden" name="prior" value="{{ '%g' % b.prior if b.prior else '' }}" />{% endif %}
<td class="vac-bal-num">{{ '%g' % b.used }}</td>
<td class="vac-bal-num vac-bal-remain{% if b.remaining is not none and b.remaining < 0 %} is-minus{% endif %}">{{ '%g' % b.remaining if b.remaining is not none else '—' }}</td>
<td class="vac-bal-num vac-bal-remain{% if b.available is not none and b.available < 0 %} is-minus{% endif %}">{{ '%g' % b.available if b.available is not none else '—' }}</td>
<td class="vac-bal-expire">{% if b.expiring %}{{ b.expiring.date[2:] | replace('-', '.') }} · {{ '%g' % b.expiring.days }}일{% else %}—{% endif %}</td>
<td><input class="erp-input vac-bal-memo" type="text" name="memo" maxlength="200" value="{{ b.memo }}" placeholder="비고" aria-label="{{ b.name }} 메모" /></td>
</tr>
{% else %}
<tr><td colspan="8" class="erp-muted">휴가 모듈 권한이 있는 사용자가 없습니다.</td></tr>
<tr><td colspan="10" class="erp-muted">휴가 모듈 권한이 있는 사용자가 없습니다.</td></tr>
{% endfor %}
</tbody>
</table>
</div>
<div class="vac-opt-save"><button type="submit" class="erp-btn erp-btn-primary">{{ bal_year }}년 잔여 연차 저장</button></div>
<div class="vac-opt-save"><button type="submit" class="erp-btn erp-btn-primary">잔여 연차 저장</button>
<span class="erp-muted vac-bal-note" hidden>입사일·직접 입력을 바꿨습니다 — 저장하면 사용·잔여·소멸을 다시 계산합니다.</span></div>
</form>
{% endif %}
@@ -152,4 +150,4 @@
{% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027b" defer></script>{% endblock %}
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027d" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block content %}
<section class="vac">
+5
View File
@@ -262,3 +262,8 @@
.vac-bal-person .vac-hire-btn .material-symbols-outlined { font-size: 16px; }
.vac-bal-legal { color: #1a56db; font-weight: 600; }
.vac-bal-years-cell { color: var(--vac-muted); }
/* 잔여 연차 — 입사일 기준(2026-10-27): 연차 기간·먼저 소멸, 바꾼 줄은 저장 전 옅게 */
.vac-bal-period, .vac-bal-expire { white-space: nowrap; font-size: 12.5px; color: var(--vac-muted); font-variant-numeric: tabular-nums; }
.vac-bal-legal small { font-weight: 500; color: var(--vac-muted); }
.vac-bal-table tr.is-stale .vac-bal-remain, .vac-bal-table tr.is-stale .vac-bal-expire { color: #b45309; font-weight: 600; }
.vac-bal-remain.is-minus { color: var(--vac-red); font-weight: 700; }
+42 -36
View File
@@ -101,69 +101,75 @@
recalc();
})();
/* 휴가 옵션 — 잔여 연차 표(2026-10-27): 이름 옆 입사일 = 날짜 버튼(erp-datepop), 고르면 근속·법정 연차·잔여를 바로 다시 계산
(서버 store.legal_annual_leave 와 같은 규칙 — 근로기준법 제60조, 입사일 기준으로 그해에 생기는 연차). 저장은 [잔여 연차 저장]. */
/* 휴가 옵션 — 잔여 연차 표(2026-10-27, 입사일 기준): 이름 옆 입사일 = 날짜 버튼(erp-datepop). 고르면 근속·이번 연차 기간·생기는 연차
(오늘까지 + 앞으로)를 바로 다시 계산(서버 store.leave_grants·leave_period 와 같은 규칙 — 근로기준법 제60조).
사용·잔여·소멸은 승인된 휴가를 연차마다 나눠야 해서 서버가 계산 — 입사일·직접 입력을 바꾸면 "저장 후"로 표시하고 안내. */
(function () {
"use strict";
var table = document.querySelector(".vac-bal-table");
if (!table) return;
var year = +table.dataset.year;
var today = table.dataset.today;
var note = document.querySelector(".vac-bal-note");
function iso(d) {
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
function parse(s) { var p = s.split("-"); return new Date(+p[0], +p[1] - 1, +p[2]); }
function addMonths(d, n) { // 같은 날, 없으면 그 달 말일(1/31 + 1달 = 2/28)
var m = d.getMonth() + n, y = d.getFullYear() + Math.floor(m / 12);
m = ((m % 12) + 12) % 12;
var last = new Date(y, m + 1, 0).getDate();
return new Date(y, m, Math.min(d.getDate(), last));
return new Date(y, m, Math.min(d.getDate(), new Date(y, m + 1, 0).getDate()));
}
function legal(hireIso) {
if (!hireIso) return null;
var p = hireIso.split("-"), hire = new Date(+p[0], +p[1] - 1, +p[2]);
var y0 = iso(new Date(year, 0, 1)), y1 = iso(new Date(year, 11, 31));
var days = 0, items = [], n = 1, d;
for (var m = 1; m < 12; m++) {
d = iso(addMonths(hire, m));
if (d >= y0 && d <= y1) { days += 1; items.push(d.slice(5) + " 입사 " + m + "개월(월 1일) 1일"); }
function dayBefore(d) { return new Date(d.getFullYear(), d.getMonth(), d.getDate() - 1); }
function status(hireIso) {
if (!hireIso || hireIso > today) return null;
var hire = parse(hireIso), n = 0;
while (iso(addMonths(hire, 12 * (n + 1))) <= today) n++;
var p0 = n === 0 ? hireIso : iso(addMonths(hire, 12 * n)), p1 = iso(dayBefore(addMonths(hire, 12 * (n + 1))));
var so = 0, up = 0, tip = [];
function add(g, days, label, exp) {
if (g < p0 || g > p1) return;
if (g <= today) so += days; else up += days;
tip.push(g.slice(2) + " " + label + " " + days + "일(~" + exp.slice(2) + ")");
}
for (;;) {
d = iso(addMonths(hire, 12 * n));
if (d > y1) break;
if (d >= y0) { var g = Math.min(25, 15 + Math.floor((n - 1) / 2)); days += g; items.push(d.slice(5) + " 근속 " + n + "년 " + g + "일"); }
n++;
if (n === 0) {
var first = iso(dayBefore(addMonths(hire, 12)));
for (var m = 1; m < 12; m++) add(iso(addMonths(hire, m)), 1, "입사 " + m + "개월(월 1일)", first);
} else {
add(p0, Math.min(25, 15 + Math.floor((n - 1) / 2)), "근속 " + n + "년", p1);
}
return { days: days, years: n - 1, tip: items.join(", ") };
return { years: n, p0: p0, p1: p1, so: so, up: up, tip: tip.join(", ") };
}
function g(v) { return String(Math.round(v * 100) / 100); }
function dots(d) { return d.slice(2).replace(/-/g, "."); }
table.querySelectorAll("tr.vac-bal-row").forEach(function (tr) {
var hire = tr.querySelector(".vac-hire-input");
var total = tr.querySelector('input[name="total"]');
var prior = tr.querySelector('input[name="prior"]');
var used = +tr.dataset.used || 0;
function stale() {
tr.querySelector(".vac-bal-remain").textContent = "저장 후";
tr.querySelector(".vac-bal-remain").classList.remove("is-minus");
tr.querySelector(".vac-bal-expire").textContent = "저장 후";
tr.classList.add("is-stale");
if (note) note.hidden = false;
}
function recalc() {
var L = legal(hire.value);
tr.querySelector(".vac-bal-years-cell").textContent = L ? L.years + "년" : "—";
var S = status(hire.value);
tr.querySelector(".vac-bal-years-cell").textContent = S ? S.years + "년" : "—";
tr.querySelector(".vac-bal-period").textContent = S ? dots(S.p0) + " ~ " + dots(S.p1) : "—";
var lg = tr.querySelector(".vac-bal-legal");
lg.textContent = L ? g(L.days) : "—";
if (L && L.tip) lg.title = L.tip; else lg.removeAttribute("title");
if (L) total.placeholder = g(L.days);
var manual = total.value.trim() === "" ? null : +total.value;
var base = manual != null ? manual : (L ? L.days : null);
var cell = tr.querySelector(".vac-bal-remain");
if (base == null) { cell.textContent = "—"; cell.classList.remove("is-minus"); return; }
var rem = base - (prior && prior.value.trim() !== "" ? +prior.value : 0) - used;
cell.textContent = g(rem);
cell.classList.toggle("is-minus", rem < 0);
lg.textContent = S ? String(S.so) : "—";
if (S && S.up) { var sm = document.createElement("small"); sm.textContent = "(+" + S.up + ")"; lg.append(" ", sm); }
if (S && S.tip) lg.title = S.tip; else lg.removeAttribute("title");
total.placeholder = S ? String(S.so + S.up) : "";
stale();
}
if (hire && hire.type !== "hidden" && window.ErpDatePop) {
window.ErpDatePop.enhance(hire, { label: "입사일", placeholder: "입사일", yearNav: true, format: window.ErpDatePop.fmtFull,
className: "vac-hire-btn" });
}
if (hire) hire.addEventListener("change", recalc);
total.addEventListener("input", recalc);
if (prior) prior.addEventListener("input", recalc);
total.addEventListener("input", stale);
if (prior) prior.addEventListener("input", stale);
});
})();
+2 -2
View File
@@ -255,7 +255,7 @@ DDL: `scripts/sql/vacation_db_init.sql` (멱등). DB·역할(`vacation_app`)·
휴가 일수는 서버(`store.compute_days`)에서 재계산: 주말 + 쉬는 날 제외, 오전/오후 반차 0.5일, 시작/종료 반차는 각 0.5 차감. 클라이언트 계산은 미리보기용(같은 공휴일 표).
쉬는 날(2026-10-27) = 국경일·대체공휴일(프로젝트 `KR_HOLIDAYS`, 2026~2030, 새 연도는 그 표에 추가) — `db.holiday_map`. `vacation_holidays` 는 읽지 않는다.
사용 연차 = 승인된 연차·오전반차·오후반차만, 해를 넘는 신청은 해마다 나눠 셈. 연차는 연도별(`vacation_balances.year`)이라 12/31 소멸·이월 없음.
연차(2026-10-27) = **입사일 기준**(`store.leave_status`) — 연차마다 쓸 수 있는 기한이 따로(1년 미만 월 1일 = 입사일부터 1년, 근속 연차 = 생긴 날부터 1년), 12/31 소멸 없음. 쓴 연차 = 승인된 연차·오전반차·오후반차만, 먼저 소멸하는 연차부터 뺀다. `vacation_balances.year` = 직접 입력한 연차 기간이 시작한 해(+ 2026 줄 = 시스템 전 사용).
권한: `vacation`(접근) / `vacation_approver`(승인·반려 — 옵션에 승인자를 지정하면 그 사람들). admin 은 항상 통과. 옵션(승인자·통보자·잔여 연차) 수정 = admin + 승인자 + 통보자.
@@ -268,7 +268,7 @@ docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 <
```
**마이그레이션 002**(`scripts/sql/vacation_db_002_hire_prior.sql`, 2026-10-27, 멱등): `vacation_employees`(사람마다 입사일 → 근로기준법 제60조 연차,
`store.legal_annual_leave`) · `vacation_balances.prior_used`(시스템 전에 그해 쓴 연차) · `vacation_balances.total_days` NULL 허용(NULL = 입사일 기준 법정 연차).
`store.leave_status`) · `vacation_balances.prior_used`(시스템 전에 쓴 연차, 2026 줄) · `vacation_balances.total_days` NULL 허용(NULL = 입사일 기준 법정 연차).
```bash
docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_002_hire_prior.sql
+10 -7
View File
@@ -30,17 +30,20 @@ def main() -> None:
html = env.get_template("vacation/form.html").render(**ctx)
with open(os.path.join(OUT_DIR, "vac_form.html"), "w", encoding="utf-8") as f:
f.write(html)
# 옵션 — 잔여 연차 표(2026, 입사일·법정 연차·시스템 전 사용) → tests/js/.out/vac_options.html
row = {"active": True, "picture": "", "service_years": 0, "legal": None, "legal_tip": "", "total": None, "effective_total": 0,
"prior": 0.0, "used": 0.0, "remaining": None, "memo": "", "last_total": None, "hire_date": ""}
# 옵션 — 잔여 연차 표(2026-10-27 입사일 기준, 오늘 = 2026-10-26 고정) → tests/js/.out/vac_options.html
row = {"active": True, "picture": "", "service_years": 0, "period_start": "", "period_end": "", "granted": 0.0,
"granted_so_far": 0.0, "upcoming": 0.0, "grants_tip": "", "total": None, "prior": 0.0, "used": 0.0,
"available": None, "expiring": None, "memo": "", "hire_date": ""}
octx = {**ctx, "page_title": "휴가 — 옵션", "is_admin": True, "can_edit": True, "msg": "",
"options": {"approvers": [], "notifiers": [], "ready": True, "updated_by": "", "updated_at": ""},
"candidates": [], "effective_approvers": [], "gmail": {"available": False, "connected": False, "smtp": True},
"bal_year": 2026, "bal_prior_year": True, "hire_ready": True,
"bal_today": "2026-10-26", "bal_prior_col": True, "system_start_year": 2026, "hire_ready": True,
"bal_rows": [
{**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6, "legal": 17.0,
"legal_tip": "03-02 근속 6년 17일", "used": 4.5, "remaining": 12.5},
{**row, "email": "kim@test.local", "name": "김철수", "used": 1.0},
{**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6,
"period_start": "2026-03-02", "period_end": "2027-03-01", "granted": 17.0, "granted_so_far": 17.0,
"grants_tip": "26-03-02 근속 6년 17일(~27-03-01)", "used": 4.5, "available": 12.5,
"expiring": {"date": "2027-03-01", "days": 12.5}},
{**row, "email": "kim@test.local", "name": "김철수"},
]}
html = env.get_template("vacation/options.html").render(**octx)
with open(os.path.join(OUT_DIR, "vac_options.html"), "w", encoding="utf-8") as f:
+38 -26
View File
@@ -1,6 +1,8 @@
// 휴가 옵션 잔여 연차 — 이름 옆 입사일 날짜 버튼 · 근로기준법 연차 바로 계산 · 시스템 전 사용(2026-10-27) — 실제 브라우저(Chromium).
// 휴가 옵션 잔여 연차 — 입사일 기준(2026-10-27, 12/31 소멸 없음) — 실제 브라우저(Chromium).
// python tests/js/render_vacation.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/vacation_balances.browser.test.js
// 이름 옆 입사일 날짜 버튼 → 근속·이번 연차 기간·생기는 연차(오늘까지 +앞으로)를 바로 계산, 사용·잔여·소멸은 "저장 후"(서버 계산),
// 1년씩 이동, 저장하면 줄마다 email·hire·total·prior·memo. 오늘 = 2026-10-26(렌더 데이터에 고정).
const fs = require("fs"), path = require("path");
const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", "..");
@@ -15,7 +17,7 @@ function check(name, cond, extra) {
const browser = await chromium.launch(exe ? { executablePath: exe } : {});
const posts = [];
try {
const p = await (await browser.newContext({ viewport: { width: 1400, height: 900 } })).newPage();
const p = await (await browser.newContext({ viewport: { width: 1500, height: 900 } })).newPage();
await p.route("**/*", function (r) {
const req = r.request(), url = new URL(req.url()).pathname;
if (url.startsWith("/static/")) {
@@ -33,52 +35,62 @@ function check(name, cond, extra) {
return p.evaluate(function (email) {
const tr = document.querySelector('input[name="email"][value="' + email + '"]').closest("tr");
const btn = tr.querySelector(".vac-hire-btn");
const t = function (sel) { return tr.querySelector(sel).textContent.trim().replace(/\s+/g, " "); };
return { btn: btn && btn.textContent.replace("calendar_month", "").trim(), nextToName: !!btn && btn.parentElement === tr.querySelector(".vac-bal-person"),
hire: tr.querySelector('input[name="hire"]').value, hireShown: getComputedStyle(tr.querySelector('input[name="hire"]')).display !== "none",
years: tr.querySelector(".vac-bal-years-cell").textContent.trim(), legal: tr.querySelector(".vac-bal-legal").textContent.trim(),
placeholder: tr.querySelector('input[name="total"]').placeholder, remain: tr.querySelector(".vac-bal-remain").textContent.trim(),
minus: tr.querySelector(".vac-bal-remain").classList.contains("is-minus") };
years: t(".vac-bal-years-cell"), period: t(".vac-bal-period"), legal: t(".vac-bal-legal"),
placeholder: tr.querySelector('input[name="total"]').placeholder, remain: t(".vac-bal-remain"), expire: t(".vac-bal-expire"),
stale: tr.classList.contains("is-stale") };
}, email);
};
const lee = await rowState("lee@test.local");
check("입사일 = 이름 옆 날짜 버튼(연도까지), 숨긴 input 이 값", lee.nextToName && !lee.hireShown && lee.btn === "2020.03.02(월)" &&
lee.hire === "2020-03-02" && lee.legal === "17" && lee.remain === "12.5", lee);
check("입사일 = 이름 옆 날짜 버튼(연도까지), 이번 연차 기간·잔여·먼저 소멸(12/31 아님)", lee.nextToName && !lee.hireShown &&
lee.btn === "2020.03.02(월)" && lee.period === "26.03.02 ~ 27.03.01" && lee.legal === "17" && lee.remain === "12.5" &&
lee.expire === "27.03.01 · 12.5일", lee);
const kim0 = await rowState("kim@test.local");
check("입사일 없음 = '입사일' 버튼, 근속·법정 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.legal === "—" && kim0.remain === "—", kim0);
// 김철수 입사일 2025-03-01 직접 입력(Enter) → 근속 1년 · 법정 17(1/1·2/1 월 1일 + 3/1 15일) · 잔여 17 − 1(사용)
check("입사일 없음 = '입사일' 버튼, 기간·연차 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.period === "—" && kim0.remain === "—", kim0);
const head = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".vac-bal-table thead th")).map(function (x) { return x.textContent.trim(); });
});
check("표 머리 = 입사일 기준(연차 기간·생기는 연차·잔여·먼저 소멸), 해 이동 버튼 없음",
head.indexOf("이번 연차 기간") >= 0 && head.indexOf("먼저 소멸") >= 0 && head.indexOf("시스템 전 사용") >= 0 &&
!(await p.$('a[href*="year="]')), head);
// 김철수 입사일 2026-10-12(오늘 10/26) → 근속 0년 · 기간 26.10.12 ~ 27.10.11 · 오늘까지 0 (+11)
await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn');
const pop = await p.evaluate(function () {
const el = document.querySelector(".pj-datepop");
return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder,
clear: !!el.querySelector(".pj-dp-clear") };
return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder };
});
check("입사일 팝업 = 날짜 하나, « ‹ › » (1년씩 이동), 지우기", !!pop && pop.navs === 4 && pop.field === "입사일" && pop.clear, pop);
await p.fill(".pj-dp-field", "2025-03-01");
check("입사일 팝업 = 날짜 하나, « ‹ › »", !!pop && pop.navs === 4 && pop.field === "입사일", pop);
await p.fill(".pj-dp-field", "2026-10-12");
await p.press(".pj-dp-field", "Enter");
const kim1 = await rowState("kim@test.local");
check("입사일 고르면 근속·법정 연차·잔여 바로 계산(근로기준법)", kim1.btn === "2025.03.01(토)" && kim1.hire === "2025-03-01" &&
kim1.years === "1년" && kim1.legal === "17" && kim1.placeholder === "17" && kim1.remain === "16", kim1);
// 시스템 전 사용 3.5 → 잔여 12.5, 연차 직접 10 → 10 − 3.5 − 1 = 5.5, 20 넘게 쓰면 빨강
await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "3.5");
check("시스템 전 사용 → 잔여에서 뺌", (await rowState("kim@test.local")).remain === "12.5");
await p.fill('tr:has(input[value="kim@test.local"]) input[name="total"]', "10");
check("연차 직접 입력이 법정보다 먼저", (await rowState("kim@test.local")).remain === "5.5");
await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "12");
check("10/12 입사 → 이번 기간 26.10.12 ~ 27.10.11, 오늘까지 0 (+11), 잔여·소멸은 저장 후", kim1.btn === "2026.10.12(월)" &&
kim1.years === "0년" && kim1.period === "26.10.12 ~ 27.10.11" && kim1.legal === "0 (+11)" && kim1.placeholder === "11" &&
kim1.remain === "저장 후" && kim1.expire === "저장 후" && kim1.stale, kim1);
// 2025-03-01 로 바꾸면 근속 1년 · 26.03.01 ~ 27.02.28 · 15
await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn');
await p.fill(".pj-dp-field", "2025.3.1");
await p.press(".pj-dp-field", "Enter");
const kim2 = await rowState("kim@test.local");
check("모자라면 잔여 빨강", kim2.remain === "-3" && kim2.minus, kim2);
// 1년씩 이동 버튼 — 2025년 3월 → « → 2024년 3월
check("2025-03-01 입사 → 근속 1년 · 26.03.01 ~ 27.02.28 · 15일", kim2.years === "1년" && kim2.period === "26.03.01 ~ 27.02.28" &&
kim2.legal === "15" && kim2.placeholder === "15", kim2);
const note = await p.evaluate(function () { return !document.querySelector(".vac-bal-note").hidden; });
check("바꾸면 '저장하면 다시 계산' 안내", note);
await p.fill('tr:has(input[value="lee@test.local"]) input[name="prior"]', "3");
check("시스템 전 사용을 바꾸면 그 줄도 저장 후", (await rowState("lee@test.local")).remain === "저장 후");
// 1년씩 이동
await p.click('tr:has(input[value="lee@test.local"]) .vac-hire-btn');
const t0 = await p.textContent(".pj-dp-title");
await p.click('.pj-dp-navbtn[data-nav="-12"]');
const t1 = await p.textContent(".pj-dp-title");
check("« = 1년 전 달력", t0 === "2020년 3월" && t1 === "2019년 3월", [t0, t1]);
await p.keyboard.press("Escape");
// 저장 — 줄마다 email·hire·total·prior·memo
await p.click('button[type="submit"]:has-text("잔여 연차 저장")');
await p.waitForTimeout(200);
const body = decodeURIComponent((posts[0] || "").replace(/\+/g, " "));
check("저장 → 입사일·연차·시스템 전 사용이 줄마다 전송", /email=kim@test.local/.test(body) && /hire=2025-03-01/.test(body) &&
/hire=2020-03-02/.test(body) && /total=10/.test(body) && /prior=12/.test(body) && (body.match(/hire=/g) || []).length === 2, body);
check("저장 → 줄마다 입사일·직접 입력·시스템 전 사용(연도 칸 없음)", /email=kim@test.local/.test(body) && /hire=2025-03-01/.test(body) &&
/hire=2020-03-02/.test(body) && /prior=3/.test(body) && (body.match(/hire=/g) || []).length === 2 && !/year=/.test(body), body);
} finally {
await browser.close();
}
+119 -61
View File
@@ -108,72 +108,127 @@ class VacationHolidayBalanceDBTests(unittest.TestCase):
self.st.approve(request_id=req["id"], approver_email="lee@test.local")
return req
def test_used_days_only_annual_types_and_split_by_year(self):
def test_usage_only_annual_types_and_hire_based_status(self):
"""승인된 연차·반차만 쓴 날로(병가·경조·제출 제외), 입사일 기준으로 먼저 소멸할 연차부터 뺀다(2026-10-27 — 12/31 소멸 없음)."""
from datetime import date
st = self.st
owner = f"bal-{uuid.uuid4().hex[:6]}@test.local"
made = [
self._approved(owner, "연차", "2026-11-02", "2026-11-03"), # 2
self._approved(owner, "오전반차", "2026-11-04", "2026-11-04"), # 0.5
self._approved(owner, "병가", "2026-11-05", "2026-11-06"), # 차감 안 함
self._approved(owner, "경조", "2026-11-09", "2026-11-09"), # 차감 안 함
self._approved(owner, "연차", "2026-12-30", "2027-01-04"), # 12/30·31 = 2, 1/4 = 1 (1/1 신정·주말 뺌)
]
st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함
self._approved(owner, "연차", "2026-11-02", "2026-11-03") # 2
self._approved(owner, "오전반차", "2026-11-04", "2026-11-04") # 0.5
self._approved(owner, "병가", "2026-11-05", "2026-11-06") # 차감 안 함
self._approved(owner, "경조", "2026-11-09", "2026-11-09") # 차감 안 함
self._approved(owner, "연차", "2026-12-30", "2027-01-04") # 12/30·31·1/4 = 3 (1/1 신정·주말 뺌)
st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함
payload={"vacation_type": "연차", "start_date": "2026-11-10", "end_date": "2026-11-10",
"start_half": "full", "end_half": "full", "reason": ""})
try:
self.assertEqual(st.used_days(user_email=owner, year=2026), 4.5)
self.assertEqual(st.used_days(user_email=owner, year=2027), 1.0)
st.save_balances(year=2026, rows=[{"user_email": owner, "total_days": 15, "memo": "입사 2020"}])
s26 = st.balance_summary(user_email=owner, year=2026)
self.assertEqual((s26["total_days"], s26["used_days"], s26["remaining_days"]), (15.0, 4.5, 10.5))
s27 = st.balance_summary(user_email=owner, year=2027) # 다음 해로 넘어가지 않음(등록 전 = 0)
self.assertEqual((s27["total_days"], s27["remaining_days"]), (0.0, -1.0))
ev = st.usage_events(user_email=owner)
self.assertEqual(round(sum(a for d, a in ev), 2), 5.5)
self.assertEqual((st.used_days(user_email=owner, year=2026), st.used_days(user_email=owner, year=2027)), (4.5, 1.0))
# 입사 2020-03-02 → 2026-03-02 근속 6년 17일(2027-03-01 까지) — 12/31 에 안 없어짐
st.save_balances(rows=[{"user_email": owner, "total_days": None, "memo": "", "hire_date": "2020-03-02"}],
as_of=date(2026, 10, 27))
s1 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27))
self.assertEqual((s1["period_start"], s1["period_end"], s1["granted"], s1["used"], s1["available"]),
("2026-03-02", "2027-03-01", 17.0, 5.5, 11.5)) # 앞날짜 승인 휴가도 이미 차감
self.assertEqual(s1["expiring"], {"date": "2027-03-01", "days": 11.5})
s2 = st.balance_summary(user_email=owner, as_of=date(2027, 2, 1)) # 해가 바뀌어도 그대로
self.assertEqual(s2["available"], 11.5)
s3 = st.balance_summary(user_email=owner, as_of=date(2027, 3, 2)) # 근속 7년 18일 새로
self.assertEqual((s3["granted"], s3["available"], s3["used"]), (18.0, 18.0, 0.0))
# 직접 입력 = 이번 연차 기간(2026-03-02 시작 → 2026 줄) 법정 대신
st.save_balances(rows=[{"user_email": owner, "total_days": 20, "memo": "회사 기준"}], as_of=date(2026, 10, 27))
self.assertEqual(st.get_balance(user_email=owner, year=2026)["total_days"], 20.0)
s4 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27))
self.assertEqual((s4["granted"], s4["available"], s4["manual_total"], s4["memo"]), (20.0, 14.5, 20.0, "회사 기준"))
finally:
for r in st.list_for(owner):
st.hard_delete(request_id=r["id"], user_email=owner, is_admin=True)
def test_save_balances_validates_all_or_nothing(self):
from datetime import date
st = self.st
a, b = f"a-{uuid.uuid4().hex[:6]}@test.local", f"b-{uuid.uuid4().hex[:6]}@test.local"
on = date(2031, 5, 1) # 입사일 없음 → 직접 입력은 그해(2031) 줄
with self.assertRaises(ValueError):
st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}])
self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함
self.assertEqual(st.save_balances(year=2031, rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "},
{"user_email": b, "total_days": 0}]), 2)
st.save_balances(rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}], as_of=on)
self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함
self.assertEqual(st.save_balances(rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "},
{"user_email": b, "total_days": 0}], as_of=on), 2)
self.assertEqual((st.get_balance(user_email=a, year=2031)["total_days"], st.get_balance(user_email=a, year=2031)["memo"]),
(15.5, "x"))
st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 20, "memo": ""}]) # 덮어쓰기
st.save_balances(rows=[{"user_email": a, "total_days": 20, "memo": ""}], as_of=on) # 덮어쓰기
self.assertEqual(st.get_balance(user_email=a, year=2031)["total_days"], 20.0)
class LegalAnnualLeaveTests(unittest.TestCase):
"""근로기준법 제60조 — 입사일 기준으로 생기는 연차를 그해에 모은다(2026-10-27, DB 없음)."""
class LeaveRulesTests(unittest.TestCase):
"""근로기준법 제60조 — 입사일 기준, 연차마다 쓸 수 있는 기한(2026-10-27, 12/31 소멸 없음, DB 없음)."""
def test_rules(self):
from datetime import date
def test_grants_periods_and_usage_units(self):
from datetime import date as D
from app.modules.vacation.store import add_months, legal_annual_leave as L
from app.modules.vacation.store import add_months, compute_days, leave_grants, leave_period, usage_units
self.assertEqual(add_months(date(2026, 1, 31), 1), date(2026, 2, 28))
self.assertEqual(add_months(date(2024, 2, 29), 12), date(2025, 2, 28))
# 입사 1년 미만 = 1개월마다 1일, 입사일이 돌아오면 15일 — 2025-03-01 입사
self.assertEqual(L(date(2025, 3, 1), 2025)["days"], 9.0) # 4/1 ~ 12/1
r = L(date(2025, 3, 1), 2026)
self.assertEqual((r["days"], r["service_years"]), (17.0, 1)) # 1/1·2/1(월 1일) + 3/1 근속 1년 15일
self.assertEqual([i["date"] for i in r["items"]], ["2026-01-01", "2026-02-01", "2026-03-01"])
self.assertEqual(L(date(2025, 3, 1), 2027)["days"], 15.0) # 근속 2년 = 15일
# 3년 이상 = 최초 1년을 넘는 근속 2년마다 1일, 최대 25일
self.assertEqual(L(date(2023, 5, 10), 2026)["days"], 16.0) # 근속 3년
self.assertEqual(L(date(2020, 3, 2), 2026)["days"], 17.0) # 근속 6년 = 15 + 2
self.assertEqual(L(date(2001, 1, 1), 2026)["days"], 25.0) # 근속 25년 → 한도 25
self.assertEqual(L(date(2027, 1, 2), 2026)["days"], 0.0) # 아직 입사 전
self.assertEqual(L(None, 2026)["days"], 0.0)
self.assertEqual(add_months(D(2026, 1, 31), 1), D(2026, 2, 28))
self.assertEqual(add_months(D(2024, 2, 29), 12), D(2025, 2, 28))
g = leave_grants(D(2026, 10, 12), D(2027, 10, 12))
self.assertEqual([(x["date"].isoformat(), x["days"], x["expires"].isoformat()) for x in g[:2]],
[("2026-11-12", 1.0, "2027-10-11"), ("2026-12-12", 1.0, "2027-10-11")]) # 월 1일 = 입사일부터 1년까지
self.assertEqual(len([x for x in g if x["period"] == 0]), 11)
self.assertEqual((g[-1]["date"], g[-1]["days"], g[-1]["expires"]), (D(2027, 10, 12), 15.0, D(2028, 10, 11)))
days = {x["period"]: x["days"] for x in leave_grants(D(2001, 1, 1), D(2026, 12, 31)) if x["period"]}
self.assertEqual((days[1], days[2], days[3], days[5], days[6], days[21], days[25]), (15.0, 15.0, 16.0, 17.0, 17.0, 25.0, 25.0))
self.assertEqual(leave_period(D(2026, 10, 12), D(2026, 10, 26)), (0, D(2026, 10, 12), D(2027, 10, 11)))
self.assertEqual(leave_period(D(2020, 3, 2), D(2026, 10, 26)), (6, D(2026, 3, 2), D(2027, 3, 1)))
hol = {"2027-01-01"}
for kw in ({"start_date": D(2026, 12, 30), "end_date": D(2027, 1, 4), "start_half": "pm", "end_half": "am"},
{"start_date": D(2026, 11, 4), "end_date": D(2026, 11, 4), "vacation_type": "오전반차"},
{"start_date": D(2026, 11, 7), "end_date": D(2026, 11, 8)}):
self.assertEqual(sum(a for d, a in usage_units(holidays=hol, **kw)), compute_days(holidays=hol, **kw), kw)
def test_status_oct12_hire(self):
"""10/12 입사 — 오늘(10/26) 쓸 수 있는 연차 0, 이번 기간(~2027-10-11) 11일 생김, 1년 되면 15일(~2028-10-11)."""
from datetime import date as D
from app.modules.vacation.store import leave_status as S
h = D(2026, 10, 12)
r = S(hire=h, as_of=D(2026, 10, 26), usages=[])
self.assertEqual((r["granted"], r["granted_so_far"], r["upcoming"], r["available"], r["expiring"]), (11.0, 0.0, 11.0, 0.0, None))
r = S(hire=h, as_of=D(2026, 12, 20), usages=[(D(2026, 12, 15), 1.0)])
self.assertEqual((r["granted_so_far"], r["used"], r["available"], r["expiring"]), (2.0, 1.0, 1.0, {"date": "2027-10-11", "days": 1.0}))
r = S(hire=h, as_of=D(2027, 1, 5), usages=[(D(2026, 12, 15), 1.0)]) # 해가 바뀌어도 그대로 + 1/12 전
self.assertEqual(r["available"], 1.0)
r = S(hire=h, as_of=D(2027, 10, 12), usages=[(D(2026, 12, 15), 1.0)]) # 남은 월차 10일은 10/11 에 소멸
self.assertEqual((r["service_years"], r["granted"], r["available"], r["expiring"]), (1, 15.0, 15.0, {"date": "2028-10-11", "days": 15.0}))
r = S(hire=h, as_of=D(2026, 10, 26), usages=[(D(2026, 10, 20), 1.0)]) # 생기기 전에 씀 = 당겨 씀
self.assertEqual(r["available"], -1.0)
def test_status_first_expiring_used_first_prior_and_no_hire(self):
from datetime import date as D
from app.modules.vacation.store import leave_status as S
# 2025-11-01 입사: 2026-10-01 까지 월차(~2026-10-31), 2026-11-01 15일 — 10/30 에 쓴 1일은 곧 소멸할 월차에서
h = D(2025, 11, 1)
r = S(hire=h, as_of=D(2026, 10, 30), usages=[(D(2026, 10, 30), 1.0)])
self.assertEqual((r["available"], r["expiring"]), (10.0, {"date": "2026-10-31", "days": 10.0}))
r = S(hire=h, as_of=D(2026, 11, 2), usages=[(D(2026, 10, 30), 1.0)])
self.assertEqual((r["available"], r["used"]), (15.0, 0.0)) # 새 기간 15일 그대로
# 시스템 전 사용 = 도입일(2026-10-27)에 쓴 것으로
r = S(hire=D(2020, 3, 2), as_of=D(2026, 10, 28), usages=[], prior=4.5)
self.assertEqual((r["used"], r["available"]), (4.5, 12.5))
# 입사일 없음 + 직접 입력 = 그해 연차(소멸일 없음 — 입사일을 넣어야 계산)
r = S(hire=None, as_of=D(2026, 10, 28), usages=[(D(2026, 5, 4), 1.0), (D(2025, 5, 4), 1.0)], override=15)
self.assertEqual((r["granted"], r["used"], r["available"], r["expiring"], r["has_hire"]), (15.0, 1.0, 14.0, None, False))
self.assertEqual(S(hire=None, as_of=D(2026, 10, 28), usages=[])["available"], 0.0)
@unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정")
class VacationHireDBTests(unittest.TestCase):
"""002 — 입사일·시스템 전 사용·연차 비우면 법정(실제 PostgreSQL, 002 적용 DB)."""
"""002 — 입사일·시스템 전 사용·직접 입력(실제 PostgreSQL, 002 적용 DB)."""
@classmethod
def setUpClass(cls):
@@ -185,33 +240,36 @@ class VacationHireDBTests(unittest.TestCase):
def tearDownClass(cls):
cls.st.close()
def test_hire_legal_manual_prior(self):
def test_hire_prior_and_override_rows(self):
from datetime import date
st = self.st
on = date(2026, 10, 28)
self.assertTrue(st.hire_ready())
a, b = f"h-{uuid.uuid4().hex[:6]}@test.local", f"h-{uuid.uuid4().hex[:6]}@test.local"
n = st.save_balances(year=2026, by="admin@test.local", rows=[
{"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2025-03-01"},
{"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2020-03-02"},
n = st.save_balances(by="admin@test.local", as_of=on, rows=[
{"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2026-10-12"},
{"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2024-11-15"},
])
self.assertEqual(n, 2)
self.assertEqual(st.hire_dates()[a], "2025-03-01")
sa = st.balance_summary(user_email=a, year=2026)
self.assertEqual((sa["total_days"], sa["manual_total"], sa["legal_days"], sa["prior_used"], sa["remaining_days"]),
(17.0, None, 17.0, 3.5, 13.5)) # 법정 17 − 시스템 전 3.5
sb = st.balance_summary(user_email=b, year=2026)
self.assertEqual((sb["total_days"], sb["legal_days"], sb["remaining_days"], sb["service_years"]), (20.0, 17.0, 20.0, 6))
# 2027 — 아무것도 등록 안 해도 입사일로 법정 연차(이월 없음)
self.assertEqual(st.balance_summary(user_email=a, year=2027)["total_days"], 15.0)
# 입사일 지우기("") · 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}])
self.assertEqual(st.hire_dates()[a], "2025-03-01")
self.assertEqual(st.hire_dates()[a], "2026-10-12")
sa = st.balance_summary(user_email=a, as_of=on) # 10/12 입사 — 아직 생긴 연차 없음, 시스템 전 사용 3.5 = 당겨 씀
self.assertEqual((sa["granted"], sa["granted_so_far"], sa["available"], sa["prior_used"]), (11.0, 0.0, -3.5, 3.5))
# b: 2025-11-15 근속 1년 기간(2025 줄)에 직접 입력 20, 시스템 전 사용은 2026 줄
self.assertEqual(st.get_balance(user_email=b, year=2025)["total_days"], 20.0)
sb = st.balance_summary(user_email=b, as_of=on)
self.assertEqual((sb["period_start"], sb["granted"], sb["available"], sb["key_year"]), ("2025-11-15", 20.0, 20.0, 2025))
self.assertEqual(st.balance_summary(user_email=b, as_of=date(2026, 11, 16))["granted"], 15.0) # 다음 기간 = 법정 15
# 입사일 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 · "" = 지움
st.save_balances(rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2026-10-12")
with self.assertRaises(ValueError):
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""},
{"user_email": b, "total_days": None, "hire_date": "2020-13-01"}])
self.assertEqual(st.hire_dates()[a], "2025-03-01")
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""}])
st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""},
{"user_email": b, "total_days": None, "hire_date": "2020-13-01"}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2026-10-12")
st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""}], as_of=on)
self.assertNotIn(a, st.hire_dates())
self.assertEqual(st.balance_summary(user_email=a, year=2026)["total_days"], 0.0)
self.assertEqual(st.balance_summary(user_email=a, as_of=on)["available"], 0.0)
if __name__ == "__main__":
+20 -16
View File
@@ -205,14 +205,18 @@ class Store:
return True
def hire_dates(self):
return {}
def balance_summary(self, user_email, year, hire_date=None):
bal = {b["user_email"]: b for b in self.list_balances(year)}.get(user_email)
used = self.used_days(user_email, year)
def balance_summary(self, user_email, as_of=None, hire_date=None): # db.balance_summary 모양(입사일 기준, 가짜 계산)
from app.timezone import today_kst
as_of = as_of or today_kst()
bal = {b["user_email"]: b for b in self.list_balances(as_of.year)}.get(user_email)
used = self.used_days(user_email, as_of.year)
manual = bal["total_days"] if bal else None
total = manual if manual is not None else 0.0
return {"year": year, "total_days": total, "manual_total": manual, "legal_days": None, "legal_items": [],
"service_years": 0, "hire_date": hire_date or "", "prior_used": 0.0, "erp_used": used,
"used_days": used, "remaining_days": total - used, "memo": bal["memo"] if bal else ""}
return {"has_hire": bool(hire_date), "service_years": 0, "period_start": f"{as_of.year}-01-01" if manual is not None else "",
"period_end": f"{as_of.year}-12-31" if manual is not None else "", "granted": total, "granted_so_far": total,
"upcoming": 0.0, "used": used, "available": total - used, "expiring": None, "grants": [], "as_of": as_of.isoformat(),
"hire_date": hire_date or "", "key_year": as_of.year, "manual_total": manual, "prior_used": 0.0,
"memo": bal["memo"] if bal else "", "total_days": total, "used_days": used, "remaining_days": total - used}
def holiday_map(self, date_from, date_to): # 국경일 + 설정 공휴일(db.holiday_map) — 해마다 한글날만
return {f"{y}-10-09": "한글날" for y in range(int(date_from[:4]), int(date_to[:4]) + 1)}
@@ -368,8 +372,8 @@ class Store2(Store):
[{"user_email": "kim@test.local", "year": year, "total_days": 12, "memo": ""}]
def used_days(self, user_email, year):
return {"lee@test.local": 4.5}.get(user_email, 0.0)
def save_balances(self, year, rows, by=""):
saved.update(year=year, rows=rows, by=by); return len(rows)
def save_balances(self, rows, by="", as_of=None):
saved.update(rows=rows, by=by); return len(rows)
def hire_dates(self):
return {"lee@test.local": "2020-03-02"}
def list_holidays(self, year=None):
@@ -388,7 +392,7 @@ def body(c):
r = c.get("/vacation/options?year=2026")
assert r.status_code == 200, r.status_code
t = r.text
assert 'id="balances"' in t and "2026년 · 참여자 4명" in t, t[t.find("잔여 연차"):t.find("잔여 연차") + 200]
assert 'id="balances"' in t and "기준 · 참여자 4명" in t, t[t.find("잔여 연차"):t.find("잔여 연차") + 200]
for u in users: # 참여자 전원 미리(이름 + 이메일 + 줄마다 칸)
assert f'name="email" value="{u["email"]}"' in t, u["email"]
assert 'src="https://img.test/lee.png"' in t # 사진 있으면 사진, 없으면 첫 글자
@@ -401,22 +405,22 @@ def body(c):
assert "법정 연차" in t and "시스템 전 사용" in t and "근로기준법 제60조" in t
assert 'value="15"' in row and ">4.5<" in row and ">10.5<" in row and 'value="입사 2020"' in row, row
j = t.index('name="email" value="kim@test.local"')
assert 'placeholder="12"' in t[j:j + 600], t[j:j + 600] # 올해 없음 → 작년 연차를 회색 참고
assert "2026.12.31 에 소멸" in t and "승인되면" in t
assert "입사일 기준" in t and "12/31 에 없어지지 않음" in t and "승인되면" in t and "먼저 소멸" in t
assert "12.31 에 소멸" not in t and "12.31 소멸" not in t
# 저장 — 빈 칸은 건너뜀, 연도·이메일·메모 그대로
# 저장 — 줄마다 입사일·연차(빈 칸 = 법정)·시스템 전 사용·메모, 저장한 사람
r = c.post("/vacation/options/balances", data={"year": "2026", "email": ["lee@test.local", "kim@test.local", "chip@test.local"],
"hire": ["2020-03-02", "", "2025-03-01"], "total": ["16", "", ""],
"prior": ["", "2.5", ""], "memo": ["a", "b", "c"]})
assert r.status_code == 303 and "year=2026" in r.headers["location"], r.status_code
assert saved == {"year": 2026, "by": "admin@test.local", "rows": [
assert r.status_code == 303 and r.headers["location"].startswith("/vacation/options?msg="), r.status_code
assert saved == {"by": "admin@test.local", "rows": [
{"user_email": "lee@test.local", "total_days": 16.0, "prior_used": None, "memo": "a", "hire_date": "2020-03-02"},
{"user_email": "kim@test.local", "total_days": None, "prior_used": 2.5, "memo": "b", "hire_date": ""},
{"user_email": "chip@test.local", "total_days": None, "prior_used": None, "memo": "c", "hire_date": "2025-03-01"}]}, saved
bad = {"year": "2026", "email": ["lee@test.local"], "hire": [""], "prior": [""], "memo": [""]}
assert c.post("/vacation/options/balances", data=dict(bad, total=["x"])).status_code == 400
assert c.post("/vacation/options/balances", data={"year": "2026", "email": ["lee@test.local"], "total": ["1"], "memo": [""]}).status_code == 400 # 칸 수
assert "시스템 전 사용</th>" not in c.get("/vacation/options?year=2027").text # 도입 해(2026)만
assert "시스템 전 사용</th>" in c.get("/vacation/options").text # 도입 해(2026)·다음 해까지 칸
# 승인자(옵션 미지정 → 휴가 승인 권한 chip)는 잔여 연차도 보고 저장
who["u"] = chip
assert 'id="balances"' in c.get("/vacation/options").text
@@ -435,11 +439,11 @@ def body(c):
("/vacation/settings/holidays/1/delete", {}),
("/vacation/settings/balances", {"user_email": "a@test.local", "year": "2026", "total_days": "1"})):
assert c.post(url, data=data).status_code in (404, 405), url
# 달력 — 국경일·대체공휴일 이름이 날짜 아래, 그 주는 has-hol, 잔여 옆 12/31 소멸
# 달력 — 국경일·대체공휴일 이름이 날짜 아래, 그 주는 has-hol, 내 연차 = 입사일 기준(12/31 소멸 없음)
t = c.get("/vacation/?year=2026&month=10").text
assert '<span class="vac-hol-name">개천절</span>' in t and '<span class="vac-hol-name">개천절 대체</span>' in t
assert '<span class="vac-hol-name">한글날</span>' in t and t.count("has-hol") == 2, t.count("has-hol")
assert "2026.12.31 소멸" in t
assert "12.31 소멸" not in t and "입사일 미등록(옵션)" in t and "발생 <strong>" in t
assert 'href="/vacation/settings' not in t and ">설정</a>" not in t and 'href="/vacation/options"' in t # 설정 버튼 없음
print("OK")
run(body)