Merge branch 'feat/vacation-hire-based-expiry'

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-26 16:27:56 +09:00
16 changed files with 500 additions and 311 deletions
+18 -15
View File
@@ -19,24 +19,27 @@
`vacation_holidays` 표(예전 seed·직접 넣은 줄)는 남아 있지만 읽지 않는다. 예전엔 그 표만 써서 seed 가 없는 해·제헌절은 근무일로 셌다. `vacation_holidays` 표(예전 seed·직접 넣은 줄)는 남아 있지만 읽지 않는다. 예전엔 그 표만 써서 seed 가 없는 해·제헌절은 근무일로 셌다.
이미 저장된 신청의 일수는 그대로(새로 저장·수정할 때 다시 계산). 이미 저장된 신청의 일수는 그대로(새로 저장·수정할 때 다시 계산).
- 메인 달력: 공휴일 이름이 **날짜 숫자 아래**(`.vac-hol-name`), 그 주는 `.vac-week.has-hol`(휴가 막대 top 38 → 54px). - 메인 달력: 공휴일 이름이 **날짜 숫자 아래**(`.vac-hol-name`), 그 주는 `.vac-week.has-hol`(휴가 막대 top 38 → 54px).
- **연차 차감** = 승인된 `DEDUCT_TYPES`(연차·오전반차·오후반차)만(`db.used_days`, 병가·경조·대체휴무·기타는 안 뺌 — 예전엔 모든 승인 휴가를 뺐다), - **연차 = 입사일 기준, 12/31 소멸 없음**(2026-10-27 — 그 전 판의 "그해 1/1~12/31, 12/31 소멸"은 근로기준법보다 짧아 없앴다).
제출·작성중은 안 뺌. 해를 넘는 신청은 해마다 그 해 날짜만큼 나눔(예전엔 시작일 연도에 통째로). **연차는 그해 것만 — 12/31 소멸**, 다음 해로 넘기지 않음 `store.leave_grants`(연차마다 생긴 날·쓸 수 있는 마지막 날) · `leave_period`(입사일/기념일 ~ 다음 기념일 전날) · `leave_status` 한 곳:
(`vacation_balances` 가 연도별, 새해는 새로 등록. 달력 잔여 옆 "yyyy.12.31 소멸"). · 입사 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 규칙,
`POST /vacation/options/balances` 한꺼번에(`db.save_balances` 한 트랜잭션 — 0~365·0.5일 단위, 빈 칸 = 그대로). 예전 `POST /settings/balances` 는 없앴다. 병가·경조·대체휴무·기타·제출·작성중은 안 뺌, 앞날짜 승인도 차감). 쓴 날마다 그날 쓸 수 있는 연차 중 **먼저 소멸하는 것부터** 빼고,
생기기 전에 쓰면 다음 연차를 당겨 씀(지금 잔여가 음수).
· 화면 = 지금 연차 기간·이번 기간에 생기는 연차(오늘까지 +앞으로)·이번 기간 쓴 날·**오늘 쓸 수 있는 잔여**·먼저 소멸할 잔여(날짜·일수).
달력 위 내 연차 줄도 같은 값(`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`(사람마다 하나). - 옵션 잔여 연차 표 **이름 옆 입사일** = 날짜 버튼(`ErpDatePop.enhance`, « » 1년씩·직접 입력 2020-03-02 Enter, 지우기) → `vacation_employees`(사람마다 하나).
- **법정 연차** = `store.legal_annual_leave(입사일, 연도)` — 근로기준법 제60조를 **입사일 기준으로 생기는 날을 그해(1/1~12/31)에 모음** 입사일을 고르면 화면(vacation.js)이 같은 규칙으로 근속·연차 기간·생기는 연차를 바로 다시 보여 주고, 사용·잔여·소멸은 "저장 후"(서버가 휴가를 연차마다 나눠 계산).
(12/31 소멸 규칙과 맞춤): 입사 1년 미만 = 입사일 + 1~11개월마다 1일, 입사일이 돌아올 때마다(근속 n년) `min(25, 15 + (n−1)//2)`. - **직접 입력** = 그 사람의 **지금 연차 기간** 연차를 법정 대신 그 값으로(비우면 법정) — `vacation_balances` 의 **그 기간이 시작한 해** 줄
출근율(개근·80%)은 따지지 않음(모두 채운 것으로). 화면(vacation.js)도 같은 계산으로 입사일을 고르는 즉시 근속·법정·잔여를 다시 보여 줌. `total_days`(`db.override_year`, 저장 때 바꾼 입사일로 서버가 계산). 입사일 없이 직접 입력만 있으면 그해 연차로 셈(소멸일 없음 — 입사일을 넣어야 계산).
- 연차 칸 = 직접 입력(값이 있으면 그 값), **비우면 법정 연차**(`vacation_balances.total_days` NULL). 입사일도 연차도 없으면 0. - **시스템 전 사용**(`prior_used`) — 이 시스템을 쓰기 전(2026)에 이미 쓴 연차, `SYSTEM_START_YEAR`(2026) 줄에. 도입일 `SYSTEM_START_DATE`(2026-10-27)에 쓴 것으로
- **시스템 전 사용**(`prior_used`) — 이 시스템을 쓰기 전에 그해 이미 쓴 연차, **도입 해(`store.SYSTEM_START_YEAR` = 2026)만** 표에 칸. 쳐서 그날 쓸 수 있는 연차에서 뺀다. 표 칸은 도입 다음 해까지(또는 값이 남아 있으면).
- 잔여 = 총(직접 또는 법정) − 시스템 전 사용 − 승인된 연차·반차 — `db.balance_summary` 한 곳(달력 잔여·옵션 표 모두). - 저장 줄마다 email·hire·total·prior·memo(칸 수가 다르면 400, 한 줄이라도 틀리면 전부 안 함). 002 전이면 입사일·시스템 전 사용은 무시(입사일 칸은 숨김 칸, 안내 문구).
- 저장 `POST /vacation/options/balances` 줄마다 email·hire·total·prior·memo(칸 수가 다르면 400, 한 줄이라도 틀리면 전부 안 함 — `db.save_balances`).
002 전이면 입사일·시스템 전 사용은 무시(입사일 칸은 숨김 칸, 안내 문구), 연차 직접 입력만 예전처럼.
## 휴가 옵션 · 휴가 메일 (2026-10-27, 마이그레이션 `vacation_db_001_options_mail.sql`) ## 휴가 옵션 · 휴가 메일 (2026-10-27, 마이그레이션 `vacation_db_001_options_mail.sql`)
+71 -58
View File
@@ -15,7 +15,7 @@
from __future__ import annotations from __future__ import annotations
import uuid import uuid
from datetime import date, datetime, timedelta, timezone from datetime import date, datetime, timezone
from decimal import Decimal from decimal import Decimal
from typing import Any from typing import Any
@@ -25,7 +25,8 @@ from psycopg_pool import ConnectionPool
from app.timezone import KST from app.timezone import KST
from .store import ( 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() ).fetchall()
return [self._balance_serialize(r) for r in rows] return [self._balance_serialize(r) for r in rows]
def used_days(self, *, user_email: str, year: int) -> float: def usage_events(self, *, user_email: str) -> list[tuple[date, float]]:
"""그해 사용 연차 = 승인된 연차·반차(DEDUCT_TYPES)의 그해 날짜분 합계(2026-10-27). """쓴 연차 = 승인된 연차·오전반차·오후반차(DEDUCT_TYPES)를 날짜별 [(날짜, 1|0.5)]로(store.usage_units — compute_days 와 같은 규칙).
병가·경조·대체휴무·기타는 빼지 않는다. 앞날짜로 승인된 휴가도 넣는다(승인되면 차감). 어느 연차에서 빼는지는 store.leave_status."""
병가·경조·대체휴무·기타는 빼지 않는다. 해를 넘는 신청(12/30~1/2)은 해마다 그 해 날짜만큼 나눠 센다
(예전엔 모든 승인 휴가를 시작일 연도에 통째로 셌다). 그해 안에 다 들어가는 신청은 저장된 일수 그대로.
"""
y0, y1 = date(year, 1, 1), date(year, 12, 31)
with self._pool.connection() as conn: with self._pool.connection() as conn:
rows = conn.execute( rows = conn.execute(
"SELECT start_date, end_date, start_half, end_half, vacation_type, days FROM vacation_requests " "SELECT start_date, end_date, start_half, end_half, vacation_type FROM vacation_requests "
"WHERE owner = %s AND status = '승인' AND vacation_type = ANY(%s) " "WHERE owner = %s AND status = '승인' AND vacation_type = ANY(%s) ORDER BY start_date",
"AND start_date <= %s AND end_date >= %s", (user_email.lower().strip(), list(DEDUCT_TYPES)),
(user_email.lower().strip(), list(DEDUCT_TYPES), y1, y0),
).fetchall() ).fetchall()
total = 0.0 if not rows:
holidays: set[str] | None = None 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: for r in rows:
sd, ed = r["start_date"], r["end_date"] out += usage_units(start_date=r["start_date"], end_date=r["end_date"], start_half=r["start_half"],
if sd >= y0 and ed <= y1: end_half=r["end_half"], vacation_type=r["vacation_type"], holidays=holidays)
total += self._num(r["days"]) return out
continue
if holidays is None:
holidays = self.red_holiday_set(date_from=(y0 - timedelta(days=7)).isoformat(),
date_to=(y1 + timedelta(days=7)).isoformat())
total += compute_days(
start_date=max(sd, y0), end_date=min(ed, y1),
start_half=r["start_half"] if sd >= y0 else "full",
end_half=r["end_half"] if ed <= y1 else "full",
vacation_type=r["vacation_type"], holidays=holidays,
)
return round(total, 2)
def save_balances(self, *, year: int, rows: list[dict[str, Any]], by: str = "") -> int: 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, row = {user_email, total_days(None = 입사일 기준 법정 연차), prior_used(시스템 전 사용, None = 0), memo,
hire_date("YYYY-MM-DD" | "" = 지움 | 키 없음 = 그대로)}. 002 전이면 입사일·시스템 전 사용은 무시하고 hire_date("YYYY-MM-DD" | "" = 지움 | 키 없음 = 그대로)}.
total_days 가 없는 줄은 건너뛴다(예전처럼). 직접 입력·메모는 그 사람의 **지금 연차 기간이 시작한 해** 줄에(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() v002 = self.hire_ready()
old_hires = self.hire_dates()
clean = [] clean = []
for r in rows: for r in rows:
email = (r.get("user_email") or "").lower().strip() email = (r.get("user_email") or "").lower().strip()
@@ -220,24 +218,30 @@ class VacationDBStore:
raise ValueError(f"입사일이 올바르지 않습니다: {email} {hv}") raise ValueError(f"입사일이 올바르지 않습니다: {email} {hv}")
if not v002 and total is None: if not v002 and total is None:
continue 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), 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() who = (by or "").lower().strip()
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
for email, total, prior, memo, hire in clean: for email, total, prior, memo, hire, key_year in clean:
if not v002: if not v002:
conn.execute( conn.execute(
"INSERT INTO vacation_balances (user_email, year, total_days, memo) VALUES (%s, %s, %s, %s) " "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", "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 continue
conn.execute( conn.execute(
"INSERT INTO vacation_balances (user_email, year, total_days, prior_used, memo) VALUES (%s, %s, %s, %s, %s) " "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, " "ON CONFLICT (user_email, year) DO UPDATE SET total_days = EXCLUDED.total_days, memo = EXCLUDED.memo",
"prior_used = EXCLUDED.prior_used, memo = EXCLUDED.memo", (email, key_year, total, memo),
(email, year, total, prior, 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 ...: if hire is not ...:
conn.execute( 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() 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} 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]: @staticmethod
"""그해 연차(2026-10-27) — 총 = 직접 입력(있으면) 아니면 입사일 기준 법정 연차(근로기준법 제60조, store.legal_annual_leave), def override_year(hire_date: str | None, as_of: date) -> int:
사용 = 시스템 전 사용(prior_used, 002) + 승인된 연차·반차(used_days), 잔여 = 총 − 사용. """직접 입력 연차를 둘 해 = 지금 연차 기간이 시작한 해(입사일 없으면 as_of 의 해) — vacation_balances.year 키."""
hire_date 를 넘기면(목록에서 한 번에 읽은 값, None = 없음) 다시 읽지 않는다.""" 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() 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 ...: if hire_date is ...:
hire_date = self.hire_dates().get(email) 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 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((prior_row or {}).get("prior_used") or 0)
prior = float(bal.get("prior_used") or 0) if bal else 0.0 st = leave_status(hire=date.fromisoformat(hire_date) if hire_date else None, as_of=as_of,
erp_used = self.used_days(user_email=email, year=year) usages=self.usage_events(user_email=email), prior=prior, override=manual)
return { return {
"year": year, **st,
"total_days": round(float(total), 2), "as_of": as_of.isoformat(),
"manual_total": manual,
"legal_days": legal["days"] if hire_date else None,
"legal_items": legal["items"],
"service_years": legal["service_years"],
"hire_date": hire_date or "", "hire_date": hire_date or "",
"key_year": key_year,
"manual_total": manual,
"prior_used": prior, "prior_used": prior,
"erp_used": erp_used, "memo": (bal or {}).get("memo") or "",
"used_days": round(prior + erp_used, 2), # 예전 이름(달력 잔여 줄) — 총 = 이번 기간 생기는 연차, 사용 = 이번 기간 쓴 날, 잔여 = 지금 쓸 수 있는 연차
"remaining_days": round(float(total) - prior - erp_used, 2), "total_days": st["granted"], "used_days": st["used"], "remaining_days": st["available"],
"memo": bal["memo"] if bal else "",
} }
# ════════════════════════════════════════════════════════════ # ════════════════════════════════════════════════════════════
+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) 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) 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) is_approver = _is_approver(request, user)
pending_count = len(store.list_pending()) if is_approver else 0 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: if store is None:
raise HTTPException(status_code=503, detail="vacation_db 미설정") raise HTTPException(status_code=503, detail="vacation_db 미설정")
form = await request.form() 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") emails, memos = form.getlist("email"), form.getlist("memo")
totals, priors, hires = form.getlist("total"), form.getlist("prior"), form.getlist("hire") totals, priors, hires = form.getlist("total"), form.getlist("prior"), form.getlist("hire")
if not (len(emails) == len(totals) == len(memos) == len(priors) == len(hires)): 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 는 동기라 스레드에서 from starlette.concurrency import run_in_threadpool # noqa: WPS433 — 폼 배열을 읽으려 async, DB 는 동기라 스레드에서
try: 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: except ValueError as exc:
raise HTTPException(status_code=400, detail=str(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) + "#balances", status_code=303)
def _balance_rows(store: Any, year: int) -> list[dict[str, Any]]: def _balance_rows(store: Any, as_of: date) -> list[dict[str, Any]]:
"""옵션 잔여 연차 표 — 참여자(휴가 모듈 사용자) 전원 + 예전에 등록됐지만 지금 권한이 없는 사람. """옵션 잔여 연차 표 — 참여자(휴가 모듈 사용자) 전원 + 예전에 등록됐지만 지금 권한이 없는 사람(2026-10-27 입사일 기준).
줄마다 입사일·근속·법정 연차(근로기준법, 입사일 기준)·연차(직접 입력)·시스템 전 사용·사용·잔여·메모(db.balance_summary 한 곳).""" 줄마다 입사일·근속·이번 연차 기간·생기는 연차(법정, 오늘까지/앞으로)·직접 입력·시스템 전 사용·사용·지금 잔여·먼저 소멸할 잔여·메모
(db.balance_summary → store.leave_status 한 곳)."""
users = _vacation_users() users = _vacation_users()
this_year = {b["user_email"]: b for b in store.list_balances(year=year)} registered = {b["user_email"] for y in (as_of.year - 1, as_of.year) for b in store.list_balances(year=y)}
last_year = {b["user_email"]: b for b in store.list_balances(year=year - 1)}
hires = store.hire_dates() hires = store.hire_dates()
rows = [] rows = []
people = [(u["email"].lower(), u.get("name") or u["email"].split("@")[0], u.get("picture") or "", True) for u in users] 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} 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: for email, name, picture, active in people:
s = store.balance_summary(user_email=email, year=year, hire_date=hires.get(email)) s = store.balance_summary(user_email=email, as_of=as_of, hire_date=hires.get(email))
last = last_year.get(email) counted = s["has_hire"] or s["manual_total"] is not None
rows.append({"email": email, "name": name, "picture": picture, "active": active, rows.append({"email": email, "name": name, "picture": picture, "active": active,
"hire_date": s["hire_date"], "service_years": s["service_years"], "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"]), "period_start": s["period_start"], "period_end": s["period_end"],
"total": s["manual_total"], "effective_total": s["total_days"], "prior": s["prior_used"], "granted": s["granted"], "granted_so_far": s["granted_so_far"], "upcoming": s["upcoming"],
"used": s["erp_used"], "remaining": s["remaining_days"] if (s["manual_total"] is not None or s["hire_date"]) else None, "grants_tip": ", ".join(f"{g['date'][2:]} {g['label']} {g['days']:g}일(~{g['expires'][2:]})" for g in s["grants"]),
"memo": s["memo"], "total": s["manual_total"], "prior": s["prior_used"], "used": s["used"],
"last_total": last["total_days"] if last and last.get("total_days") is not None else None}) "available": s["available"] if counted else None, "expiring": s["expiring"], "memo": s["memo"]})
return rows return rows
@@ -679,10 +673,7 @@ def options_page(request: Request) -> HTMLResponse:
users = _vacation_users() users = _vacation_users()
can_edit = _can_edit_options(request, user, opts, users) can_edit = _can_edit_options(request, user, opts, users)
today = today_kst() today = today_kst()
try: bal_rows = _balance_rows(store, today) if can_edit else []
bal_year = int(request.query_params.get("year") or today.year)
except ValueError:
bal_year = today.year
return render_template( return render_template(
request, request,
"vacation/options.html", "vacation/options.html",
@@ -699,11 +690,13 @@ def options_page(request: Request) -> HTMLResponse:
"effective_approvers": notify.approver_emails(opts, users), "effective_approvers": notify.approver_emails(opts, users),
"gmail": _gmail_state(request, user), "gmail": _gmail_state(request, user),
"msg": request.query_params.get("msg", ""), "msg": request.query_params.get("msg", ""),
"bal_year": bal_year, "bal_today": today.isoformat(),
"bal_prior_year": bal_year == SYSTEM_START_YEAR, # 시스템 도입 해만 "시스템 전 사용" 칸 # "시스템 전 사용"(도입 해 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, "hire_ready": store.hire_ready() if can_edit else False,
"can_edit": can_edit, "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, ...] = ("작성중", "반려") EDITABLE_STATUSES: tuple[str, ...] = ("작성중", "반려")
# 연차에서 차감하는 휴가 종류(2026-10-27) — 승인되면 그해 연차에서 빠진다. 병가·경조·대체휴무·기타는 차감하지 않는다. # 연차에서 차감하는 휴가 종류(2026-10-27) — 승인되면 연차에서 빠진다. 병가·경조·대체휴무·기타는 차감하지 않는다.
# 연차는 그해(1/1~12/31) 것만 쓰고 다음 해로 넘기지 않는다(12/31 소멸 — 해마다 잔여 연차를 새로 등록). # 연차는 입사일 기준(leave_grants·leave_status) — 연차마다 쓸 수 있는 기한이 따로(12/31 소멸 규칙은 2026-10-27 없앰).
DEDUCT_TYPES: tuple[str, ...] = ("연차", "오전반차", "오후반차") DEDUCT_TYPES: tuple[str, ...] = ("연차", "오전반차", "오후반차")
# 이 시스템을 쓰기 시작한 해 — 그해만 잔여 연차 표에 "시스템 전 사용"(도입 전에 이미 쓴 연차) 칸(2026-10-27) # 이 시스템을 쓰기 시작한 해 — 그해만 잔여 연차 표에 "시스템 전 사용"(도입 전에 이미 쓴 연차) 칸(2026-10-27)
@@ -49,34 +49,126 @@ def add_months(d: date, n: int) -> date:
return date(y, m, min(d.day, last)) return date(y, m, min(d.day, last))
def legal_annual_leave(hire: date | None, year: int) -> dict: # 시스템 전 사용(prior_used)을 쓴 것으로 치는 날 — 이 시스템을 쓰기 시작한 날(그때까지 쓴 연차)
"""근로기준법 제60조 연차 — 입사일 기준으로 생기는 날을 그해(1/1~12/31)에 모은다(연차는 12/31 소멸 규칙과 맞춤). 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조 ①④ def leave_grants(hire: date, until: date) -> list[dict]:
출근율(1개월 개근·1년 80%)은 따지지 않는다(모두 채운 것으로 본다). 입사일이 없거나 그해 뒤면 0일. """입사일부터 until 까지 생기는 연차(근로기준법 제60조) — 생긴 날마다 한 줄, 쓸 수 있는 마지막 날(expires) 포함.
반환 {"days", "items": [{"date", "days", "label"}], "service_years"(12/31 기준 만 근속 연수)}.
· 입사 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} out: list[dict] = []
if hire is None: first_end = add_months(hire, 12) - timedelta(days=1)
return out
y0, y1 = date(year, 1, 1), date(year, 12, 31)
items = []
for m in range(1, 12): for m in range(1, 12):
d = add_months(hire, m) g = add_months(hire, m)
if y0 <= d <= y1: if g > until:
items.append({"date": d.isoformat(), "days": 1.0, "label": f"입사 {m}개월(월 1일)"}) break
out.append({"date": g, "expires": first_end, "days": 1.0, "label": f"입사 {m}개월(월 1일)", "period": 0})
n = 1 n = 1
while True: while True:
d = add_months(hire, 12 * n) g = add_months(hire, 12 * n)
if d > y1: if g > until:
break break
if d >= y0: out.append({"date": g, "expires": add_months(hire, 12 * (n + 1)) - timedelta(days=1),
items.append({"date": d.isoformat(), "days": float(min(25, 15 + (n - 1) // 2)), "label": f"근속 {n}년"}) "days": float(min(25, 15 + (n - 1) // 2)), "label": f"근속 {n}년", "period": n})
n += 1 n += 1
out["items"] = items return out
out["days"] = float(sum(i["days"] for i in items))
out["service_years"] = max(0, n - 1)
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 return out
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %} {% 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 %} {% block content %}
<section class="vac"> <section class="vac">
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %} {% 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) -#} {#- 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop) -#}
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %} <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> {% 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/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" %} {% 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 %} {% block content %}
<section class="vac"> <section class="vac">
@@ -19,13 +19,15 @@
<a class="erp-btn erp-btn-outline" href="/vacation/options">옵션</a> <a class="erp-btn erp-btn-outline" href="/vacation/options">옵션</a>
</div> </div>
<div class="vac-balance"> <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-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-sep">·</span>
<span class="vac-bal-item vac-bal-remain">잔여 <strong>{{ balance.remaining_days }}</strong></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>
{#- 연차는 그해 것만 — 12/31 소멸, 다음 해로 넘어가지 않음(2026-10-27). 사용 = 승인된 연차·반차 -#} {% if balance.expiring %}<span class="erp-muted vac-bal-year">{{ balance.expiring.date | replace('-', '.') }} 소멸 {{ '%g' % balance.expiring.days }}일</span>
<span class="erp-muted vac-bal-year" title="사용 = 승인된 연차·오전반차·오후반차(병가·경조·대체휴무·기타는 빼지 않음)">{{ year }}년 · {{ year }}.12.31 소멸</span> {% elif not balance.has_hire and balance.manual_total is none %}<span class="erp-muted vac-bal-year">입사일 미등록(옵션)</span>{% endif %}
</div> </div>
</div> </div>
@@ -2,7 +2,7 @@
{#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나). {#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나).
메일: 제출 = 승인자·통보자, 승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 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/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %} <link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %}
@@ -63,27 +63,24 @@
{#- 잔여 연차(2026-10-27, 설정에서 옮김) — 참여자(휴가 모듈 사용자) 전원을 미리 보여 주고 줄마다 연차 입력. 관리자·승인자·통보자만 보임·저장. -#} {#- 잔여 연차(2026-10-27, 설정에서 옮김) — 참여자(휴가 모듈 사용자) 전원을 미리 보여 주고 줄마다 연차 입력. 관리자·승인자·통보자만 보임·저장. -#}
<form method="post" action="/vacation/options/balances" class="erp-card vac-opt-card vac-opt-balcard" id="balances"> <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"> <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> <h2>잔여 연차 <span class="erp-muted vac-opt-count">{{ bal_today | replace('-', '.') }} 기준 · 참여자 {{ 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>
</div> </div>
<p class="erp-muted vac-opt-hint">이름 옆 <b>입사일</b>을 고르면 <b>근로기준법 제60조</b>대로 {{ bal_year }}년에 생기는 연차를 계산합니다 <p class="erp-muted vac-opt-hint">연차는 사람마다 <b>입사일 기준</b>입니다(근로기준법 제60조 — 출근율은 모두 채운 것으로 봄).
(입사 1년 미만 = 1개월마다 1일·최대 11일, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일·최대 25일, 출근율은 모두 채운 것으로 봄). 입사 1년 미만은 입사일 + 1~11개월마다 1일씩 생기고 <b>입사일부터 1년</b>까지, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일(최대 25일)이
<b>연차</b> 칸을 비우면 법정 연차를 쓰고, 숫자를 넣으면 그 값을 씁니다. 휴가가 <b>승인되면</b> 차감됩니다(연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 차감 안 함). 생겨 <b>그날부터 1년</b>까지 씁니다(12/31 에 없어지지 않음). 휴가가 <b>승인되면</b> 그날 쓸 수 있는 연차 중 <b>먼저 소멸하는 것부터</b> 뺍니다
{{ bal_year }}년 연차는 <b>{{ bal_year }}.12.31 에 소멸</b>하고 다음 해로 넘어가지 않습니다. (연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 안 뺌, 생기기 전에 쓰면 다음 연차를 당겨 씀).
{% if bal_prior_year %}<b>시스템 전 사용</b> = 이 시스템을 쓰기 전에 {{ bal_year }}년에 이미 쓴 연차(잔여에서 뺍니다).{% endif %}</p> <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 %} {% 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"> <div class="erp-table-wrap">
<table class="erp-table vac-bal-table" data-year="{{ bal_year }}"> <table class="erp-table vac-bal-table" data-today="{{ bal_today }}">
<thead><tr><th>참여자 · 입사일</th><th>근속</th><th title="입사일 기준 근로기준법 제60조">법정 연차</th><th>연차</th> <thead><tr><th>참여자 · 입사일</th><th>근속</th><th>이번 연차 기간</th>
{% if bal_prior_year %}<th title="이 시스템을 쓰기 전에 그해 이미 쓴 연차">시스템 전 사용</th>{% endif %} <th title="이번 연차 기간에 생기는 법정 연차 — 오늘까지 생긴 것 (+ 앞으로 생길 것)">생기는 연차</th><th title="비우면 법정 연차">직접 입력</th>
<th title="ERP 에서 승인된 연차·반차">사용</th><th>잔여</th><th>메모</th></tr></thead> {% if bal_prior_col %}<th title="이 시스템을 쓰기 전에 이미 쓴 연차">시스템 전 사용</th>{% endif %}
<th title="이번 연차 기간에 승인된 연차·반차">사용</th><th title="오늘 쓸 수 있는 연차">잔여</th><th>먼저 소멸</th><th>메모</th></tr></thead>
<tbody> <tbody>
{% for b in bal_rows %} {% 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> <td>
<span class="vac-bal-person"> <span class="vac-bal-person">
{% if b.picture %}<img class="vac-opt-face" src="{{ b.picture }}" alt="" referrerpolicy="no-referrer" /> {% 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="vac-opt-name">{{ b.name }}</span>
<span class="erp-muted vac-opt-mail">{{ b.email }}{% if not b.active %} · 휴가 권한 없음{% endif %}</span> <span class="erp-muted vac-opt-mail">{{ b.email }}{% if not b.active %} · 휴가 권한 없음{% endif %}</span>
</span> </span>
{#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값) -#} {#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값). 002 전이면 숨김 칸만(서버가 무시) -#}
{#- 002 전이면 숨김 칸만(서버가 무시) — disabled 는 폼에서 빠져 칸 수가 어긋나므로 쓰지 않는다 -#}
<input class="vac-hire-input" type="{{ 'date' if hire_ready else 'hidden' }}" name="hire" value="{{ b.hire_date }}" aria-label="{{ b.name }} 입사일" /> <input class="vac-hire-input" type="{{ 'date' if hire_ready else 'hidden' }}" name="hire" value="{{ b.hire_date }}" aria-label="{{ b.name }} 입사일" />
</span> </span>
<input type="hidden" name="email" value="{{ b.email }}" /> <input type="hidden" name="email" value="{{ b.email }}" />
</td> </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-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" <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 '' }}" value="{{ '%g' % b.total if b.total is not none else '' }}" placeholder="{{ '%g' % b.granted if b.hire_date 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>
aria-label="{{ b.name }} 연차(비우면 법정 연차)" /></td> {% if bal_prior_col %}
{% if bal_prior_year %}
<td><input class="erp-input vac-bal-input vac-bal-prior" type="number" name="prior" step="0.5" min="0" max="365" <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> 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 %} {% 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">{{ '%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> <td><input class="erp-input vac-bal-memo" type="text" name="memo" maxlength="200" value="{{ b.memo }}" placeholder="비고" aria-label="{{ b.name }} 메모" /></td>
</tr> </tr>
{% else %} {% else %}
<tr><td colspan="8" class="erp-muted">휴가 모듈 권한이 있는 사용자가 없습니다.</td></tr> <tr><td colspan="10" class="erp-muted">휴가 모듈 권한이 있는 사용자가 없습니다.</td></tr>
{% endfor %} {% endfor %}
</tbody> </tbody>
</table> </table>
</div> </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> </form>
{% endif %} {% endif %}
@@ -152,4 +150,4 @@
{% endblock %} {% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261027b" defer></script> {% 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" %} {% 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 %} {% block content %}
<section class="vac"> <section class="vac">
+5
View File
@@ -262,3 +262,8 @@
.vac-bal-person .vac-hire-btn .material-symbols-outlined { font-size: 16px; } .vac-bal-person .vac-hire-btn .material-symbols-outlined { font-size: 16px; }
.vac-bal-legal { color: #1a56db; font-weight: 600; } .vac-bal-legal { color: #1a56db; font-weight: 600; }
.vac-bal-years-cell { color: var(--vac-muted); } .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(); recalc();
})(); })();
/* 휴가 옵션 — 잔여 연차 표(2026-10-27): 이름 옆 입사일 = 날짜 버튼(erp-datepop), 고르면 근속·법정 연차·잔여를 바로 다시 계산 /* 휴가 옵션 — 잔여 연차 표(2026-10-27, 입사일 기준): 이름 옆 입사일 = 날짜 버튼(erp-datepop). 고르면 근속·이번 연차 기간·생기는 연차
(서버 store.legal_annual_leave 와 같은 규칙 — 근로기준법 제60조, 입사일 기준으로 그해에 생기는 연차). 저장은 [잔여 연차 저장]. */ (오늘까지 + 앞으로)를 바로 다시 계산(서버 store.leave_grants·leave_period 와 같은 규칙 — 근로기준법 제60조).
사용·잔여·소멸은 승인된 휴가를 연차마다 나눠야 해서 서버가 계산 — 입사일·직접 입력을 바꾸면 "저장 후"로 표시하고 안내. */
(function () { (function () {
"use strict"; "use strict";
var table = document.querySelector(".vac-bal-table"); var table = document.querySelector(".vac-bal-table");
if (!table) return; if (!table) return;
var year = +table.dataset.year; var today = table.dataset.today;
var note = document.querySelector(".vac-bal-note");
function iso(d) { function iso(d) {
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0"); 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) function addMonths(d, n) { // 같은 날, 없으면 그 달 말일(1/31 + 1달 = 2/28)
var m = d.getMonth() + n, y = d.getFullYear() + Math.floor(m / 12); var m = d.getMonth() + n, y = d.getFullYear() + Math.floor(m / 12);
m = ((m % 12) + 12) % 12; m = ((m % 12) + 12) % 12;
var last = new Date(y, m + 1, 0).getDate(); return new Date(y, m, Math.min(d.getDate(), new Date(y, m + 1, 0).getDate()));
return new Date(y, m, Math.min(d.getDate(), last));
} }
function legal(hireIso) { function dayBefore(d) { return new Date(d.getFullYear(), d.getMonth(), d.getDate() - 1); }
if (!hireIso) return null; function status(hireIso) {
var p = hireIso.split("-"), hire = new Date(+p[0], +p[1] - 1, +p[2]); if (!hireIso || hireIso > today) return null;
var y0 = iso(new Date(year, 0, 1)), y1 = iso(new Date(year, 11, 31)); var hire = parse(hireIso), n = 0;
var days = 0, items = [], n = 1, d; while (iso(addMonths(hire, 12 * (n + 1))) <= today) n++;
for (var m = 1; m < 12; m++) { var p0 = n === 0 ? hireIso : iso(addMonths(hire, 12 * n)), p1 = iso(dayBefore(addMonths(hire, 12 * (n + 1))));
d = iso(addMonths(hire, m)); var so = 0, up = 0, tip = [];
if (d >= y0 && d <= y1) { days += 1; items.push(d.slice(5) + " 입사 " + m + "개월(월 1일) 1일"); } 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 (;;) { if (n === 0) {
d = iso(addMonths(hire, 12 * n)); var first = iso(dayBefore(addMonths(hire, 12)));
if (d > y1) break; for (var m = 1; m < 12; m++) add(iso(addMonths(hire, m)), 1, "입사 " + m + "개월(월 1일)", first);
if (d >= y0) { var g = Math.min(25, 15 + Math.floor((n - 1) / 2)); days += g; items.push(d.slice(5) + " 근속 " + n + "년 " + g + "일"); } } else {
n++; 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) { table.querySelectorAll("tr.vac-bal-row").forEach(function (tr) {
var hire = tr.querySelector(".vac-hire-input"); var hire = tr.querySelector(".vac-hire-input");
var total = tr.querySelector('input[name="total"]'); var total = tr.querySelector('input[name="total"]');
var prior = tr.querySelector('input[name="prior"]'); 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() { function recalc() {
var L = legal(hire.value); var S = status(hire.value);
tr.querySelector(".vac-bal-years-cell").textContent = L ? L.years + "년" : "—"; 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"); var lg = tr.querySelector(".vac-bal-legal");
lg.textContent = L ? g(L.days) : "—"; lg.textContent = S ? String(S.so) : "—";
if (L && L.tip) lg.title = L.tip; else lg.removeAttribute("title"); if (S && S.up) { var sm = document.createElement("small"); sm.textContent = "(+" + S.up + ")"; lg.append(" ", sm); }
if (L) total.placeholder = g(L.days); if (S && S.tip) lg.title = S.tip; else lg.removeAttribute("title");
var manual = total.value.trim() === "" ? null : +total.value; total.placeholder = S ? String(S.so + S.up) : "";
var base = manual != null ? manual : (L ? L.days : null); stale();
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);
} }
if (hire && hire.type !== "hidden" && window.ErpDatePop) { if (hire && hire.type !== "hidden" && window.ErpDatePop) {
window.ErpDatePop.enhance(hire, { label: "입사일", placeholder: "입사일", yearNav: true, format: window.ErpDatePop.fmtFull, window.ErpDatePop.enhance(hire, { label: "입사일", placeholder: "입사일", yearNav: true, format: window.ErpDatePop.fmtFull,
className: "vac-hire-btn" }); className: "vac-hire-btn" });
} }
if (hire) hire.addEventListener("change", recalc); if (hire) hire.addEventListener("change", recalc);
total.addEventListener("input", recalc); total.addEventListener("input", stale);
if (prior) prior.addEventListener("input", recalc); 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 차감. 클라이언트 계산은 미리보기용(같은 공휴일 표). 휴가 일수는 서버(`store.compute_days`)에서 재계산: 주말 + 쉬는 날 제외, 오전/오후 반차 0.5일, 시작/종료 반차는 각 0.5 차감. 클라이언트 계산은 미리보기용(같은 공휴일 표).
쉬는 날(2026-10-27) = 국경일·대체공휴일(프로젝트 `KR_HOLIDAYS`, 2026~2030, 새 연도는 그 표에 추가) — `db.holiday_map`. `vacation_holidays` 는 읽지 않는다. 쉬는 날(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 + 승인자 + 통보자. 권한: `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조 연차, **마이그레이션 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 ```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 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) 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: with open(os.path.join(OUT_DIR, "vac_form.html"), "w", encoding="utf-8") as f:
f.write(html) f.write(html)
# 옵션 — 잔여 연차 표(2026, 입사일·법정 연차·시스템 전 사용) → tests/js/.out/vac_options.html # 옵션 — 잔여 연차 표(2026-10-27 입사일 기준, 오늘 = 2026-10-26 고정) → tests/js/.out/vac_options.html
row = {"active": True, "picture": "", "service_years": 0, "legal": None, "legal_tip": "", "total": None, "effective_total": 0, row = {"active": True, "picture": "", "service_years": 0, "period_start": "", "period_end": "", "granted": 0.0,
"prior": 0.0, "used": 0.0, "remaining": None, "memo": "", "last_total": None, "hire_date": ""} "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": "", octx = {**ctx, "page_title": "휴가 — 옵션", "is_admin": True, "can_edit": True, "msg": "",
"options": {"approvers": [], "notifiers": [], "ready": True, "updated_by": "", "updated_at": ""}, "options": {"approvers": [], "notifiers": [], "ready": True, "updated_by": "", "updated_at": ""},
"candidates": [], "effective_approvers": [], "gmail": {"available": False, "connected": False, "smtp": True}, "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": [ "bal_rows": [
{**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6, "legal": 17.0, {**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6,
"legal_tip": "03-02 근속 6년 17일", "used": 4.5, "remaining": 12.5}, "period_start": "2026-03-02", "period_end": "2027-03-01", "granted": 17.0, "granted_so_far": 17.0,
{**row, "email": "kim@test.local", "name": "김철수", "used": 1.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) 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: 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 // python tests/js/render_vacation.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/vacation_balances.browser.test.js // 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 fs = require("fs"), path = require("path");
const { chromium } = require("playwright"); const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", ".."); const ROOT = path.join(__dirname, "..", "..");
@@ -15,7 +17,7 @@ function check(name, cond, extra) {
const browser = await chromium.launch(exe ? { executablePath: exe } : {}); const browser = await chromium.launch(exe ? { executablePath: exe } : {});
const posts = []; const posts = [];
try { 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) { await p.route("**/*", function (r) {
const req = r.request(), url = new URL(req.url()).pathname; const req = r.request(), url = new URL(req.url()).pathname;
if (url.startsWith("/static/")) { if (url.startsWith("/static/")) {
@@ -33,52 +35,62 @@ function check(name, cond, extra) {
return p.evaluate(function (email) { return p.evaluate(function (email) {
const tr = document.querySelector('input[name="email"][value="' + email + '"]').closest("tr"); const tr = document.querySelector('input[name="email"][value="' + email + '"]').closest("tr");
const btn = tr.querySelector(".vac-hire-btn"); 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"), 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", 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(), years: t(".vac-bal-years-cell"), period: t(".vac-bal-period"), legal: t(".vac-bal-legal"),
placeholder: tr.querySelector('input[name="total"]').placeholder, remain: tr.querySelector(".vac-bal-remain").textContent.trim(), placeholder: tr.querySelector('input[name="total"]').placeholder, remain: t(".vac-bal-remain"), expire: t(".vac-bal-expire"),
minus: tr.querySelector(".vac-bal-remain").classList.contains("is-minus") }; stale: tr.classList.contains("is-stale") };
}, email); }, email);
}; };
const lee = await rowState("lee@test.local"); const lee = await rowState("lee@test.local");
check("입사일 = 이름 옆 날짜 버튼(연도까지), 숨긴 input 이 값", lee.nextToName && !lee.hireShown && lee.btn === "2020.03.02(월)" && check("입사일 = 이름 옆 날짜 버튼(연도까지), 이번 연차 기간·잔여·먼저 소멸(12/31 아님)", lee.nextToName && !lee.hireShown &&
lee.hire === "2020-03-02" && lee.legal === "17" && lee.remain === "12.5", lee); 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"); const kim0 = await rowState("kim@test.local");
check("입사일 없음 = '입사일' 버튼, 근속·법정 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.legal === "—" && kim0.remain === "—", kim0); check("입사일 없음 = '입사일' 버튼, 기간·연차 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.period === "—" && kim0.remain === "—", kim0);
// 김철수 입사일 2025-03-01 직접 입력(Enter) → 근속 1년 · 법정 17(1/1·2/1 월 1일 + 3/1 15일) · 잔여 17 − 1(사용) 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'); await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn');
const pop = await p.evaluate(function () { const pop = await p.evaluate(function () {
const el = document.querySelector(".pj-datepop"); const el = document.querySelector(".pj-datepop");
return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder, return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder };
clear: !!el.querySelector(".pj-dp-clear") };
}); });
check("입사일 팝업 = 날짜 하나, « ‹ › » (1년씩 이동), 지우기", !!pop && pop.navs === 4 && pop.field === "입사일" && pop.clear, pop); check("입사일 팝업 = 날짜 하나, « ‹ › »", !!pop && pop.navs === 4 && pop.field === "입사일", pop);
await p.fill(".pj-dp-field", "2025-03-01"); await p.fill(".pj-dp-field", "2026-10-12");
await p.press(".pj-dp-field", "Enter"); await p.press(".pj-dp-field", "Enter");
const kim1 = await rowState("kim@test.local"); const kim1 = await rowState("kim@test.local");
check("입사일 고르면 근속·법정 연차·잔여 바로 계산(근로기준법)", kim1.btn === "2025.03.01(토)" && kim1.hire === "2025-03-01" && check("10/12 입사 → 이번 기간 26.10.12 ~ 27.10.11, 오늘까지 0 (+11), 잔여·소멸은 저장 후", kim1.btn === "2026.10.12(월)" &&
kim1.years === "1년" && kim1.legal === "17" && kim1.placeholder === "17" && kim1.remain === "16", kim1); kim1.years === "0년" && kim1.period === "26.10.12 ~ 27.10.11" && kim1.legal === "0 (+11)" && kim1.placeholder === "11" &&
// 시스템 전 사용 3.5 → 잔여 12.5, 연차 직접 10 → 10 − 3.5 − 1 = 5.5, 20 넘게 쓰면 빨강 kim1.remain === "저장 후" && kim1.expire === "저장 후" && kim1.stale, kim1);
await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "3.5"); // 2025-03-01 로 바꾸면 근속 1년 · 26.03.01 ~ 27.02.28 · 15
check("시스템 전 사용 → 잔여에서 뺌", (await rowState("kim@test.local")).remain === "12.5"); await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn');
await p.fill('tr:has(input[value="kim@test.local"]) input[name="total"]', "10"); await p.fill(".pj-dp-field", "2025.3.1");
check("연차 직접 입력이 법정보다 먼저", (await rowState("kim@test.local")).remain === "5.5"); await p.press(".pj-dp-field", "Enter");
await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "12");
const kim2 = await rowState("kim@test.local"); const kim2 = await rowState("kim@test.local");
check("모자라면 잔여 빨강", kim2.remain === "-3" && kim2.minus, kim2); check("2025-03-01 입사 → 근속 1년 · 26.03.01 ~ 27.02.28 · 15일", kim2.years === "1년" && kim2.period === "26.03.01 ~ 27.02.28" &&
// 1년씩 이동 버튼 — 2025년 3월 → « → 2024년 3월 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'); await p.click('tr:has(input[value="lee@test.local"]) .vac-hire-btn');
const t0 = await p.textContent(".pj-dp-title"); const t0 = await p.textContent(".pj-dp-title");
await p.click('.pj-dp-navbtn[data-nav="-12"]'); await p.click('.pj-dp-navbtn[data-nav="-12"]');
const t1 = await p.textContent(".pj-dp-title"); const t1 = await p.textContent(".pj-dp-title");
check("« = 1년 전 달력", t0 === "2020년 3월" && t1 === "2019년 3월", [t0, t1]); check("« = 1년 전 달력", t0 === "2020년 3월" && t1 === "2019년 3월", [t0, t1]);
await p.keyboard.press("Escape"); await p.keyboard.press("Escape");
// 저장 — 줄마다 email·hire·total·prior·memo
await p.click('button[type="submit"]:has-text("잔여 연차 저장")'); await p.click('button[type="submit"]:has-text("잔여 연차 저장")');
await p.waitForTimeout(200); await p.waitForTimeout(200);
const body = decodeURIComponent((posts[0] || "").replace(/\+/g, " ")); const body = decodeURIComponent((posts[0] || "").replace(/\+/g, " "));
check("저장 → 입사일·연차·시스템 전 사용이 줄마다 전송", /email=kim@test.local/.test(body) && /hire=2025-03-01/.test(body) && 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); /hire=2020-03-02/.test(body) && /prior=3/.test(body) && (body.match(/hire=/g) || []).length === 2 && !/year=/.test(body), body);
} finally { } finally {
await browser.close(); await browser.close();
} }
+117 -59
View File
@@ -108,72 +108,127 @@ class VacationHolidayBalanceDBTests(unittest.TestCase):
self.st.approve(request_id=req["id"], approver_email="lee@test.local") self.st.approve(request_id=req["id"], approver_email="lee@test.local")
return req 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 st = self.st
owner = f"bal-{uuid.uuid4().hex[:6]}@test.local" 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-02", "2026-11-03"), # 2 self._approved(owner, "오전반차", "2026-11-04", "2026-11-04") # 0.5
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-05", "2026-11-06"), # 차감 안 함 self._approved(owner, "경조", "2026-11-09", "2026-11-09") # 차감 안 함
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 신정·주말 뺌)
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="제출", # 제출(승인 전)은 차감 안 함 st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함
payload={"vacation_type": "연차", "start_date": "2026-11-10", "end_date": "2026-11-10", payload={"vacation_type": "연차", "start_date": "2026-11-10", "end_date": "2026-11-10",
"start_half": "full", "end_half": "full", "reason": ""}) "start_half": "full", "end_half": "full", "reason": ""})
try: try:
self.assertEqual(st.used_days(user_email=owner, year=2026), 4.5) ev = st.usage_events(user_email=owner)
self.assertEqual(st.used_days(user_email=owner, year=2027), 1.0) self.assertEqual(round(sum(a for d, a in ev), 2), 5.5)
st.save_balances(year=2026, rows=[{"user_email": owner, "total_days": 15, "memo": "입사 2020"}]) self.assertEqual((st.used_days(user_email=owner, year=2026), st.used_days(user_email=owner, year=2027)), (4.5, 1.0))
s26 = st.balance_summary(user_email=owner, year=2026) # 입사 2020-03-02 → 2026-03-02 근속 6년 17일(2027-03-01 까지) — 12/31 에 안 없어짐
self.assertEqual((s26["total_days"], s26["used_days"], s26["remaining_days"]), (15.0, 4.5, 10.5)) st.save_balances(rows=[{"user_email": owner, "total_days": None, "memo": "", "hire_date": "2020-03-02"}],
s27 = st.balance_summary(user_email=owner, year=2027) # 다음 해로 넘어가지 않음(등록 전 = 0) as_of=date(2026, 10, 27))
self.assertEqual((s27["total_days"], s27["remaining_days"]), (0.0, -1.0)) 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: finally:
for r in st.list_for(owner): for r in st.list_for(owner):
st.hard_delete(request_id=r["id"], user_email=owner, is_admin=True) st.hard_delete(request_id=r["id"], user_email=owner, is_admin=True)
def test_save_balances_validates_all_or_nothing(self): def test_save_balances_validates_all_or_nothing(self):
from datetime import date
st = self.st st = self.st
a, b = f"a-{uuid.uuid4().hex[:6]}@test.local", f"b-{uuid.uuid4().hex[:6]}@test.local" 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): with self.assertRaises(ValueError):
st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}]) 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.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 "}, self.assertEqual(st.save_balances(rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "},
{"user_email": b, "total_days": 0}]), 2) {"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"]), self.assertEqual((st.get_balance(user_email=a, year=2031)["total_days"], st.get_balance(user_email=a, year=2031)["memo"]),
(15.5, "x")) (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) self.assertEqual(st.get_balance(user_email=a, year=2031)["total_days"], 20.0)
class LegalAnnualLeaveTests(unittest.TestCase): class LeaveRulesTests(unittest.TestCase):
"""근로기준법 제60조 — 입사일 기준으로 생기는 연차를 그해에 모은다(2026-10-27, DB 없음).""" """근로기준법 제60조 — 입사일 기준, 연차마다 쓸 수 있는 기한(2026-10-27, 12/31 소멸 없음, DB 없음)."""
def test_rules(self): def test_grants_periods_and_usage_units(self):
from datetime import date 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(D(2026, 1, 31), 1), D(2026, 2, 28))
self.assertEqual(add_months(date(2024, 2, 29), 12), date(2025, 2, 28)) self.assertEqual(add_months(D(2024, 2, 29), 12), D(2025, 2, 28))
# 입사 1년 미만 = 1개월마다 1일, 입사일이 돌아오면 15일 — 2025-03-01 입사 g = leave_grants(D(2026, 10, 12), D(2027, 10, 12))
self.assertEqual(L(date(2025, 3, 1), 2025)["days"], 9.0) # 4/1 ~ 12/1 self.assertEqual([(x["date"].isoformat(), x["days"], x["expires"].isoformat()) for x in g[:2]],
r = L(date(2025, 3, 1), 2026) [("2026-11-12", 1.0, "2027-10-11"), ("2026-12-12", 1.0, "2027-10-11")]) # 월 1일 = 입사일부터 1년까지
self.assertEqual((r["days"], r["service_years"]), (17.0, 1)) # 1/1·2/1(월 1일) + 3/1 근속 1년 15일 self.assertEqual(len([x for x in g if x["period"] == 0]), 11)
self.assertEqual([i["date"] for i in r["items"]], ["2026-01-01", "2026-02-01", "2026-03-01"]) self.assertEqual((g[-1]["date"], g[-1]["days"], g[-1]["expires"]), (D(2027, 10, 12), 15.0, D(2028, 10, 11)))
self.assertEqual(L(date(2025, 3, 1), 2027)["days"], 15.0) # 근속 2년 = 15일 days = {x["period"]: x["days"] for x in leave_grants(D(2001, 1, 1), D(2026, 12, 31)) if x["period"]}
# 3년 이상 = 최초 1년을 넘는 근속 2년마다 1일, 최대 25일 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(L(date(2023, 5, 10), 2026)["days"], 16.0) # 근속 3년 self.assertEqual(leave_period(D(2026, 10, 12), D(2026, 10, 26)), (0, D(2026, 10, 12), D(2027, 10, 11)))
self.assertEqual(L(date(2020, 3, 2), 2026)["days"], 17.0) # 근속 6년 = 15 + 2 self.assertEqual(leave_period(D(2020, 3, 2), D(2026, 10, 26)), (6, D(2026, 3, 2), D(2027, 3, 1)))
self.assertEqual(L(date(2001, 1, 1), 2026)["days"], 25.0) # 근속 25년 → 한도 25 hol = {"2027-01-01"}
self.assertEqual(L(date(2027, 1, 2), 2026)["days"], 0.0) # 아직 입사 전 for kw in ({"start_date": D(2026, 12, 30), "end_date": D(2027, 1, 4), "start_half": "pm", "end_half": "am"},
self.assertEqual(L(None, 2026)["days"], 0.0) {"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) 미설정") @unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정")
class VacationHireDBTests(unittest.TestCase): class VacationHireDBTests(unittest.TestCase):
"""002 — 입사일·시스템 전 사용·연차 비우면 법정(실제 PostgreSQL, 002 적용 DB).""" """002 — 입사일·시스템 전 사용·직접 입력(실제 PostgreSQL, 002 적용 DB)."""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
@@ -185,33 +240,36 @@ class VacationHireDBTests(unittest.TestCase):
def tearDownClass(cls): def tearDownClass(cls):
cls.st.close() 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 st = self.st
on = date(2026, 10, 28)
self.assertTrue(st.hire_ready()) self.assertTrue(st.hire_ready())
a, b = f"h-{uuid.uuid4().hex[:6]}@test.local", f"h-{uuid.uuid4().hex[:6]}@test.local" 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=[ 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": "2025-03-01"}, {"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": "2020-03-02"}, {"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2024-11-15"},
]) ])
self.assertEqual(n, 2) self.assertEqual(n, 2)
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, year=2026) sa = st.balance_summary(user_email=a, as_of=on) # 10/12 입사 — 아직 생긴 연차 없음, 시스템 전 사용 3.5 = 당겨 씀
self.assertEqual((sa["total_days"], sa["manual_total"], sa["legal_days"], sa["prior_used"], sa["remaining_days"]), self.assertEqual((sa["granted"], sa["granted_so_far"], sa["available"], sa["prior_used"]), (11.0, 0.0, -3.5, 3.5))
(17.0, None, 17.0, 3.5, 13.5)) # 법정 17 − 시스템 전 3.5 # b: 2025-11-15 근속 1년 기간(2025 줄)에 직접 입력 20, 시스템 전 사용은 2026 줄
sb = st.balance_summary(user_email=b, year=2026) self.assertEqual(st.get_balance(user_email=b, year=2025)["total_days"], 20.0)
self.assertEqual((sb["total_days"], sb["legal_days"], sb["remaining_days"], sb["service_years"]), (20.0, 17.0, 20.0, 6)) sb = st.balance_summary(user_email=b, as_of=on)
# 2027 — 아무것도 등록 안 해도 입사일로 법정 연차(이월 없음) 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=a, year=2027)["total_days"], 15.0) self.assertEqual(st.balance_summary(user_email=b, as_of=date(2026, 11, 16))["granted"], 15.0) # 다음 기간 = 법정 15
# 입사일 지우기("") · 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 # 입사일 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 · "" = 지움
st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}]) st.save_balances(rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2025-03-01") self.assertEqual(st.hire_dates()[a], "2026-10-12")
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
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"}]) {"user_email": b, "total_days": None, "hire_date": "2020-13-01"}], as_of=on)
self.assertEqual(st.hire_dates()[a], "2025-03-01") self.assertEqual(st.hire_dates()[a], "2026-10-12")
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": ""}], as_of=on)
self.assertNotIn(a, st.hire_dates()) 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__": if __name__ == "__main__":
+20 -16
View File
@@ -205,14 +205,18 @@ class Store:
return True return True
def hire_dates(self): def hire_dates(self):
return {} return {}
def balance_summary(self, user_email, year, hire_date=None): def balance_summary(self, user_email, as_of=None, hire_date=None): # db.balance_summary 모양(입사일 기준, 가짜 계산)
bal = {b["user_email"]: b for b in self.list_balances(year)}.get(user_email) from app.timezone import today_kst
used = self.used_days(user_email, year) 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 manual = bal["total_days"] if bal else None
total = manual if manual is not None else 0.0 total = manual if manual is not None else 0.0
return {"year": year, "total_days": total, "manual_total": manual, "legal_days": None, "legal_items": [], return {"has_hire": bool(hire_date), "service_years": 0, "period_start": f"{as_of.year}-01-01" if manual is not None else "",
"service_years": 0, "hire_date": hire_date or "", "prior_used": 0.0, "erp_used": used, "period_end": f"{as_of.year}-12-31" if manual is not None else "", "granted": total, "granted_so_far": total,
"used_days": used, "remaining_days": total - used, "memo": bal["memo"] if bal else ""} "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) — 해마다 한글날만 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)} 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": ""}] [{"user_email": "kim@test.local", "year": year, "total_days": 12, "memo": ""}]
def used_days(self, user_email, year): def used_days(self, user_email, year):
return {"lee@test.local": 4.5}.get(user_email, 0.0) return {"lee@test.local": 4.5}.get(user_email, 0.0)
def save_balances(self, year, rows, by=""): def save_balances(self, rows, by="", as_of=None):
saved.update(year=year, rows=rows, by=by); return len(rows) saved.update(rows=rows, by=by); return len(rows)
def hire_dates(self): def hire_dates(self):
return {"lee@test.local": "2020-03-02"} return {"lee@test.local": "2020-03-02"}
def list_holidays(self, year=None): def list_holidays(self, year=None):
@@ -388,7 +392,7 @@ def body(c):
r = c.get("/vacation/options?year=2026") r = c.get("/vacation/options?year=2026")
assert r.status_code == 200, r.status_code assert r.status_code == 200, r.status_code
t = r.text 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: # 참여자 전원 미리(이름 + 이메일 + 줄마다 칸) for u in users: # 참여자 전원 미리(이름 + 이메일 + 줄마다 칸)
assert f'name="email" value="{u["email"]}"' in t, u["email"] assert f'name="email" value="{u["email"]}"' in t, u["email"]
assert 'src="https://img.test/lee.png"' in t # 사진 있으면 사진, 없으면 첫 글자 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 "법정 연차" 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 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"') j = t.index('name="email" value="kim@test.local"')
assert 'placeholder="12"' in t[j:j + 600], t[j:j + 600] # 올해 없음 → 작년 연차를 회색 참고 assert "입사일 기준" in t and "12/31 에 없어지지 않음" in t and "승인되면" in t and "먼저 소멸" in t
assert "2026.12.31 에 소멸" 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"], 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", "", ""], "hire": ["2020-03-02", "", "2025-03-01"], "total": ["16", "", ""],
"prior": ["", "2.5", ""], "memo": ["a", "b", "c"]}) "prior": ["", "2.5", ""], "memo": ["a", "b", "c"]})
assert r.status_code == 303 and "year=2026" in r.headers["location"], r.status_code assert r.status_code == 303 and r.headers["location"].startswith("/vacation/options?msg="), r.status_code
assert saved == {"year": 2026, "by": "admin@test.local", "rows": [ 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": "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": "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 {"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": [""]} 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=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 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)는 잔여 연차도 보고 저장 # 승인자(옵션 미지정 → 휴가 승인 권한 chip)는 잔여 연차도 보고 저장
who["u"] = chip who["u"] = chip
assert 'id="balances"' in c.get("/vacation/options").text assert 'id="balances"' in c.get("/vacation/options").text
@@ -435,11 +439,11 @@ def body(c):
("/vacation/settings/holidays/1/delete", {}), ("/vacation/settings/holidays/1/delete", {}),
("/vacation/settings/balances", {"user_email": "a@test.local", "year": "2026", "total_days": "1"})): ("/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 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 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 '<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 '<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 # 설정 버튼 없음 assert 'href="/vacation/settings' not in t and ">설정</a>" not in t and 'href="/vacation/options"' in t # 설정 버튼 없음
print("OK") print("OK")
run(body) run(body)