From 4b2defac3aee9c9af0971203b7beb38b423cc982 Mon Sep 17 00:00:00 2001 From: king Date: Mon, 26 Oct 2026 16:27:50 +0900 Subject: [PATCH] =?UTF-8?q?feat(vacation):=20=EC=97=B0=EC=B0=A8=2012/31=20?= =?UTF-8?q?=EC=86=8C=EB=A9=B8=20=EC=82=AD=EC=A0=9C=20=E2=80=94=20=EC=9E=85?= =?UTF-8?q?=EC=82=AC=EC=9D=BC=20=EA=B8=B0=EC=A4=80,=20=EC=97=B0=EC=B0=A8?= =?UTF-8?q?=EB=A7=88=EB=8B=A4=20=EC=93=B8=20=EC=88=98=20=EC=9E=88=EB=8A=94?= =?UTF-8?q?=20=EA=B8=B0=ED=95=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - store.leave_grants/leave_period/leave_status: 1년 미만 월 1일 = 입사일부터 1년까지, 근속 n년 연차 = 생긴 날부터 1년까지(근로기준법 제60조) - 승인된 연차·반차를 날짜별(usage_units = compute_days 규칙)로 나눠 그날 쓸 수 있는 연차 중 먼저 소멸하는 것부터 차감, 생기기 전이면 당겨 씀 - 화면: 지금 연차 기간 · 생기는 연차(오늘까지 +앞으로) · 사용 · 오늘 쓸 수 있는 잔여 · 먼저 소멸(날짜·일수), 해 이동 없음, 달력 위 내 연차도 같은 값 - 직접 입력 = 지금 연차 기간이 시작한 해 줄(override_year), 시스템 전 사용 = 2026 줄(도입일에 쓴 것으로) - 테스트: 규칙(10/12 입사 사례·먼저 소멸·당겨 씀·시스템 전·입사일 없음), 실제 PG, 실제 앱, 브라우저 Co-Authored-By: Claude Opus 5.5 --- app/modules/vacation/CLAUDE.md | 33 ++-- app/modules/vacation/db.py | 129 +++++++------ app/modules/vacation/router.py | 51 +++-- app/modules/vacation/store.py | 138 +++++++++++--- .../vacation/templates/vacation/detail.html | 2 +- .../vacation/templates/vacation/form.html | 4 +- .../vacation/templates/vacation/index.html | 14 +- .../vacation/templates/vacation/options.html | 54 +++--- .../vacation/templates/vacation/pending.html | 2 +- app/static/vacation.css | 5 + app/static/vacation.js | 78 ++++---- docs/DATABASES.md | 4 +- tests/js/render_vacation.py | 17 +- tests/js/vacation_balances.browser.test.js | 64 ++++--- tests/test_vacation_db.py | 180 ++++++++++++------ tests/test_vacation_options_mail.py | 36 ++-- 16 files changed, 500 insertions(+), 311 deletions(-) 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, 설정에서 옮김) — 참여자(휴가 모듈 사용자) 전원을 미리 보여 주고 줄마다 연차 입력. 관리자·승인자·통보자만 보임·저장. -#}
-

잔여 연차 {{ bal_year }}년 · 참여자 {{ bal_rows | selectattr('active') | list | length }}명

- - ‹ {{ bal_year - 1 }} - {{ bal_year + 1 }} › - +

잔여 연차 {{ bal_today | replace('-', '.') }} 기준 · 참여자 {{ bal_rows | selectattr('active') | list | length }}명

-

이름 옆 입사일을 고르면 근로기준법 제60조대로 {{ bal_year }}년에 생기는 연차를 계산합니다 - (입사 1년 미만 = 1개월마다 1일·최대 11일, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일·최대 25일, 출근율은 모두 채운 것으로 봄). - 연차 칸을 비우면 법정 연차를 쓰고, 숫자를 넣으면 그 값을 씁니다. 휴가가 승인되면 차감됩니다(연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 차감 안 함). - {{ bal_year }}년 연차는 {{ bal_year }}.12.31 에 소멸하고 다음 해로 넘어가지 않습니다. - {% if bal_prior_year %}시스템 전 사용 = 이 시스템을 쓰기 전에 {{ bal_year }}년에 이미 쓴 연차(잔여에서 뺍니다).{% endif %}

+

연차는 사람마다 입사일 기준입니다(근로기준법 제60조 — 출근율은 모두 채운 것으로 봄). + 입사 1년 미만은 입사일 + 1~11개월마다 1일씩 생기고 입사일부터 1년까지, 입사일이 돌아올 때마다 15일 + 최초 1년을 넘는 근속 2년마다 1일(최대 25일)이 + 생겨 그날부터 1년까지 씁니다(12/31 에 없어지지 않음). 휴가가 승인되면 그날 쓸 수 있는 연차 중 먼저 소멸하는 것부터 뺍니다 + (연차·오전반차·오후반차 — 병가·경조·대체휴무·기타는 안 뺌, 생기기 전에 쓰면 다음 연차를 당겨 씀). + 직접 입력 = 이번 연차 기간 연차를 법정 대신 그 값으로(비우면 법정). + {% if bal_prior_col %}시스템 전 사용 = 이 시스템을 쓰기 전({{ system_start_year }}년)에 이미 쓴 연차.{% endif %}

