diff --git a/app/modules/vacation/CLAUDE.md b/app/modules/vacation/CLAUDE.md
index db8184f..cf7483f 100644
--- a/app/modules/vacation/CLAUDE.md
+++ b/app/modules/vacation/CLAUDE.md
@@ -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`)
diff --git a/app/modules/vacation/db.py b/app/modules/vacation/db.py
index 7425037..2a88d47 100644
--- a/app/modules/vacation/db.py
+++ b/app/modules/vacation/db.py
@@ -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"],
}
# ════════════════════════════════════════════════════════════
diff --git a/app/modules/vacation/router.py b/app/modules/vacation/router.py
index f283870..d09ea10 100644
--- a/app/modules/vacation/router.py
+++ b/app/modules/vacation/router.py
@@ -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,
},
)
diff --git a/app/modules/vacation/store.py b/app/modules/vacation/store.py
index cc39c2c..d778f59 100644
--- a/app/modules/vacation/store.py
+++ b/app/modules/vacation/store.py
@@ -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
diff --git a/app/modules/vacation/templates/vacation/detail.html b/app/modules/vacation/templates/vacation/detail.html
index d34b3f4..9746a95 100644
--- a/app/modules/vacation/templates/vacation/detail.html
+++ b/app/modules/vacation/templates/vacation/detail.html
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
-{% block head_extra %}{% endblock %}
+{% block head_extra %}{% endblock %}
{% block content %}
diff --git a/app/modules/vacation/templates/vacation/form.html b/app/modules/vacation/templates/vacation/form.html
index 565e3d4..b799163 100644
--- a/app/modules/vacation/templates/vacation/form.html
+++ b/app/modules/vacation/templates/vacation/form.html
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
-{% block head_extra %}
+{% block head_extra %}
{#- 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop) -#}
{% endblock %}
@@ -73,4 +73,4 @@
{% block scripts %}
-{% endblock %}
+{% endblock %}
diff --git a/app/modules/vacation/templates/vacation/index.html b/app/modules/vacation/templates/vacation/index.html
index dd6bf25..c45aa21 100644
--- a/app/modules/vacation/templates/vacation/index.html
+++ b/app/modules/vacation/templates/vacation/index.html
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
-{% block head_extra %}{% endblock %}
+{% block head_extra %}{% endblock %}
{% block content %}
@@ -19,13 +19,15 @@
옵션
- 총 {{ balance.total_days }}
+ {#- 내 연차 — 입사일 기준(2026-10-27, 12/31 소멸 없음): 이번 연차 기간에 생기는 연차·쓴 날·지금 쓸 수 있는 잔여·먼저 소멸할 잔여 -#}
+ {% set gt = '%g' % balance.granted_so_far ~ ((' (+%g 예정)' % balance.upcoming) if balance.upcoming else '') %}
+ 발생 {{ gt }}·
- 사용 {{ balance.used_days }}
+ 사용 {{ '%g' % balance.used_days }}·
- 잔여 {{ balance.remaining_days }}
- {#- 연차는 그해 것만 — 12/31 소멸, 다음 해로 넘어가지 않음(2026-10-27). 사용 = 승인된 연차·반차 -#}
- {{ year }}년 · {{ year }}.12.31 소멸
+ 잔여 {{ '%g' % balance.remaining_days }}
+ {% if balance.expiring %}{{ balance.expiring.date | replace('-', '.') }} 소멸 {{ '%g' % balance.expiring.days }}일
+ {% elif not balance.has_hire and balance.manual_total is none %}입사일 미등록(옵션){% endif %}
diff --git a/app/modules/vacation/templates/vacation/options.html b/app/modules/vacation/templates/vacation/options.html
index 5b08844..26f1b59 100644
--- a/app/modules/vacation/templates/vacation/options.html
+++ b/app/modules/vacation/templates/vacation/options.html
@@ -2,7 +2,7 @@
{#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나).
메일: 제출 = 승인자·통보자, 승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
-{% block head_extra %}
+{% block head_extra %}
{% endblock %}
@@ -63,27 +63,24 @@
{#- 잔여 연차(2026-10-27, 설정에서 옮김) — 참여자(휴가 모듈 사용자) 전원을 미리 보여 주고 줄마다 연차 입력. 관리자·승인자·통보자만 보임·저장. -#}