{% if not hire_ready %}{% endif %} -
- - - {% if bal_prior_year %}{% endif %} - +
참여자 · 입사일근속법정 연차연차시스템 전 사용사용잔여메모
+ + + {% if bal_prior_col %}{% endif %} + {% for b in bal_rows %} - + - + + - {% if bal_prior_year %} + value="{{ '%g' % b.total if b.total is not none else '' }}" placeholder="{{ '%g' % b.granted if b.hire_date else '' }}" + aria-label="{{ b.name }} 이번 연차 기간 직접 입력(비우면 법정)" /> + {% if bal_prior_col %} {% else %}{% endif %} - + + {% else %} - + {% endfor %}
참여자 · 입사일근속이번 연차 기간생기는 연차직접 입력시스템 전 사용사용잔여먼저 소멸메모
{% if b.picture %} @@ -92,33 +89,34 @@ {{ b.name }} {{ b.email }}{% if not b.active %} · 휴가 권한 없음{% endif %} - {#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값) -#} - {#- 002 전이면 숨김 칸만(서버가 무시) — disabled 는 폼에서 빠져 칸 수가 어긋나므로 쓰지 않는다 -#} + {#- 입사일 — 이름 옆 날짜 버튼(erp-datepop, 숨긴 input 이 값). 002 전이면 숨김 칸만(서버가 무시) -#} {% if b.hire_date %}{{ b.service_years }}년{% else %}—{% endif %}{% if b.period_start %}{{ b.period_start[2:] | replace('-', '.') }} ~ {{ b.period_end[2:] | replace('-', '.') }}{% else %}—{% endif %} {{ '%g' % b.used }}{{ '%g' % b.remaining if b.remaining is not none else '—' }}{{ '%g' % b.available if b.available is not none else '—' }}{% if b.expiring %}{{ b.expiring.date[2:] | replace('-', '.') }} · {{ '%g' % b.expiring.days }}일{% else %}—{% endif %}
휴가 모듈 권한이 있는 사용자가 없습니다.
휴가 모듈 권한이 있는 사용자가 없습니다.
-
+
+
{% endif %} @@ -152,4 +150,4 @@ {% endblock %} {% block scripts %} -{% endblock %} +{% endblock %} diff --git a/app/modules/vacation/templates/vacation/pending.html b/app/modules/vacation/templates/vacation/pending.html index 7bc505d..9ff1055 100644 --- a/app/modules/vacation/templates/vacation/pending.html +++ b/app/modules/vacation/templates/vacation/pending.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {% block content %}
diff --git a/app/static/vacation.css b/app/static/vacation.css index f7acfe3..30ee0fb 100644 --- a/app/static/vacation.css +++ b/app/static/vacation.css @@ -262,3 +262,8 @@ .vac-bal-person .vac-hire-btn .material-symbols-outlined { font-size: 16px; } .vac-bal-legal { color: #1a56db; font-weight: 600; } .vac-bal-years-cell { color: var(--vac-muted); } +/* 잔여 연차 — 입사일 기준(2026-10-27): 연차 기간·먼저 소멸, 바꾼 줄은 저장 전 옅게 */ +.vac-bal-period, .vac-bal-expire { white-space: nowrap; font-size: 12.5px; color: var(--vac-muted); font-variant-numeric: tabular-nums; } +.vac-bal-legal small { font-weight: 500; color: var(--vac-muted); } +.vac-bal-table tr.is-stale .vac-bal-remain, .vac-bal-table tr.is-stale .vac-bal-expire { color: #b45309; font-weight: 600; } +.vac-bal-remain.is-minus { color: var(--vac-red); font-weight: 700; } diff --git a/app/static/vacation.js b/app/static/vacation.js index be199ad..e1fc0d6 100644 --- a/app/static/vacation.js +++ b/app/static/vacation.js @@ -101,69 +101,75 @@ recalc(); })(); -/* 휴가 옵션 — 잔여 연차 표(2026-10-27): 이름 옆 입사일 = 날짜 버튼(erp-datepop), 고르면 근속·법정 연차·잔여를 바로 다시 계산 - (서버 store.legal_annual_leave 와 같은 규칙 — 근로기준법 제60조, 입사일 기준으로 그해에 생기는 연차). 저장은 [잔여 연차 저장]. */ +/* 휴가 옵션 — 잔여 연차 표(2026-10-27, 입사일 기준): 이름 옆 입사일 = 날짜 버튼(erp-datepop). 고르면 근속·이번 연차 기간·생기는 연차 + (오늘까지 + 앞으로)를 바로 다시 계산(서버 store.leave_grants·leave_period 와 같은 규칙 — 근로기준법 제60조). + 사용·잔여·소멸은 승인된 휴가를 연차마다 나눠야 해서 서버가 계산 — 입사일·직접 입력을 바꾸면 "저장 후"로 표시하고 안내. */ (function () { "use strict"; var table = document.querySelector(".vac-bal-table"); if (!table) return; - var year = +table.dataset.year; + var today = table.dataset.today; + var note = document.querySelector(".vac-bal-note"); function iso(d) { return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0"); } + function parse(s) { var p = s.split("-"); return new Date(+p[0], +p[1] - 1, +p[2]); } function addMonths(d, n) { // 같은 날, 없으면 그 달 말일(1/31 + 1달 = 2/28) var m = d.getMonth() + n, y = d.getFullYear() + Math.floor(m / 12); m = ((m % 12) + 12) % 12; - var last = new Date(y, m + 1, 0).getDate(); - return new Date(y, m, Math.min(d.getDate(), last)); + return new Date(y, m, Math.min(d.getDate(), new Date(y, m + 1, 0).getDate())); } - function legal(hireIso) { - if (!hireIso) return null; - var p = hireIso.split("-"), hire = new Date(+p[0], +p[1] - 1, +p[2]); - var y0 = iso(new Date(year, 0, 1)), y1 = iso(new Date(year, 11, 31)); - var days = 0, items = [], n = 1, d; - for (var m = 1; m < 12; m++) { - d = iso(addMonths(hire, m)); - if (d >= y0 && d <= y1) { days += 1; items.push(d.slice(5) + " 입사 " + m + "개월(월 1일) 1일"); } + function dayBefore(d) { return new Date(d.getFullYear(), d.getMonth(), d.getDate() - 1); } + function status(hireIso) { + if (!hireIso || hireIso > today) return null; + var hire = parse(hireIso), n = 0; + while (iso(addMonths(hire, 12 * (n + 1))) <= today) n++; + var p0 = n === 0 ? hireIso : iso(addMonths(hire, 12 * n)), p1 = iso(dayBefore(addMonths(hire, 12 * (n + 1)))); + var so = 0, up = 0, tip = []; + function add(g, days, label, exp) { + if (g < p0 || g > p1) return; + if (g <= today) so += days; else up += days; + tip.push(g.slice(2) + " " + label + " " + days + "일(~" + exp.slice(2) + ")"); } - for (;;) { - d = iso(addMonths(hire, 12 * n)); - if (d > y1) break; - if (d >= y0) { var g = Math.min(25, 15 + Math.floor((n - 1) / 2)); days += g; items.push(d.slice(5) + " 근속 " + n + "년 " + g + "일"); } - n++; + if (n === 0) { + var first = iso(dayBefore(addMonths(hire, 12))); + for (var m = 1; m < 12; m++) add(iso(addMonths(hire, m)), 1, "입사 " + m + "개월(월 1일)", first); + } else { + add(p0, Math.min(25, 15 + Math.floor((n - 1) / 2)), "근속 " + n + "년", p1); } - return { days: days, years: n - 1, tip: items.join(", ") }; + return { years: n, p0: p0, p1: p1, so: so, up: up, tip: tip.join(", ") }; } - function g(v) { return String(Math.round(v * 100) / 100); } + function dots(d) { return d.slice(2).replace(/-/g, "."); } table.querySelectorAll("tr.vac-bal-row").forEach(function (tr) { var hire = tr.querySelector(".vac-hire-input"); var total = tr.querySelector('input[name="total"]'); var prior = tr.querySelector('input[name="prior"]'); - var used = +tr.dataset.used || 0; + function stale() { + tr.querySelector(".vac-bal-remain").textContent = "저장 후"; + tr.querySelector(".vac-bal-remain").classList.remove("is-minus"); + tr.querySelector(".vac-bal-expire").textContent = "저장 후"; + tr.classList.add("is-stale"); + if (note) note.hidden = false; + } function recalc() { - var L = legal(hire.value); - tr.querySelector(".vac-bal-years-cell").textContent = L ? L.years + "년" : "—"; + var S = status(hire.value); + tr.querySelector(".vac-bal-years-cell").textContent = S ? S.years + "년" : "—"; + tr.querySelector(".vac-bal-period").textContent = S ? dots(S.p0) + " ~ " + dots(S.p1) : "—"; var lg = tr.querySelector(".vac-bal-legal"); - lg.textContent = L ? g(L.days) : "—"; - if (L && L.tip) lg.title = L.tip; else lg.removeAttribute("title"); - if (L) total.placeholder = g(L.days); - var manual = total.value.trim() === "" ? null : +total.value; - var base = manual != null ? manual : (L ? L.days : null); - var cell = tr.querySelector(".vac-bal-remain"); - if (base == null) { cell.textContent = "—"; cell.classList.remove("is-minus"); return; } - var rem = base - (prior && prior.value.trim() !== "" ? +prior.value : 0) - used; - cell.textContent = g(rem); - cell.classList.toggle("is-minus", rem < 0); + lg.textContent = S ? String(S.so) : "—"; + if (S && S.up) { var sm = document.createElement("small"); sm.textContent = "(+" + S.up + ")"; lg.append(" ", sm); } + if (S && S.tip) lg.title = S.tip; else lg.removeAttribute("title"); + total.placeholder = S ? String(S.so + S.up) : ""; + stale(); } if (hire && hire.type !== "hidden" && window.ErpDatePop) { window.ErpDatePop.enhance(hire, { label: "입사일", placeholder: "입사일", yearNav: true, format: window.ErpDatePop.fmtFull, className: "vac-hire-btn" }); } if (hire) hire.addEventListener("change", recalc); - total.addEventListener("input", recalc); - if (prior) prior.addEventListener("input", recalc); + total.addEventListener("input", stale); + if (prior) prior.addEventListener("input", stale); }); })(); - diff --git a/docs/DATABASES.md b/docs/DATABASES.md index 86adb08..9d480eb 100644 --- a/docs/DATABASES.md +++ b/docs/DATABASES.md @@ -255,7 +255,7 @@ DDL: `scripts/sql/vacation_db_init.sql` (멱등). DB·역할(`vacation_app`)· 휴가 일수는 서버(`store.compute_days`)에서 재계산: 주말 + 쉬는 날 제외, 오전/오후 반차 0.5일, 시작/종료 반차는 각 0.5 차감. 클라이언트 계산은 미리보기용(같은 공휴일 표). 쉬는 날(2026-10-27) = 국경일·대체공휴일(프로젝트 `KR_HOLIDAYS`, 2026~2030, 새 연도는 그 표에 추가) — `db.holiday_map`. `vacation_holidays` 는 읽지 않는다. -사용 연차 = 승인된 연차·오전반차·오후반차만, 해를 넘는 신청은 해마다 나눠 셈. 연차는 연도별(`vacation_balances.year`)이라 12/31 소멸·이월 없음. +연차(2026-10-27) = **입사일 기준**(`store.leave_status`) — 연차마다 쓸 수 있는 기한이 따로(1년 미만 월 1일 = 입사일부터 1년, 근속 연차 = 생긴 날부터 1년), 12/31 소멸 없음. 쓴 연차 = 승인된 연차·오전반차·오후반차만, 먼저 소멸하는 연차부터 뺀다. `vacation_balances.year` = 직접 입력한 연차 기간이 시작한 해(+ 2026 줄 = 시스템 전 사용). 권한: `vacation`(접근) / `vacation_approver`(승인·반려 — 옵션에 승인자를 지정하면 그 사람들). admin 은 항상 통과. 옵션(승인자·통보자·잔여 연차) 수정 = admin + 승인자 + 통보자. @@ -268,7 +268,7 @@ docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < ``` **마이그레이션 002**(`scripts/sql/vacation_db_002_hire_prior.sql`, 2026-10-27, 멱등): `vacation_employees`(사람마다 입사일 → 근로기준법 제60조 연차, -`store.legal_annual_leave`) · `vacation_balances.prior_used`(시스템 전에 그해 쓴 연차) · `vacation_balances.total_days` NULL 허용(NULL = 입사일 기준 법정 연차). +`store.leave_status`) · `vacation_balances.prior_used`(시스템 전에 쓴 연차, 2026 줄) · `vacation_balances.total_days` NULL 허용(NULL = 입사일 기준 법정 연차). ```bash docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_002_hire_prior.sql diff --git a/tests/js/render_vacation.py b/tests/js/render_vacation.py index 964dfb9..154a1c5 100644 --- a/tests/js/render_vacation.py +++ b/tests/js/render_vacation.py @@ -30,17 +30,20 @@ def main() -> None: html = env.get_template("vacation/form.html").render(**ctx) with open(os.path.join(OUT_DIR, "vac_form.html"), "w", encoding="utf-8") as f: f.write(html) - # 옵션 — 잔여 연차 표(2026, 입사일·법정 연차·시스템 전 사용) → tests/js/.out/vac_options.html - row = {"active": True, "picture": "", "service_years": 0, "legal": None, "legal_tip": "", "total": None, "effective_total": 0, - "prior": 0.0, "used": 0.0, "remaining": None, "memo": "", "last_total": None, "hire_date": ""} + # 옵션 — 잔여 연차 표(2026-10-27 입사일 기준, 오늘 = 2026-10-26 고정) → tests/js/.out/vac_options.html + row = {"active": True, "picture": "", "service_years": 0, "period_start": "", "period_end": "", "granted": 0.0, + "granted_so_far": 0.0, "upcoming": 0.0, "grants_tip": "", "total": None, "prior": 0.0, "used": 0.0, + "available": None, "expiring": None, "memo": "", "hire_date": ""} octx = {**ctx, "page_title": "휴가 — 옵션", "is_admin": True, "can_edit": True, "msg": "", "options": {"approvers": [], "notifiers": [], "ready": True, "updated_by": "", "updated_at": ""}, "candidates": [], "effective_approvers": [], "gmail": {"available": False, "connected": False, "smtp": True}, - "bal_year": 2026, "bal_prior_year": True, "hire_ready": True, + "bal_today": "2026-10-26", "bal_prior_col": True, "system_start_year": 2026, "hire_ready": True, "bal_rows": [ - {**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6, "legal": 17.0, - "legal_tip": "03-02 근속 6년 17일", "used": 4.5, "remaining": 12.5}, - {**row, "email": "kim@test.local", "name": "김철수", "used": 1.0}, + {**row, "email": "lee@test.local", "name": "이팀장", "hire_date": "2020-03-02", "service_years": 6, + "period_start": "2026-03-02", "period_end": "2027-03-01", "granted": 17.0, "granted_so_far": 17.0, + "grants_tip": "26-03-02 근속 6년 17일(~27-03-01)", "used": 4.5, "available": 12.5, + "expiring": {"date": "2027-03-01", "days": 12.5}}, + {**row, "email": "kim@test.local", "name": "김철수"}, ]} html = env.get_template("vacation/options.html").render(**octx) with open(os.path.join(OUT_DIR, "vac_options.html"), "w", encoding="utf-8") as f: diff --git a/tests/js/vacation_balances.browser.test.js b/tests/js/vacation_balances.browser.test.js index fa846ac..5eef9ea 100644 --- a/tests/js/vacation_balances.browser.test.js +++ b/tests/js/vacation_balances.browser.test.js @@ -1,6 +1,8 @@ -// 휴가 옵션 잔여 연차 — 이름 옆 입사일 날짜 버튼 · 근로기준법 연차 바로 계산 · 시스템 전 사용(2026-10-27) — 실제 브라우저(Chromium). +// 휴가 옵션 잔여 연차 — 입사일 기준(2026-10-27, 12/31 소멸 없음) — 실제 브라우저(Chromium). // python tests/js/render_vacation.py // NODE_PATH= PJ_TEST_BROWSER= node tests/js/vacation_balances.browser.test.js +// 이름 옆 입사일 날짜 버튼 → 근속·이번 연차 기간·생기는 연차(오늘까지 +앞으로)를 바로 계산, 사용·잔여·소멸은 "저장 후"(서버 계산), +// 1년씩 이동, 저장하면 줄마다 email·hire·total·prior·memo. 오늘 = 2026-10-26(렌더 데이터에 고정). const fs = require("fs"), path = require("path"); const { chromium } = require("playwright"); const ROOT = path.join(__dirname, "..", ".."); @@ -15,7 +17,7 @@ function check(name, cond, extra) { const browser = await chromium.launch(exe ? { executablePath: exe } : {}); const posts = []; try { - const p = await (await browser.newContext({ viewport: { width: 1400, height: 900 } })).newPage(); + const p = await (await browser.newContext({ viewport: { width: 1500, height: 900 } })).newPage(); await p.route("**/*", function (r) { const req = r.request(), url = new URL(req.url()).pathname; if (url.startsWith("/static/")) { @@ -33,52 +35,62 @@ function check(name, cond, extra) { return p.evaluate(function (email) { const tr = document.querySelector('input[name="email"][value="' + email + '"]').closest("tr"); const btn = tr.querySelector(".vac-hire-btn"); + const t = function (sel) { return tr.querySelector(sel).textContent.trim().replace(/\s+/g, " "); }; return { btn: btn && btn.textContent.replace("calendar_month", "").trim(), nextToName: !!btn && btn.parentElement === tr.querySelector(".vac-bal-person"), hire: tr.querySelector('input[name="hire"]').value, hireShown: getComputedStyle(tr.querySelector('input[name="hire"]')).display !== "none", - years: tr.querySelector(".vac-bal-years-cell").textContent.trim(), legal: tr.querySelector(".vac-bal-legal").textContent.trim(), - placeholder: tr.querySelector('input[name="total"]').placeholder, remain: tr.querySelector(".vac-bal-remain").textContent.trim(), - minus: tr.querySelector(".vac-bal-remain").classList.contains("is-minus") }; + years: t(".vac-bal-years-cell"), period: t(".vac-bal-period"), legal: t(".vac-bal-legal"), + placeholder: tr.querySelector('input[name="total"]').placeholder, remain: t(".vac-bal-remain"), expire: t(".vac-bal-expire"), + stale: tr.classList.contains("is-stale") }; }, email); }; const lee = await rowState("lee@test.local"); - check("입사일 = 이름 옆 날짜 버튼(연도까지), 숨긴 input 이 값", lee.nextToName && !lee.hireShown && lee.btn === "2020.03.02(월)" && - lee.hire === "2020-03-02" && lee.legal === "17" && lee.remain === "12.5", lee); + check("입사일 = 이름 옆 날짜 버튼(연도까지), 이번 연차 기간·잔여·먼저 소멸(12/31 아님)", lee.nextToName && !lee.hireShown && + lee.btn === "2020.03.02(월)" && lee.period === "26.03.02 ~ 27.03.01" && lee.legal === "17" && lee.remain === "12.5" && + lee.expire === "27.03.01 · 12.5일", lee); const kim0 = await rowState("kim@test.local"); - check("입사일 없음 = '입사일' 버튼, 근속·법정 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.legal === "—" && kim0.remain === "—", kim0); - // 김철수 입사일 2025-03-01 직접 입력(Enter) → 근속 1년 · 법정 17(1/1·2/1 월 1일 + 3/1 15일) · 잔여 17 − 1(사용) + check("입사일 없음 = '입사일' 버튼, 기간·연차 —", kim0.btn === "입사일" && kim0.years === "—" && kim0.period === "—" && kim0.remain === "—", kim0); + const head = await p.evaluate(function () { + return Array.from(document.querySelectorAll(".vac-bal-table thead th")).map(function (x) { return x.textContent.trim(); }); + }); + check("표 머리 = 입사일 기준(연차 기간·생기는 연차·잔여·먼저 소멸), 해 이동 버튼 없음", + head.indexOf("이번 연차 기간") >= 0 && head.indexOf("먼저 소멸") >= 0 && head.indexOf("시스템 전 사용") >= 0 && + !(await p.$('a[href*="year="]')), head); + // 김철수 입사일 2026-10-12(오늘 10/26) → 근속 0년 · 기간 26.10.12 ~ 27.10.11 · 오늘까지 0 (+11) await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn'); const pop = await p.evaluate(function () { const el = document.querySelector(".pj-datepop"); - return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder, - clear: !!el.querySelector(".pj-dp-clear") }; + return el && { navs: el.querySelectorAll(".pj-dp-navbtn").length, field: el.querySelector(".pj-dp-field").placeholder }; }); - check("입사일 팝업 = 날짜 하나, « ‹ › » (1년씩 이동), 지우기", !!pop && pop.navs === 4 && pop.field === "입사일" && pop.clear, pop); - await p.fill(".pj-dp-field", "2025-03-01"); + check("입사일 팝업 = 날짜 하나, « ‹ › »", !!pop && pop.navs === 4 && pop.field === "입사일", pop); + await p.fill(".pj-dp-field", "2026-10-12"); await p.press(".pj-dp-field", "Enter"); const kim1 = await rowState("kim@test.local"); - check("입사일 고르면 근속·법정 연차·잔여 바로 계산(근로기준법)", kim1.btn === "2025.03.01(토)" && kim1.hire === "2025-03-01" && - kim1.years === "1년" && kim1.legal === "17" && kim1.placeholder === "17" && kim1.remain === "16", kim1); - // 시스템 전 사용 3.5 → 잔여 12.5, 연차 직접 10 → 10 − 3.5 − 1 = 5.5, 20 넘게 쓰면 빨강 - await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "3.5"); - check("시스템 전 사용 → 잔여에서 뺌", (await rowState("kim@test.local")).remain === "12.5"); - await p.fill('tr:has(input[value="kim@test.local"]) input[name="total"]', "10"); - check("연차 직접 입력이 법정보다 먼저", (await rowState("kim@test.local")).remain === "5.5"); - await p.fill('tr:has(input[value="kim@test.local"]) input[name="prior"]', "12"); + check("10/12 입사 → 이번 기간 26.10.12 ~ 27.10.11, 오늘까지 0 (+11), 잔여·소멸은 저장 후", kim1.btn === "2026.10.12(월)" && + kim1.years === "0년" && kim1.period === "26.10.12 ~ 27.10.11" && kim1.legal === "0 (+11)" && kim1.placeholder === "11" && + kim1.remain === "저장 후" && kim1.expire === "저장 후" && kim1.stale, kim1); + // 2025-03-01 로 바꾸면 근속 1년 · 26.03.01 ~ 27.02.28 · 15 + await p.click('tr:has(input[value="kim@test.local"]) .vac-hire-btn'); + await p.fill(".pj-dp-field", "2025.3.1"); + await p.press(".pj-dp-field", "Enter"); const kim2 = await rowState("kim@test.local"); - check("모자라면 잔여 빨강", kim2.remain === "-3" && kim2.minus, kim2); - // 1년씩 이동 버튼 — 2025년 3월 → « → 2024년 3월 + check("2025-03-01 입사 → 근속 1년 · 26.03.01 ~ 27.02.28 · 15일", kim2.years === "1년" && kim2.period === "26.03.01 ~ 27.02.28" && + kim2.legal === "15" && kim2.placeholder === "15", kim2); + const note = await p.evaluate(function () { return !document.querySelector(".vac-bal-note").hidden; }); + check("바꾸면 '저장하면 다시 계산' 안내", note); + await p.fill('tr:has(input[value="lee@test.local"]) input[name="prior"]', "3"); + check("시스템 전 사용을 바꾸면 그 줄도 저장 후", (await rowState("lee@test.local")).remain === "저장 후"); + // 1년씩 이동 await p.click('tr:has(input[value="lee@test.local"]) .vac-hire-btn'); const t0 = await p.textContent(".pj-dp-title"); await p.click('.pj-dp-navbtn[data-nav="-12"]'); const t1 = await p.textContent(".pj-dp-title"); check("« = 1년 전 달력", t0 === "2020년 3월" && t1 === "2019년 3월", [t0, t1]); await p.keyboard.press("Escape"); - // 저장 — 줄마다 email·hire·total·prior·memo await p.click('button[type="submit"]:has-text("잔여 연차 저장")'); await p.waitForTimeout(200); const body = decodeURIComponent((posts[0] || "").replace(/\+/g, " ")); - check("저장 → 입사일·연차·시스템 전 사용이 줄마다 전송", /email=kim@test.local/.test(body) && /hire=2025-03-01/.test(body) && - /hire=2020-03-02/.test(body) && /total=10/.test(body) && /prior=12/.test(body) && (body.match(/hire=/g) || []).length === 2, body); + check("저장 → 줄마다 입사일·직접 입력·시스템 전 사용(연도 칸 없음)", /email=kim@test.local/.test(body) && /hire=2025-03-01/.test(body) && + /hire=2020-03-02/.test(body) && /prior=3/.test(body) && (body.match(/hire=/g) || []).length === 2 && !/year=/.test(body), body); } finally { await browser.close(); } diff --git a/tests/test_vacation_db.py b/tests/test_vacation_db.py index 8a1da71..b1b64ff 100644 --- a/tests/test_vacation_db.py +++ b/tests/test_vacation_db.py @@ -108,72 +108,127 @@ class VacationHolidayBalanceDBTests(unittest.TestCase): self.st.approve(request_id=req["id"], approver_email="lee@test.local") return req - def test_used_days_only_annual_types_and_split_by_year(self): + def test_usage_only_annual_types_and_hire_based_status(self): + """승인된 연차·반차만 쓴 날로(병가·경조·제출 제외), 입사일 기준으로 먼저 소멸할 연차부터 뺀다(2026-10-27 — 12/31 소멸 없음).""" + from datetime import date + st = self.st owner = f"bal-{uuid.uuid4().hex[:6]}@test.local" - made = [ - self._approved(owner, "연차", "2026-11-02", "2026-11-03"), # 2 - self._approved(owner, "오전반차", "2026-11-04", "2026-11-04"), # 0.5 - self._approved(owner, "병가", "2026-11-05", "2026-11-06"), # 차감 안 함 - self._approved(owner, "경조", "2026-11-09", "2026-11-09"), # 차감 안 함 - self._approved(owner, "연차", "2026-12-30", "2027-01-04"), # 12/30·31 = 2, 1/4 = 1 (1/1 신정·주말 뺌) - ] - st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함 + self._approved(owner, "연차", "2026-11-02", "2026-11-03") # 2 + self._approved(owner, "오전반차", "2026-11-04", "2026-11-04") # 0.5 + self._approved(owner, "병가", "2026-11-05", "2026-11-06") # 차감 안 함 + self._approved(owner, "경조", "2026-11-09", "2026-11-09") # 차감 안 함 + self._approved(owner, "연차", "2026-12-30", "2027-01-04") # 12/30·31·1/4 = 3 (1/1 신정·주말 뺌) + st.create_request(owner=owner, owner_name="테스트", status="제출", # 제출(승인 전)은 차감 안 함 payload={"vacation_type": "연차", "start_date": "2026-11-10", "end_date": "2026-11-10", "start_half": "full", "end_half": "full", "reason": ""}) try: - self.assertEqual(st.used_days(user_email=owner, year=2026), 4.5) - self.assertEqual(st.used_days(user_email=owner, year=2027), 1.0) - st.save_balances(year=2026, rows=[{"user_email": owner, "total_days": 15, "memo": "입사 2020"}]) - s26 = st.balance_summary(user_email=owner, year=2026) - self.assertEqual((s26["total_days"], s26["used_days"], s26["remaining_days"]), (15.0, 4.5, 10.5)) - s27 = st.balance_summary(user_email=owner, year=2027) # 다음 해로 넘어가지 않음(등록 전 = 0) - self.assertEqual((s27["total_days"], s27["remaining_days"]), (0.0, -1.0)) + ev = st.usage_events(user_email=owner) + self.assertEqual(round(sum(a for d, a in ev), 2), 5.5) + self.assertEqual((st.used_days(user_email=owner, year=2026), st.used_days(user_email=owner, year=2027)), (4.5, 1.0)) + # 입사 2020-03-02 → 2026-03-02 근속 6년 17일(2027-03-01 까지) — 12/31 에 안 없어짐 + st.save_balances(rows=[{"user_email": owner, "total_days": None, "memo": "", "hire_date": "2020-03-02"}], + as_of=date(2026, 10, 27)) + s1 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27)) + self.assertEqual((s1["period_start"], s1["period_end"], s1["granted"], s1["used"], s1["available"]), + ("2026-03-02", "2027-03-01", 17.0, 5.5, 11.5)) # 앞날짜 승인 휴가도 이미 차감 + self.assertEqual(s1["expiring"], {"date": "2027-03-01", "days": 11.5}) + s2 = st.balance_summary(user_email=owner, as_of=date(2027, 2, 1)) # 해가 바뀌어도 그대로 + self.assertEqual(s2["available"], 11.5) + s3 = st.balance_summary(user_email=owner, as_of=date(2027, 3, 2)) # 근속 7년 18일 새로 + self.assertEqual((s3["granted"], s3["available"], s3["used"]), (18.0, 18.0, 0.0)) + # 직접 입력 = 이번 연차 기간(2026-03-02 시작 → 2026 줄) 법정 대신 + st.save_balances(rows=[{"user_email": owner, "total_days": 20, "memo": "회사 기준"}], as_of=date(2026, 10, 27)) + self.assertEqual(st.get_balance(user_email=owner, year=2026)["total_days"], 20.0) + s4 = st.balance_summary(user_email=owner, as_of=date(2026, 10, 27)) + self.assertEqual((s4["granted"], s4["available"], s4["manual_total"], s4["memo"]), (20.0, 14.5, 20.0, "회사 기준")) finally: for r in st.list_for(owner): st.hard_delete(request_id=r["id"], user_email=owner, is_admin=True) def test_save_balances_validates_all_or_nothing(self): + from datetime import date + st = self.st a, b = f"a-{uuid.uuid4().hex[:6]}@test.local", f"b-{uuid.uuid4().hex[:6]}@test.local" + on = date(2031, 5, 1) # 입사일 없음 → 직접 입력은 그해(2031) 줄 with self.assertRaises(ValueError): - st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}]) - self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함 - self.assertEqual(st.save_balances(year=2031, rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "}, - {"user_email": b, "total_days": 0}]), 2) + st.save_balances(rows=[{"user_email": a, "total_days": 15}, {"user_email": b, "total_days": 15.3}], as_of=on) + self.assertIsNone(st.get_balance(user_email=a, year=2031)) # 한 줄이라도 틀리면 전부 저장 안 함 + self.assertEqual(st.save_balances(rows=[{"user_email": a.upper(), "total_days": 15.5, "memo": " x "}, + {"user_email": b, "total_days": 0}], as_of=on), 2) self.assertEqual((st.get_balance(user_email=a, year=2031)["total_days"], st.get_balance(user_email=a, year=2031)["memo"]), (15.5, "x")) - st.save_balances(year=2031, rows=[{"user_email": a, "total_days": 20, "memo": ""}]) # 덮어쓰기 + st.save_balances(rows=[{"user_email": a, "total_days": 20, "memo": ""}], as_of=on) # 덮어쓰기 self.assertEqual(st.get_balance(user_email=a, year=2031)["total_days"], 20.0) -class LegalAnnualLeaveTests(unittest.TestCase): - """근로기준법 제60조 — 입사일 기준으로 생기는 연차를 그해에 모은다(2026-10-27, DB 없음).""" +class LeaveRulesTests(unittest.TestCase): + """근로기준법 제60조 — 입사일 기준, 연차마다 쓸 수 있는 기한(2026-10-27, 12/31 소멸 없음, DB 없음).""" - def test_rules(self): - from datetime import date + def test_grants_periods_and_usage_units(self): + from datetime import date as D - from app.modules.vacation.store import add_months, legal_annual_leave as L + from app.modules.vacation.store import add_months, compute_days, leave_grants, leave_period, usage_units - self.assertEqual(add_months(date(2026, 1, 31), 1), date(2026, 2, 28)) - self.assertEqual(add_months(date(2024, 2, 29), 12), date(2025, 2, 28)) - # 입사 1년 미만 = 1개월마다 1일, 입사일이 돌아오면 15일 — 2025-03-01 입사 - self.assertEqual(L(date(2025, 3, 1), 2025)["days"], 9.0) # 4/1 ~ 12/1 - r = L(date(2025, 3, 1), 2026) - self.assertEqual((r["days"], r["service_years"]), (17.0, 1)) # 1/1·2/1(월 1일) + 3/1 근속 1년 15일 - self.assertEqual([i["date"] for i in r["items"]], ["2026-01-01", "2026-02-01", "2026-03-01"]) - self.assertEqual(L(date(2025, 3, 1), 2027)["days"], 15.0) # 근속 2년 = 15일 - # 3년 이상 = 최초 1년을 넘는 근속 2년마다 1일, 최대 25일 - self.assertEqual(L(date(2023, 5, 10), 2026)["days"], 16.0) # 근속 3년 - self.assertEqual(L(date(2020, 3, 2), 2026)["days"], 17.0) # 근속 6년 = 15 + 2 - self.assertEqual(L(date(2001, 1, 1), 2026)["days"], 25.0) # 근속 25년 → 한도 25 - self.assertEqual(L(date(2027, 1, 2), 2026)["days"], 0.0) # 아직 입사 전 - self.assertEqual(L(None, 2026)["days"], 0.0) + self.assertEqual(add_months(D(2026, 1, 31), 1), D(2026, 2, 28)) + self.assertEqual(add_months(D(2024, 2, 29), 12), D(2025, 2, 28)) + g = leave_grants(D(2026, 10, 12), D(2027, 10, 12)) + self.assertEqual([(x["date"].isoformat(), x["days"], x["expires"].isoformat()) for x in g[:2]], + [("2026-11-12", 1.0, "2027-10-11"), ("2026-12-12", 1.0, "2027-10-11")]) # 월 1일 = 입사일부터 1년까지 + self.assertEqual(len([x for x in g if x["period"] == 0]), 11) + self.assertEqual((g[-1]["date"], g[-1]["days"], g[-1]["expires"]), (D(2027, 10, 12), 15.0, D(2028, 10, 11))) + days = {x["period"]: x["days"] for x in leave_grants(D(2001, 1, 1), D(2026, 12, 31)) if x["period"]} + self.assertEqual((days[1], days[2], days[3], days[5], days[6], days[21], days[25]), (15.0, 15.0, 16.0, 17.0, 17.0, 25.0, 25.0)) + self.assertEqual(leave_period(D(2026, 10, 12), D(2026, 10, 26)), (0, D(2026, 10, 12), D(2027, 10, 11))) + self.assertEqual(leave_period(D(2020, 3, 2), D(2026, 10, 26)), (6, D(2026, 3, 2), D(2027, 3, 1))) + hol = {"2027-01-01"} + for kw in ({"start_date": D(2026, 12, 30), "end_date": D(2027, 1, 4), "start_half": "pm", "end_half": "am"}, + {"start_date": D(2026, 11, 4), "end_date": D(2026, 11, 4), "vacation_type": "오전반차"}, + {"start_date": D(2026, 11, 7), "end_date": D(2026, 11, 8)}): + self.assertEqual(sum(a for d, a in usage_units(holidays=hol, **kw)), compute_days(holidays=hol, **kw), kw) + + def test_status_oct12_hire(self): + """10/12 입사 — 오늘(10/26) 쓸 수 있는 연차 0, 이번 기간(~2027-10-11) 11일 생김, 1년 되면 15일(~2028-10-11).""" + from datetime import date as D + + from app.modules.vacation.store import leave_status as S + + h = D(2026, 10, 12) + r = S(hire=h, as_of=D(2026, 10, 26), usages=[]) + self.assertEqual((r["granted"], r["granted_so_far"], r["upcoming"], r["available"], r["expiring"]), (11.0, 0.0, 11.0, 0.0, None)) + r = S(hire=h, as_of=D(2026, 12, 20), usages=[(D(2026, 12, 15), 1.0)]) + self.assertEqual((r["granted_so_far"], r["used"], r["available"], r["expiring"]), (2.0, 1.0, 1.0, {"date": "2027-10-11", "days": 1.0})) + r = S(hire=h, as_of=D(2027, 1, 5), usages=[(D(2026, 12, 15), 1.0)]) # 해가 바뀌어도 그대로 + 1/12 전 + self.assertEqual(r["available"], 1.0) + r = S(hire=h, as_of=D(2027, 10, 12), usages=[(D(2026, 12, 15), 1.0)]) # 남은 월차 10일은 10/11 에 소멸 + self.assertEqual((r["service_years"], r["granted"], r["available"], r["expiring"]), (1, 15.0, 15.0, {"date": "2028-10-11", "days": 15.0})) + r = S(hire=h, as_of=D(2026, 10, 26), usages=[(D(2026, 10, 20), 1.0)]) # 생기기 전에 씀 = 당겨 씀 + self.assertEqual(r["available"], -1.0) + + def test_status_first_expiring_used_first_prior_and_no_hire(self): + from datetime import date as D + + from app.modules.vacation.store import leave_status as S + + # 2025-11-01 입사: 2026-10-01 까지 월차(~2026-10-31), 2026-11-01 15일 — 10/30 에 쓴 1일은 곧 소멸할 월차에서 + h = D(2025, 11, 1) + r = S(hire=h, as_of=D(2026, 10, 30), usages=[(D(2026, 10, 30), 1.0)]) + self.assertEqual((r["available"], r["expiring"]), (10.0, {"date": "2026-10-31", "days": 10.0})) + r = S(hire=h, as_of=D(2026, 11, 2), usages=[(D(2026, 10, 30), 1.0)]) + self.assertEqual((r["available"], r["used"]), (15.0, 0.0)) # 새 기간 15일 그대로 + # 시스템 전 사용 = 도입일(2026-10-27)에 쓴 것으로 + r = S(hire=D(2020, 3, 2), as_of=D(2026, 10, 28), usages=[], prior=4.5) + self.assertEqual((r["used"], r["available"]), (4.5, 12.5)) + # 입사일 없음 + 직접 입력 = 그해 연차(소멸일 없음 — 입사일을 넣어야 계산) + r = S(hire=None, as_of=D(2026, 10, 28), usages=[(D(2026, 5, 4), 1.0), (D(2025, 5, 4), 1.0)], override=15) + self.assertEqual((r["granted"], r["used"], r["available"], r["expiring"], r["has_hire"]), (15.0, 1.0, 14.0, None, False)) + self.assertEqual(S(hire=None, as_of=D(2026, 10, 28), usages=[])["available"], 0.0) @unittest.skipUnless(ENABLED, "VACATION_TEST_DB_URL(localhost) 미설정") class VacationHireDBTests(unittest.TestCase): - """002 — 입사일·시스템 전 사용·연차 비우면 법정(실제 PostgreSQL, 002 적용 DB).""" + """002 — 입사일·시스템 전 사용·직접 입력(실제 PostgreSQL, 002 적용 DB).""" @classmethod def setUpClass(cls): @@ -185,33 +240,36 @@ class VacationHireDBTests(unittest.TestCase): def tearDownClass(cls): cls.st.close() - def test_hire_legal_manual_prior(self): + def test_hire_prior_and_override_rows(self): + from datetime import date + st = self.st + on = date(2026, 10, 28) self.assertTrue(st.hire_ready()) a, b = f"h-{uuid.uuid4().hex[:6]}@test.local", f"h-{uuid.uuid4().hex[:6]}@test.local" - n = st.save_balances(year=2026, by="admin@test.local", rows=[ - {"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2025-03-01"}, - {"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2020-03-02"}, + n = st.save_balances(by="admin@test.local", as_of=on, rows=[ + {"user_email": a, "total_days": None, "prior_used": 3.5, "memo": "", "hire_date": "2026-10-12"}, + {"user_email": b, "total_days": 20, "prior_used": None, "memo": "직접", "hire_date": "2024-11-15"}, ]) self.assertEqual(n, 2) - self.assertEqual(st.hire_dates()[a], "2025-03-01") - sa = st.balance_summary(user_email=a, year=2026) - self.assertEqual((sa["total_days"], sa["manual_total"], sa["legal_days"], sa["prior_used"], sa["remaining_days"]), - (17.0, None, 17.0, 3.5, 13.5)) # 법정 17 − 시스템 전 3.5 - sb = st.balance_summary(user_email=b, year=2026) - self.assertEqual((sb["total_days"], sb["legal_days"], sb["remaining_days"], sb["service_years"]), (20.0, 17.0, 20.0, 6)) - # 2027 — 아무것도 등록 안 해도 입사일로 법정 연차(이월 없음) - self.assertEqual(st.balance_summary(user_email=a, year=2027)["total_days"], 15.0) - # 입사일 지우기("") · 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 - st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}]) - self.assertEqual(st.hire_dates()[a], "2025-03-01") + self.assertEqual(st.hire_dates()[a], "2026-10-12") + sa = st.balance_summary(user_email=a, as_of=on) # 10/12 입사 — 아직 생긴 연차 없음, 시스템 전 사용 3.5 = 당겨 씀 + self.assertEqual((sa["granted"], sa["granted_so_far"], sa["available"], sa["prior_used"]), (11.0, 0.0, -3.5, 3.5)) + # b: 2025-11-15 근속 1년 기간(2025 줄)에 직접 입력 20, 시스템 전 사용은 2026 줄 + self.assertEqual(st.get_balance(user_email=b, year=2025)["total_days"], 20.0) + sb = st.balance_summary(user_email=b, as_of=on) + self.assertEqual((sb["period_start"], sb["granted"], sb["available"], sb["key_year"]), ("2025-11-15", 20.0, 20.0, 2025)) + self.assertEqual(st.balance_summary(user_email=b, as_of=date(2026, 11, 16))["granted"], 15.0) # 다음 기간 = 법정 15 + # 입사일 키 없으면 그대로 · 틀린 입사일은 전부 저장 안 함 · "" = 지움 + st.save_balances(rows=[{"user_email": a, "total_days": None, "prior_used": 0, "memo": ""}], as_of=on) + self.assertEqual(st.hire_dates()[a], "2026-10-12") with self.assertRaises(ValueError): - st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""}, - {"user_email": b, "total_days": None, "hire_date": "2020-13-01"}]) - self.assertEqual(st.hire_dates()[a], "2025-03-01") - st.save_balances(year=2026, rows=[{"user_email": a, "total_days": None, "hire_date": ""}]) + st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""}, + {"user_email": b, "total_days": None, "hire_date": "2020-13-01"}], as_of=on) + self.assertEqual(st.hire_dates()[a], "2026-10-12") + st.save_balances(rows=[{"user_email": a, "total_days": None, "hire_date": ""}], as_of=on) self.assertNotIn(a, st.hire_dates()) - self.assertEqual(st.balance_summary(user_email=a, year=2026)["total_days"], 0.0) + self.assertEqual(st.balance_summary(user_email=a, as_of=on)["available"], 0.0) if __name__ == "__main__": diff --git a/tests/test_vacation_options_mail.py b/tests/test_vacation_options_mail.py index 27f79a7..ce74241 100644 --- a/tests/test_vacation_options_mail.py +++ b/tests/test_vacation_options_mail.py @@ -205,14 +205,18 @@ class Store: return True def hire_dates(self): return {} - def balance_summary(self, user_email, year, hire_date=None): - bal = {b["user_email"]: b for b in self.list_balances(year)}.get(user_email) - used = self.used_days(user_email, year) + def balance_summary(self, user_email, as_of=None, hire_date=None): # db.balance_summary 모양(입사일 기준, 가짜 계산) + from app.timezone import today_kst + as_of = as_of or today_kst() + bal = {b["user_email"]: b for b in self.list_balances(as_of.year)}.get(user_email) + used = self.used_days(user_email, as_of.year) manual = bal["total_days"] if bal else None total = manual if manual is not None else 0.0 - return {"year": year, "total_days": total, "manual_total": manual, "legal_days": None, "legal_items": [], - "service_years": 0, "hire_date": hire_date or "", "prior_used": 0.0, "erp_used": used, - "used_days": used, "remaining_days": total - used, "memo": bal["memo"] if bal else ""} + return {"has_hire": bool(hire_date), "service_years": 0, "period_start": f"{as_of.year}-01-01" if manual is not None else "", + "period_end": f"{as_of.year}-12-31" if manual is not None else "", "granted": total, "granted_so_far": total, + "upcoming": 0.0, "used": used, "available": total - used, "expiring": None, "grants": [], "as_of": as_of.isoformat(), + "hire_date": hire_date or "", "key_year": as_of.year, "manual_total": manual, "prior_used": 0.0, + "memo": bal["memo"] if bal else "", "total_days": total, "used_days": used, "remaining_days": total - used} def holiday_map(self, date_from, date_to): # 국경일 + 설정 공휴일(db.holiday_map) — 해마다 한글날만 return {f"{y}-10-09": "한글날" for y in range(int(date_from[:4]), int(date_to[:4]) + 1)} @@ -368,8 +372,8 @@ class Store2(Store): [{"user_email": "kim@test.local", "year": year, "total_days": 12, "memo": ""}] def used_days(self, user_email, year): return {"lee@test.local": 4.5}.get(user_email, 0.0) - def save_balances(self, year, rows, by=""): - saved.update(year=year, rows=rows, by=by); return len(rows) + def save_balances(self, rows, by="", as_of=None): + saved.update(rows=rows, by=by); return len(rows) def hire_dates(self): return {"lee@test.local": "2020-03-02"} def list_holidays(self, year=None): @@ -388,7 +392,7 @@ def body(c): r = c.get("/vacation/options?year=2026") assert r.status_code == 200, r.status_code t = r.text - assert 'id="balances"' in t and "2026년 · 참여자 4명" in t, t[t.find("잔여 연차"):t.find("잔여 연차") + 200] + assert 'id="balances"' in t and "기준 · 참여자 4명" in t, t[t.find("잔여 연차"):t.find("잔여 연차") + 200] for u in users: # 참여자 전원 미리(이름 + 이메일 + 줄마다 칸) assert f'name="email" value="{u["email"]}"' in t, u["email"] assert 'src="https://img.test/lee.png"' in t # 사진 있으면 사진, 없으면 첫 글자 @@ -401,22 +405,22 @@ def body(c): assert "법정 연차" in t and "시스템 전 사용" in t and "근로기준법 제60조" in t assert 'value="15"' in row and ">4.5<" in row and ">10.5<" in row and 'value="입사 2020"' in row, row j = t.index('name="email" value="kim@test.local"') - assert 'placeholder="12"' in t[j:j + 600], t[j:j + 600] # 올해 없음 → 작년 연차를 회색 참고 - assert "2026.12.31 에 소멸" in t and "승인되면" in t + assert "입사일 기준" in t and "12/31 에 없어지지 않음" in t and "승인되면" in t and "먼저 소멸" in t + assert "12.31 에 소멸" not in t and "12.31 소멸" not in t # 저장 — 빈 칸은 건너뜀, 연도·이메일·메모 그대로 # 저장 — 줄마다 입사일·연차(빈 칸 = 법정)·시스템 전 사용·메모, 저장한 사람 r = c.post("/vacation/options/balances", data={"year": "2026", "email": ["lee@test.local", "kim@test.local", "chip@test.local"], "hire": ["2020-03-02", "", "2025-03-01"], "total": ["16", "", ""], "prior": ["", "2.5", ""], "memo": ["a", "b", "c"]}) - assert r.status_code == 303 and "year=2026" in r.headers["location"], r.status_code - assert saved == {"year": 2026, "by": "admin@test.local", "rows": [ + assert r.status_code == 303 and r.headers["location"].startswith("/vacation/options?msg="), r.status_code + assert saved == {"by": "admin@test.local", "rows": [ {"user_email": "lee@test.local", "total_days": 16.0, "prior_used": None, "memo": "a", "hire_date": "2020-03-02"}, {"user_email": "kim@test.local", "total_days": None, "prior_used": 2.5, "memo": "b", "hire_date": ""}, {"user_email": "chip@test.local", "total_days": None, "prior_used": None, "memo": "c", "hire_date": "2025-03-01"}]}, saved bad = {"year": "2026", "email": ["lee@test.local"], "hire": [""], "prior": [""], "memo": [""]} assert c.post("/vacation/options/balances", data=dict(bad, total=["x"])).status_code == 400 assert c.post("/vacation/options/balances", data={"year": "2026", "email": ["lee@test.local"], "total": ["1"], "memo": [""]}).status_code == 400 # 칸 수 - assert "시스템 전 사용" not in c.get("/vacation/options?year=2027").text # 도입 해(2026)만 + assert "시스템 전 사용" in c.get("/vacation/options").text # 도입 해(2026)·다음 해까지 칸 # 승인자(옵션 미지정 → 휴가 승인 권한 chip)는 잔여 연차도 보고 저장 who["u"] = chip assert 'id="balances"' in c.get("/vacation/options").text @@ -435,11 +439,11 @@ def body(c): ("/vacation/settings/holidays/1/delete", {}), ("/vacation/settings/balances", {"user_email": "a@test.local", "year": "2026", "total_days": "1"})): assert c.post(url, data=data).status_code in (404, 405), url - # 달력 — 국경일·대체공휴일 이름이 날짜 아래, 그 주는 has-hol, 잔여 옆 12/31 소멸 + # 달력 — 국경일·대체공휴일 이름이 날짜 아래, 그 주는 has-hol, 내 연차 = 입사일 기준(12/31 소멸 없음) t = c.get("/vacation/?year=2026&month=10").text assert '개천절' in t and '개천절 대체' in t assert '한글날' 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 "발생 " in t assert 'href="/vacation/settings' not in t and ">설정" not in t and 'href="/vacation/options"' in t # 설정 버튼 없음 print("OK") run(body)