feat(휴가): 협의자 결재·신청 화면 개편(라디오·붙박이 달력·결재 라인)·내 신청 내역

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-02 15:46:19 +09:00
parent f7a3afcebf
commit 97f4a904cd
22 changed files with 1200 additions and 246 deletions
+18 -5
View File
@@ -6,11 +6,24 @@
- 월간 달력(구글식 bar) / 연차·반차 신청 / 승인 워크플로 / 옵션(승인자·통보자·잔여 연차).
- **설정 화면 없음**(2026-10-27 삭제 — [설정] 버튼·공휴일 추가/삭제 기능 포함). `GET /vacation/settings` 는 옵션으로 넘김, 공휴일 저장 주소 없음.
- 권한키 `vacation`(사용)·`vacation_approver`(승인).
- **신청 화면 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업**(2026-10-27, 공용 `app/static/erp-datepop.js`·`.css` — project.js `openDatePopover`·
`enhanceDateInput` 을 떼어 낸 것). 시작일·종료일 input 은 숨긴 값 저장소, 옆 날짜 버튼 둘(`ErpDatePop.enhanceRange`) — 어느 쪽을 눌러도 같은
기간 팝업(누른 칸이 먼저, 시작일 고르면 종료일 칸으로, 종료일 고르면 닫힘, 지우기 없음), 반차는 하루짜리 팝업(시작=종료). 직접 입력(10/27·1027 Enter).
공휴일 = 국경일·대체공휴일(`router._red_holidays` → `db.holiday_map`, 작년~내년, `#vac-holidays`) — 팝업 빨강·이름 + 예상 일수에서도 뺀다(서버 compute_days 와 같은 표).
테스트 `tests/js/vacation_datepop.browser.test.js`(`render_vacation.py`).
- **신청 화면**(2026-11-02, `form.html`) = 위 휴가 종류 라디오(고르면 검은 배경·흰 굵은 글씨) · 왼쪽 붙박이 달력(공용 `ErpDatePop.mountRange` — 팝업과 같은 `.pj-dp-*` 서식,
첫 클릭 시작일·둘째 클릭 종료일·셋째 새로, 하루 = 동그라미, 기간 = 둥근 막대, 반차 = 클릭마다 하루) · 오른쪽 시작일·종료일(읽기 전용, 달력이 채움)·구분·예상 일수·사유 · 아래 결재 라인.
하루짜리는 종료 구분을 숨기고 보내지 않는다(서버 compute_days 도 시작 구분만 씀). 시작일·종료일 숨긴 칸은 브라우저 필수 검사가 안 돼 `vacation.js` 가 제출 전 확인.
공휴일 = 국경일·대체공휴일(`router._red_holidays` → `db.holiday_map`, 작년~내년, `#vac-holidays`) — 달력 빨강·이름 + 예상 일수에서도 뺀다(서버 compute_days 와 같은 표).
옵션의 입사일 버튼은 그대로 `ErpDatePop.enhance`(팝업). 테스트 `tests/js/vacation_datepop.browser.test.js`(`render_vacation.py`).
## 협의자 결재 (2026-11-02, 마이그레이션 `vacation_db_003_consults.sql`)
- 흐름: 작성중 → (협의자 있으면) **협의중** → 모두 승인 → **제출**(결재자 승인 대기) → 승인. 협의자 한 명이 반려하면 신청도 반려(`approver_email` = 그 협의자). 수정·재제출하면 협의가 처음부터(`db.submit`).
협의중에는 결재자가 승인·반려 못 함(`approve`·`reject` 가 status='제출' 만). 일수·연차 차감은 그대로 승인 때만. 마지막 두 명 동시 처리는 `decide_consult` 가 신청 줄을 잠가 막음.
- 표 `vacation_consults`(신청 삭제 시 CASCADE) — 이메일·이름·협의 내용·상태 대기|승인|반려·반려 사유·처리 시각. 003 전이면 `consults_ready()` False → 협의자 칸 잠김, 예전처럼 제출.
- 신청 화면: [구성원 선택] = **ERP 등록 구성원 전체**(`router._people`, 휴가 권한 무관, 본인 제외) 아이콘 + 이름, 복수. 고른 사람마다 협의 내용 칸(`consult_email`·`consult_message` 같은 순서 — 빈 내용도 자리 유지).
[협의자 없음] 체크 = 칸 잠김·전송 안 함. 제출인데 둘 다 없으면 400(작성중 저장은 통과). 통보자·결재자 = 옵션 값, 아이콘 + 이름 표시만.
- 메일(`notify.py`): 제출 = 협의자마다 따로 한 통(자기 내용만, `consult_request`) + 결재자·통보자(전체 협의자·내용). 모두 승인 = `consulted`(결재자·통보자·신청자). 협의 반려 = `rejected`. 한 명 승인만으로는 메일 없음.
- 화면: 달력 위 [내 신청 내역] `/vacation/mine`(협의자별 상태 → 결재 상태), [협의 대기 N] → `/vacation/pending#consults`(이 화면은 이제 누구나, 승인 대기 표는 결재자만, 표에 협의 내용).
상세 = 결재 진행·협의자별 내용·협의 승인/반려. **보기 권한**: 신청자·결재자·통보자 = 전체, 협의자 = 자기 줄만(서버가 거름, 메일 기록도 안 보임).
- **휴가 권한 없는 협의자**: 사이드바에 휴가 메뉴가 없어 메일 링크로 상세(`_guard(consult_of=…)`)에 들어와 처리한다. 달력·내역·대기 화면은 권한이 있어야 함.
- 테스트 `tests/test_vacation_options_mail.py`(메일 내용·폼·권한), `tests/test_vacation_db.py`(실제 PG 흐름).
## 공휴일 · 연차 (2026-10-27)
+101 -11
View File
@@ -337,15 +337,96 @@ class VacationDBStore:
).fetchone()
return self._req_serialize(row) if row else None
# ── 협의자(마이그레이션 003, 2026-11-02) — 테이블이 없으면 협의자 없음 ──
def consults_ready(self) -> bool:
with self._pool.connection() as conn:
row = conn.execute("SELECT to_regclass('public.vacation_consults') AS r").fetchone()
return bool(row and row["r"])
@staticmethod
def _consult_serialize(row: dict[str, Any]) -> dict[str, Any]:
out = dict(row)
if isinstance(out.get("decided_at"), datetime):
out["decided_at"] = out["decided_at"].astimezone(KST).isoformat(timespec="seconds")
return out
def consults_for(self, request_ids: list[str]) -> dict[str, list[dict[str, Any]]]:
"""{신청 id: [협의자…]} — 지정한 순서대로."""
if not request_ids or not self.consults_ready():
return {}
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM vacation_consults WHERE request_id = ANY(%s) ORDER BY id",
(list(request_ids),)).fetchall()
out: dict[str, list[dict[str, Any]]] = {}
for r in rows:
out.setdefault(r["request_id"], []).append(self._consult_serialize(r))
return out
def list_consults(self, *, request_id: str) -> list[dict[str, Any]]:
return self.consults_for([request_id]).get(request_id, [])
def my_consults(self, *, email: str) -> list[dict[str, Any]]:
"""내 협의 차례인 신청(협의중 + 내 줄 대기) — 시작일 순, 줄마다 my_message."""
if not self.consults_ready():
return []
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT r.*, c.message AS my_message FROM vacation_consults c JOIN vacation_requests r ON r.id = c.request_id "
"WHERE c.email = %s AND c.state = '대기' AND r.status = '협의중' ORDER BY r.start_date, r.created_at",
(email.lower().strip(),)).fetchall()
return [self._req_serialize(r) for r in rows]
@staticmethod
def _replace_consults(conn: Any, request_id: str, consults: list[dict[str, Any]]) -> None:
conn.execute("DELETE FROM vacation_consults WHERE request_id = %s", (request_id,))
for c in consults:
conn.execute("INSERT INTO vacation_consults (request_id, email, name, message) VALUES (%s, %s, %s, %s)",
(request_id, c["email"], c.get("name") or "", c.get("message") or ""))
def decide_consult(self, *, request_id: str, email: str, approve: bool, reason: str = "") -> tuple[dict[str, Any], str | None]:
"""협의자 한 명의 승인·반려. 반환 (신청, 알릴 일): 모두 승인 → 제출로 넘어감("consulted"), 반려 → 신청도 반려("rejected"),
아직 남은 협의자가 있으면 None. 신청 줄을 잠가 마지막 두 명이 동시에 눌러도 한 번만 넘어간다."""
email = email.lower().strip()
reason = (reason or "").strip()
if not approve and not reason:
raise ValueError("반려 사유는 필수입니다.")
with self._pool.connection() as conn, conn.transaction():
head = conn.execute("SELECT status FROM vacation_requests WHERE id = %s FOR UPDATE", (request_id,)).fetchone()
if not head:
raise KeyError(request_id)
mine = conn.execute("SELECT state FROM vacation_consults WHERE request_id = %s AND email = %s",
(request_id, email)).fetchone()
if not mine:
raise PermissionError("이 신청의 협의자만 처리할 수 있습니다.")
if head["status"] != "협의중" or mine["state"] != "대기":
raise ValueError("협의 대기 중이 아닙니다(이미 처리됨).")
conn.execute("UPDATE vacation_consults SET state = %s, comment = %s, decided_at = now() WHERE request_id = %s AND email = %s",
("승인" if approve else "반려", reason, request_id, email))
event: str | None = None
if not approve:
event = "rejected"
row = conn.execute("UPDATE vacation_requests SET status = '반려', approver_email = %s, decided_at = now(), "
"reject_reason = %s WHERE id = %s RETURNING *", (email, reason, request_id)).fetchone()
elif conn.execute("SELECT 1 FROM vacation_consults WHERE request_id = %s AND state <> '승인' LIMIT 1", (request_id,)).fetchone():
row = conn.execute("SELECT * FROM vacation_requests WHERE id = %s", (request_id,)).fetchone()
else:
event = "consulted"
row = conn.execute("UPDATE vacation_requests SET status = '제출' WHERE id = %s RETURNING *", (request_id,)).fetchone()
return self._req_serialize(row), event
def create_request(
self, *, owner: str, owner_name: str, payload: dict[str, Any], status: str = "작성중"
self, *, owner: str, owner_name: str, payload: dict[str, Any], status: str = "작성중",
consults: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
"""consults = [{email, name, message}] — 제출이면서 협의자가 있으면 협의중으로 시작."""
h = self._normalize_payload(payload)
if status not in STATUSES:
status = "작성중"
if status == "제출" and consults:
status = "협의중"
days = self._calc_days(h)
req_id = uuid.uuid4().hex[:12]
with self._pool.connection() as conn:
with self._pool.connection() as conn, conn.transaction():
row = conn.execute(
"""
INSERT INTO vacation_requests
@@ -368,12 +449,14 @@ class VacationDBStore:
status,
),
).fetchone()
if consults:
self._replace_consults(conn, req_id, consults)
return self._req_serialize(row)
def update_request(
self, *, request_id: str, owner: str, payload: dict[str, Any]
self, *, request_id: str, owner: str, payload: dict[str, Any], consults: list[dict[str, Any]] | None = None
) -> dict[str, Any]:
"""작성중/반려 상태에서만 본인이 수정 가능."""
"""작성중/반려 상태에서만 본인이 수정 가능. consults 를 넘기면 협의자를 그 목록으로 바꾼다(003 전이면 None)."""
owner = owner.lower().strip()
current = self.get_request(request_id=request_id)
if not current:
@@ -384,7 +467,7 @@ class VacationDBStore:
raise ValueError(f"{current['status']} 상태에서는 수정할 수 없습니다.")
h = self._normalize_payload(payload)
days = self._calc_days(h)
with self._pool.connection() as conn:
with self._pool.connection() as conn, conn.transaction():
row = conn.execute(
"""
UPDATE vacation_requests
@@ -407,25 +490,32 @@ class VacationDBStore:
owner,
),
).fetchone()
if row and consults is not None:
self._replace_consults(conn, request_id, consults)
if not row:
raise KeyError(request_id)
return self._req_serialize(row)
# ── 워크플로 ──
def submit(self, *, request_id: str, owner: str) -> dict[str, Any]:
"""작성중/반려 → 제출 (본인)."""
"""작성중/반려 → 제출(본인). 협의자가 있으면 협의중으로, 다시 제출하면 협의도 처음부터."""
owner = owner.lower().strip()
with self._pool.connection() as conn:
ready = self.consults_ready() # 트랜잭션 전에 — 안에서 두 번째 연결을 잡지 않게
with self._pool.connection() as conn, conn.transaction():
has = ready and conn.execute("SELECT 1 FROM vacation_consults WHERE request_id = %s LIMIT 1", (request_id,)).fetchone()
row = conn.execute(
"""
UPDATE vacation_requests
SET status = '제출', reject_reason = '',
SET status = %s, reject_reason = '',
approver_email = NULL, decided_at = NULL
WHERE id = %s AND owner = %s AND status IN ('작성중', '반려')
RETURNING *
""",
(request_id, owner),
("협의중" if has else "제출", request_id, owner),
).fetchone()
if row and has:
conn.execute("UPDATE vacation_consults SET state = '대기', comment = '', decided_at = NULL WHERE request_id = %s",
(request_id,))
if not row:
raise ValueError("작성중/반려 상태에서만 제출할 수 있습니다.")
return self._req_serialize(row)
@@ -487,7 +577,7 @@ class VacationDBStore:
"""완전 삭제.
- 관리자(is_admin): 모든 상태 삭제 가능.
- 일반 사용자: 본인 + 승인 전(작성중/제출/반려)만. 승인/취소 건은 불가.
- 일반 사용자: 본인 + 승인 전(작성중/협의중/제출/반려)만. 승인/취소 건은 불가.
"""
user_email = user_email.lower().strip()
current = self.get_request(request_id=request_id)
@@ -496,7 +586,7 @@ class VacationDBStore:
if not is_admin:
if current["owner"] != user_email:
raise PermissionError("본인 신청만 삭제할 수 있습니다.")
if current["status"] not in ("작성중", "제출", "반려"):
if current["status"] not in ("작성중", "협의중", "제출", "반려"):
raise ValueError("승인/취소된 휴가는 삭제할 수 없습니다. (관리자 문의)")
with self._pool.connection() as conn:
cur = conn.execute(
+45 -15
View File
@@ -4,7 +4,9 @@
제출 = 승인자 + 승인 통보자
승인 = 승인자 + 승인 통보자 + 신청자
반려 = 승인자 + 승인 통보자 + 신청자
협의 완료(협의자 모두 승인) = 승인자 + 승인 통보자 + 신청자
승인자 = 휴가 옵션의 승인자(없으면 vacation_approver 권한자 — ERP 관리자는 자동으로 넣지 않는다).
협의자(2026-11-02)가 있으면 제출 때 협의자마다 따로 한 통 — 자기 협의 내용만. 그 밖의 메일은 협의자 전체와 협의 내용을 싣는다.
보내는 사람 = 그 일을 한 사람(제출 = 신청자, 승인·반려 = 처리한 승인자)의 **본인 Gmail** — 입출고 발주 메일과 같은
Gmail 연결(inout_db `inout_gmail_tokens`, gmail.send 만, 사람마다 한 번 연결). 연결이 없거나 끊겼거나 Gmail 이 실패하면
회사 알림 메일(SMTP, app/mail.py)로 보내고 보낸 사람 이름·답장 주소를 그 사람으로 한다.
@@ -22,13 +24,16 @@ from .store import HALF_LABELS
logger = logging.getLogger("app.vacation.notify")
EVENTS = ("submitted", "approved", "rejected")
EVENT_WORD = {"submitted": "제출", "approved": "승인", "rejected": "반려"}
EVENTS = ("submitted", "approved", "rejected", "consulted")
EVENT_WORD = {"submitted": "제출", "approved": "승인", "rejected": "반려", "consult_request": "협의 요청", "consulted": "협의 완료"}
EVENT_LEAD = {
"submitted": "휴가 신청이 제출되었습니다. 확인 후 승인해 주세요.",
"approved": "휴가가 승인되었습니다.",
"rejected": "휴가가 반려되었습니다.",
"consult_request": "휴가 협의 요청이 왔습니다. 내용을 확인하고 ERP 휴가 메뉴에서 협의 결재를 진행해 주세요.",
"consulted": "협의가 모두 끝났습니다. 확인 후 승인해 주세요.",
}
LEAD_WITH_CONSULTS = "휴가 신청이 제출되었습니다. 협의자가 모두 승인하면 결재할 수 있습니다."
_WEEKDAYS = "월화수목금토일"
@@ -55,7 +60,7 @@ def approver_emails(options: dict[str, Any], users: list[dict[str, Any]]) -> lis
def recipients(event: str, req: dict[str, Any], options: dict[str, Any], users: list[dict[str, Any]]) -> list[str]:
people = approver_emails(options, users) + _uniq(options.get("notifiers") or [])
if event in ("approved", "rejected"):
if event in ("approved", "rejected", "consulted"):
people.append(req.get("owner") or "")
return _uniq(people)
@@ -87,29 +92,39 @@ def _days(v: Any) -> str:
def build(event: str, req: dict[str, Any], *, actor_name: str, actor_email: str, link: str,
name_of: Any = None) -> dict[str, str]:
"""제목·글·HTML. 사용자 글(사유·반려 사유·이름)은 HTML 에서 늘 escape."""
name_of: Any = None, consult: dict[str, Any] | None = None) -> dict[str, str]:
"""제목·글·HTML. 사용자 글(사유·반려 사유·이름)은 HTML 에서 늘 escape.
협의 요청(consult_request)은 받는 협의자 한 명 몫(consult)만, 나머지 메일은 협의자 전체(req["consults"])와 협의 내용을 싣는다."""
name_of = name_of or (lambda e: e)
owner = req.get("owner_name") or name_of(req.get("owner") or "")
word = EVENT_WORD[event]
consults = req.get("consults") or []
subject = f"[휴가 {word}] {owner} · {req.get('vacation_type', '')} {period_text(req)} ({_days(req.get('days'))}일)"
rows = [("신청자", f"{owner} ({req.get('owner', '')})"), ("종류", req.get("vacation_type") or ""),
("기간", period_text(req)), ("일수", f"{_days(req.get('days'))}일"), ("사유", req.get("reason") or "-")]
if event == "submitted":
rows.append(("상태", "제출 — 승인 대기"))
if event == "consult_request":
rows += [("상태", "협의 대기"), ("협의 내용", (consult or {}).get("message") or "-")]
elif event == "consulted":
rows.append(("상태", "협의 완료 — 승인 대기"))
elif event == "submitted":
rows.append(("상태", "협의 진행 중" if consults else "제출 — 승인 대기"))
else:
rows.append(("상태", word))
rows.append((f"{word}자", f"{actor_name} ({actor_email})"))
if event == "rejected":
rows.append(("반려 사유", req.get("reject_reason") or "-"))
text = "\n".join([EVENT_LEAD[event], ""] + [f"{k}: {v}" for k, v in rows] + ["", f"휴가 신청 보기: {link}"])
if event != "consult_request":
rows += [(f"협의자 {c.get('name') or name_of(c.get('email') or '')}",
f"{c.get('state') or '대기'} — {c.get('message') or '협의 내용 없음'}") for c in consults]
lead = LEAD_WITH_CONSULTS if event == "submitted" and consults else EVENT_LEAD[event]
text = "\n".join([lead, ""] + [f"{k}: {v}" for k, v in rows] + ["", f"휴가 신청 보기: {link}"])
tr = "".join(
f'<tr><th style="text-align:left;padding:6px 12px 6px 0;color:#666;font-weight:600;white-space:nowrap;vertical-align:top">'
f'{escape(k)}</th><td style="padding:6px 0;white-space:pre-wrap">{escape(str(v))}</td></tr>' for k, v in rows)
color = {"submitted": "#1a56db", "approved": "#0f8a3a", "rejected": "#c22b10"}[event]
color = {"approved": "#0f8a3a", "rejected": "#c22b10"}.get(event, "#1a56db")
html = (
'<div style="font-family:Pretendard,\'Malgun Gothic\',sans-serif;font-size:14px;color:#111;line-height:1.5">'
f'<p style="margin:0 0 12px;font-size:16px;font-weight:700;color:{color}">{escape(EVENT_LEAD[event])}</p>'
f'<p style="margin:0 0 12px;font-size:16px;font-weight:700;color:{color}">{escape(lead)}</p>'
f'<table style="border-collapse:collapse;margin:0 0 16px">{tr}</table>'
f'<p style="margin:0"><a href="{escape(link, quote=True)}" style="display:inline-block;padding:8px 14px;border-radius:6px;'
f'background:{color};color:#fff;text-decoration:none;font-weight:600">휴가 신청 보기</a></p>'
@@ -156,9 +171,8 @@ def _send_gmail(inout_store: Any, *, email: str, name: str, to: list[str], mail:
def deliver(store: Any, inout_store: Any, *, event: str, req: dict[str, Any], actor: dict[str, Any],
users: list[dict[str, Any]], link: str) -> dict[str, Any]:
"""받는 사람을 정해 한 통 보내고 기록한다. 반환 {ok, via, to, error} (테스트·로그용)."""
from app import mail as smtp # noqa: WPS433
"""받는 사람을 정해 한 통 보내고 기록한다. 제출이면 협의자마다 자기 몫 협의 요청도 따로 한 통씩.
반환 {ok, via, to, error} (테스트·로그용, 협의 요청 제외)."""
if event not in EVENTS:
raise ValueError(event)
try:
@@ -169,13 +183,29 @@ def deliver(store: Any, inout_store: Any, *, event: str, req: dict[str, Any], ac
names = {_norm(u.get("email")): u.get("name") or "" for u in users}
email = _norm(actor.get("email"))
name = actor.get("name") or names.get(email) or email.split("@")[0]
def name_of(e: Any) -> str:
return names.get(_norm(e)) or str(e).split("@")[0]
if event == "submitted":
for c in req.get("consults") or []:
mail = build("consult_request", req, actor_name=name, actor_email=email, link=link, name_of=name_of, consult=c)
_send_and_log(store, inout_store, "consult_request", req, _uniq([c.get("email")]), mail, email, name)
result: dict[str, Any] = {"ok": False, "via": "", "to": to, "error": ""}
if not to:
result["error"] = "받는 사람 없음(승인자·통보자 미지정)"
logger.info("휴가 메일 받는 사람 없음 — %s %s", event, req.get("id"))
return result
mail = build(event, req, actor_name=name, actor_email=email, link=link,
name_of=lambda e: names.get(_norm(e)) or str(e).split("@")[0])
mail = build(event, req, actor_name=name, actor_email=email, link=link, name_of=name_of)
return _send_and_log(store, inout_store, event, req, to, mail, email, name)
def _send_and_log(store: Any, inout_store: Any, event: str, req: dict[str, Any], to: list[str], mail: dict[str, str],
email: str, name: str) -> dict[str, Any]:
"""한 통 보내기 — 본인 Gmail, 안 되면 회사 SMTP. 결과는 vacation_mail_log 에."""
from app import mail as smtp # noqa: WPS433
result: dict[str, Any] = {"ok": False, "via": "", "to": to, "error": ""}
ok, gmail_err = _send_gmail(inout_store, email=email, name=name, to=to, mail=mail)
if ok:
result.update(ok=True, via="gmail")
+169 -23
View File
@@ -3,6 +3,7 @@
- 경로: /vacation
- 권한: 로그인 + `vacation` 모듈 권한 (관리자는 항상 통과). 서버 측 검사.
승인/반려 = admin + (휴가 옵션에 승인자를 지정했으면 그 사람들, 아니면 `vacation_approver` 권한자) — 2026-10-27.
- 협의자(2026-11-02, 마이그레이션 003): 신청자가 지정(복수) → 모두 승인해야 결재자에게 넘어감(상태 협의중 → 제출). 협의자는 휴가 권한이 없어도 자기 신청은 볼 수 있다.
- 휴가 옵션(`/vacation/options`, 수정 = admin·승인자·통보자): 승인자·승인 통보자·잔여 연차. 공휴일 = 국경일 표(설정 화면 없음). 제출·승인·반려 메일은 `notify.py`
(처리한 사람 본인 Gmail — 입출고와 같은 Gmail 연결, 없으면 회사 SMTP).
- 데이터: VacationDBStore (vacation_db / PostgreSQL) 전용.
@@ -61,6 +62,16 @@ def _require_approver(request: Request) -> dict[str, Any]:
return user
def _require_login(request: Request) -> dict[str, Any]:
"""로그인만 — 협의 결재처럼 휴가 모듈 권한이 없어도 되는 곳(협의자 여부는 저장소가 확인)."""
from app.main import get_current_user_record # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
return user
def _options(request: Request) -> dict[str, Any]:
"""휴가 옵션(승인자·통보자, 마이그레이션 001). DB·001 이 없으면 빈 옵션."""
st = _store(request)
@@ -111,6 +122,38 @@ def _vacation_users() -> list[dict[str, Any]]:
return out
def _people() -> dict[str, dict[str, str]]:
"""전체 구성원(휴가 권한과 무관) {이메일: 이메일·이름·사진} — 협의자 후보·결재 라인 아이콘. 이름 순."""
from app.main import user_store # noqa: WPS433
rows = [{"email": u["email"].lower(), "name": u.get("name") or u["email"].split("@")[0], "picture": u.get("picture") or ""}
for u in user_store.list_all()]
rows.sort(key=lambda p: p["name"].lower())
return {p["email"]: p for p in rows}
def _form_consults(store: Any, owner: str, emails: list[str], messages: list[str], no_consult: str, action: str) -> list[dict[str, Any]] | None:
"""폼의 협의자 줄 → [{email, name, message}]. 003 전이면 None(협의자 없음). 제출인데 협의자도 "협의자 없음"도 없으면 400."""
if not store.consults_ready():
return None
if no_consult:
return []
if len(emails) != len(messages):
raise HTTPException(status_code=400, detail="협의자 칸이 맞지 않습니다.")
known = _people()
out: dict[str, dict[str, Any]] = {}
for raw, message in zip(emails, messages):
email = raw.strip().lower()
if email == owner.lower():
continue
if email not in known:
raise HTTPException(status_code=400, detail=f"등록된 구성원만 협의자로 고를 수 있습니다: {email}")
out[email] = {"email": email, "name": known[email]["name"], "message": message.strip()[:2000]}
if action == "submit" and not out:
raise HTTPException(status_code=400, detail="협의자를 고르거나 '협의자 없음'을 체크하세요.")
return list(out.values())
def _notify(bg: BackgroundTasks, request: Request, event: str, req: dict[str, Any] | None,
actor: dict[str, Any]) -> None:
"""제출·승인·반려 메일을 응답 뒤 백그라운드로(notify.deliver — 받는 사람·보내는 사람 규칙은 그쪽)."""
@@ -121,6 +164,10 @@ def _notify(bg: BackgroundTasks, request: Request, event: str, req: dict[str, An
st = _store(request)
if st is None or not req:
return
try:
req = {**req, "consults": st.list_consults(request_id=req["id"])}
except Exception: # noqa: BLE001 — 협의자 조회 실패가 처리 결과를 뒤집지 않게(메일만 협의 내용 없이)
req = {**req, "consults": []}
base = (env("PUBLIC_BASE_URL") or str(request.base_url)).rstrip("/")
inout_store = getattr(request.app.state, "inout_store", None)
bg.add_task(notify.deliver, st, inout_store, event=event, req=req, actor=dict(actor),
@@ -147,23 +194,26 @@ def _render_config_needed(request: Request, user: dict[str, Any]) -> HTMLRespons
def _guard(
request: Request,
request: Request, consult_of: str = "",
) -> tuple[Any, dict[str, Any]] | HTMLResponse | RedirectResponse:
"""로그인+권한+store 점검. 페이지 핸들러 진입부에서 사용."""
"""로그인+권한+store 점검. 페이지 핸들러 진입부에서 사용.
consult_of = 신청 id — 휴가 권한이 없어도 그 신청의 협의자면 통과(메일 링크로 들어와 협의 결재)."""
from app.main import get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin, login_redirect # noqa: WPS433
user = get_current_user_record(request)
if user is None:
return login_redirect(request)
if not has_module(user, "vacation"):
store = _store(request)
allowed = has_module(user, "vacation") or (store is not None and consult_of and any(
c["email"] == user["email"].lower() for c in store.list_consults(request_id=consult_of)))
if not allowed:
return render_template(
request,
"denied.html",
{"reason": "휴가 관리 모듈 접근 권한이 없습니다.", "is_admin": is_admin(user)},
status_code=403,
)
store = _store(request)
if store is None:
return _render_config_needed(request, user)
return store, user
@@ -184,6 +234,7 @@ def _ym(request: Request) -> tuple[int, int]:
# 상태별 bar 스타일 클래스 (CSS 와 매핑)
_STATUS_CLASS = {
"작성중": "vac-bar-draft",
"협의중": "vac-bar-submit",
"제출": "vac-bar-submit",
"승인": "vac-bar-approve",
"반려": "vac-bar-reject",
@@ -323,6 +374,7 @@ def index(request: Request) -> HTMLResponse:
"is_admin": is_admin(user),
"is_approver": is_approver,
"pending_count": pending_count,
"consult_count": len(store.my_consults(email=user["email"])),
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 관리",
"page_subtitle": f"{year}년 {month}월 휴가 달력",
@@ -344,11 +396,29 @@ def index(request: Request) -> HTMLResponse:
# ════════════════════════════════════════════════════════════
# 휴가 신청 — 등록 / 수정 / 상세
# ════════════════════════════════════════════════════════════
def _form_context(request: Request, user: dict[str, Any]) -> dict[str, Any]:
def _approval_line(request: Request, people: dict[str, dict[str, str]]) -> dict[str, list[dict[str, str]]]:
"""옵션에 세팅된 결재자·통보자(아이콘 + 이름) — 신청 화면·상세의 결재 라인."""
from . import notify # noqa: WPS433
opts = _options(request)
def who(emails: list[str]) -> list[dict[str, str]]:
return [people.get(e) or {"email": e, "name": e.split("@")[0], "picture": ""} for e in emails]
return {"approvers": who(notify.approver_emails(opts, _vacation_users())), "notifiers": who(opts.get("notifiers") or [])}
def _form_context(request: Request, user: dict[str, Any], req: dict[str, Any] | None = None) -> dict[str, Any]:
from app.main import build_erp_nav # noqa: WPS433
from app.store import is_admin # noqa: WPS433
people = _people()
st = _store(request)
return {
"members": [p for e, p in people.items() if e != user["email"].lower()],
"consult_ready": bool(st is not None and st.consults_ready()),
"consult_chosen": {c["email"]: c["message"] for c in st.list_consults(request_id=req["id"])} if req and st is not None else {},
"line": _approval_line(request, people),
"user": user,
"is_admin": is_admin(user),
"is_approver": _is_approver(request, user),
@@ -422,6 +492,9 @@ def create(
end_half: str = Form("full"),
reason: str = Form(""),
action: str = Form("submit"), # "draft" | "submit"
consult_email: list[str] = Form(default=[]),
consult_message: list[str] = Form(default=[]),
no_consult: str = Form(""),
user: dict[str, Any] = Depends(_require_user),
) -> RedirectResponse:
store = _store(request)
@@ -431,12 +504,14 @@ def create(
payload = _payload_from_form(
vacation_type, start_date, end_date, start_half, end_half, reason
)
consults = _form_consults(store, user["email"], consult_email, consult_message, no_consult, action)
try:
req = store.create_request(
owner=user["email"],
owner_name=user.get("name") or user["email"],
payload=payload,
status=status,
consults=consults,
)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
@@ -454,26 +529,57 @@ def pending_page(request: Request) -> HTMLResponse:
if not isinstance(guard, tuple):
return guard
store, user = guard
if not _is_approver(request, user):
return render_template(
request,
"denied.html",
{"reason": "휴가 승인자 권한이 없습니다.", "is_admin": is_admin(user)},
status_code=403,
)
pending = store.list_pending()
is_approver = _is_approver(request, user)
pending = store.list_pending() if is_approver else []
consults = store.my_consults(email=user["email"])
by_req = store.consults_for([r["id"] for r in pending])
for r in pending:
r["consults"] = by_req.get(r["id"], [])
return render_template(
request,
"vacation/pending.html",
{
"user": user,
"is_admin": is_admin(user),
"is_approver": True,
"is_approver": is_approver,
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 — 승인 대기",
"page_subtitle": f"제출 상태 {len(pending)}건",
"page_title": "휴가 — 결재 대기",
"page_subtitle": f"협의 {len(consults)}건" + (f" · 승인 {len(pending)}건" if is_approver else ""),
"items": pending,
"consult_items": consults,
"half_labels": HALF_LABELS,
"people": _people(),
},
)
@router.get("/mine", response_class=HTMLResponse)
def mine_page(request: Request) -> HTMLResponse:
"""내 휴가 신청 내역 — 협의·결재 진행 상황(2026-11-02)."""
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
guard = _guard(request)
if not isinstance(guard, tuple):
return guard
store, user = guard
items = store.list_for(user["email"])
by_req = store.consults_for([r["id"] for r in items])
for r in items:
r["consults"] = by_req.get(r["id"], [])
return render_template(
request,
"vacation/mine.html",
{
"user": user,
"is_admin": is_admin(user),
"is_approver": _is_approver(request, user),
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 — 내 신청 내역",
"page_subtitle": f"{len(items)}건",
"items": items,
"half_labels": HALF_LABELS,
"people": _people(),
},
)
@@ -776,7 +882,7 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
guard = _guard(request)
guard = _guard(request, consult_of=request_id)
if not isinstance(guard, tuple):
return guard
store, user = guard
@@ -787,14 +893,20 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
{"reason": "휴가 신청을 찾을 수 없습니다.", "is_admin": is_admin(user)},
status_code=404,
)
email = user["email"].lower()
is_owner = req["owner"] == user["email"]
is_approver = _is_approver(request, user)
if not (is_owner or is_approver):
consults = store.list_consults(request_id=request_id)
mine = next((c for c in consults if c["email"] == email), None)
see_all = is_owner or is_approver or email in (_options(request).get("notifiers") or [])
if not (see_all or mine):
return render_template(
request, "denied.html",
{"reason": "본인 또는 승인자만 조회할 수 있습니다.", "is_admin": is_admin(user)},
{"reason": "본인·승인자·통보자·협의자만 조회할 수 있습니다.", "is_admin": is_admin(user)},
status_code=403,
)
req["consults"] = consults if see_all else [mine] # 협의자는 자기 몫 협의 내용만
people = _people()
return render_template(
request,
"vacation/detail.html",
@@ -809,8 +921,11 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
"req": req,
"half_labels": HALF_LABELS,
"can_edit": is_owner and req["status"] in ("작성중", "반려"),
"mail_log": _mail_log(store, request_id),
"event_words": {"submitted": "제출", "approved": "승인", "rejected": "반려"},
"can_consult": bool(mine and mine["state"] == "대기" and req["status"] == "협의중"),
"people": people,
"line": _approval_line(request, people),
"mail_log": _mail_log(store, request_id) if see_all else [],
"event_words": {"submitted": "제출", "approved": "승인", "rejected": "반려", "consult_request": "협의 요청", "consulted": "협의 완료"},
},
)
@@ -851,7 +966,7 @@ def edit_form(request: Request, request_id: str) -> HTMLResponse:
{"reason": f"{req['status']} 상태에서는 수정할 수 없습니다.", "is_admin": is_admin(user)},
status_code=409,
)
ctx = _form_context(request, user)
ctx = _form_context(request, user, req)
ctx.update(
{
"page_title": "휴가 신청 수정",
@@ -876,6 +991,9 @@ def update(
end_half: str = Form("full"),
reason: str = Form(""),
action: str = Form("save"), # "save" | "submit"
consult_email: list[str] = Form(default=[]),
consult_message: list[str] = Form(default=[]),
no_consult: str = Form(""),
user: dict[str, Any] = Depends(_require_user),
) -> RedirectResponse:
store = _store(request)
@@ -884,8 +1002,9 @@ def update(
payload = _payload_from_form(
vacation_type, start_date, end_date, start_half, end_half, reason
)
consults = _form_consults(store, user["email"], consult_email, consult_message, no_consult, action)
try:
store.update_request(request_id=request_id, owner=user["email"], payload=payload)
store.update_request(request_id=request_id, owner=user["email"], payload=payload, consults=consults)
if action == "submit":
_notify(bg, request, "submitted", store.submit(request_id=request_id, owner=user["email"]), user)
except KeyError:
@@ -914,6 +1033,33 @@ def submit(
return RedirectResponse(url=f"/vacation/{request_id}", status_code=303)
@router.post("/{request_id}/consult")
def consult_decide(
request: Request,
request_id: str,
bg: BackgroundTasks,
decision: str = Form(...), # "approve" | "reject"
reject_reason: str = Form(""),
user: dict[str, Any] = Depends(_require_login),
) -> RedirectResponse:
"""협의 결재 — 모두 승인하면 제출(결재자 승인 대기)로, 한 명이 반려하면 신청도 반려."""
store = _store(request)
if store is None:
raise HTTPException(status_code=503, detail="vacation_db 미설정")
try:
req, event = store.decide_consult(request_id=request_id, email=user["email"], approve=decision == "approve",
reason=reject_reason)
except KeyError:
raise HTTPException(status_code=404, detail="휴가 신청을 찾을 수 없습니다.")
except PermissionError as exc:
raise HTTPException(status_code=403, detail=str(exc))
except ValueError as exc:
raise HTTPException(status_code=409, detail=str(exc))
if event:
_notify(bg, request, event, req, user)
return RedirectResponse(url=f"/vacation/{request_id}", status_code=303)
@router.post("/{request_id}/approve")
def approve(
request: Request,
+2 -1
View File
@@ -24,7 +24,8 @@ VACATION_TYPES: tuple[str, ...] = (
)
# 신청 상태 워크플로
STATUSES: tuple[str, ...] = ("작성중", "제출", "승인", "반려", "취소")
# 협의중 = 협의자 승인 대기(2026-11-02, 마이그레이션 003) — 협의자가 모두 승인하면 제출(결재자 승인 대기)
STATUSES: tuple[str, ...] = ("작성중", "협의중", "제출", "승인", "반려", "취소")
# 시작/종료일 구분
HALVES: tuple[str, ...] = ("full", "am", "pm")
@@ -0,0 +1,36 @@
{#- 결재 라인 공용 조각(2026-11-02) — 아이콘 + 이름, 협의·결재 진행 상황 -#}
{% macro face(p) -%}
{% if p.picture %}<img class="vac-opt-face" src="{{ p.picture }}" alt="" referrerpolicy="no-referrer" />
{%- else %}<span class="vac-opt-face is-ini">{{ (p.name or p.email)[:1] }}</span>{% endif %}
{%- endmacro %}
{% macro person(p) -%}
<span class="vac-person">{{ face(p) }}<span class="vac-opt-name">{{ p.name or p.email }}</span></span>
{%- endmacro %}
{% macro status_badge(status) -%}
{% set badge = 'erp-badge-neutral' %}
{% if status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }}">{{ status }}</span>
{%- endmacro %}
{#- 협의자별 상태 → 결재 상태. r.consults 필요 -#}
{% macro progress(r, people) -%}
{% set rejected_in_consult = r.consults | selectattr('state', 'equalto', '반려') | list %}
<span class="vac-steps">
{% for c in r.consults %}
{% set p = people.get(c.email) or {'email': c.email, 'name': c.name, 'picture': ''} %}
<span class="vac-step is-{{ {'대기': 'wait', '승인': 'ok', '반려': 'no'}[c.state] }}" title="협의 {{ c.state }}">{{ face(p) }}{{ p.name or p.email }} <b>{{ c.state }}</b></span>
{% endfor %}
{% if r.consults %}<span class="vac-step-arrow" aria-hidden="true">→</span>{% endif %}
{% if r.status == '협의중' %}<span class="vac-step is-wait">결재 <b>협의 후</b></span>
{% elif r.status == '제출' %}<span class="vac-step is-wait">결재 <b>대기</b></span>
{% elif r.status == '승인' %}<span class="vac-step is-ok">결재 <b>승인</b></span>
{% elif r.status == '반려' and not rejected_in_consult %}<span class="vac-step is-no">결재 <b>반려</b></span>
{% elif r.status == '반려' %}<span class="vac-step">결재 <b>안 넘어감</b></span>
{% elif r.status == '작성중' %}<span class="vac-step">결재 <b>제출 전</b></span>
{% else %}<span class="vac-step">{{ r.status }}</span>{% endif %}
</span>
{%- endmacro %}
@@ -1,6 +1,7 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac">
@@ -13,7 +14,7 @@
</div>
{% set badge = 'erp-badge-neutral' %}
{% if req.status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif req.status == '제출' %}{% set badge = 'erp-badge-inverse' %}
{% elif req.status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif req.status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }} vac-detail-status">{{ req.status }}</span>
</div>
@@ -24,7 +25,7 @@
<div><dt>시작일</dt><dd>{{ req.start_date }} ({{ half_labels[req.start_half] }})</dd></div>
<div><dt>종료일</dt><dd>{{ req.end_date }} ({{ half_labels[req.end_half] }})</dd></div>
{% if req.approver_email %}
<div><dt>승인자</dt><dd>{{ req.approver_email }}</dd></div>
<div><dt>{{ '반려자' if req.status == '반려' else '승인자' }}</dt><dd>{{ req.approver_email }}</dd></div>
<div><dt>결재일시</dt><dd>{{ req.decided_at }}</dd></div>
{% endif %}
</dl>
@@ -43,6 +44,42 @@
</div>
{% endif %}
{#- 결재 라인(2026-11-02) — 협의자별 상태·협의 내용(협의자에게는 자기 줄만, 서버가 거름), 통보자·결재자 -#}
<div class="vac-detail-block vac-line">
<div class="vac-detail-label">결재 진행</div>
<p class="vac-line-progress">{{ vm.progress(req, people) }}</p>
{% for c in req.consults %}
{% set p = people.get(c.email) or {'email': c.email, 'name': c.name, 'picture': ''} %}
<div class="vac-line-consult">
<div>{{ vm.person(p) }} <span class="erp-muted">협의 {{ c.state }}{% if c.decided_at %} · {{ c.decided_at[5:16] | replace('T', ' ') }}{% endif %}</span></div>
{% if c.message %}<p>{{ c.message }}</p>{% endif %}
{% if c.comment %}<p class="vac-line-comment">반려 사유: {{ c.comment }}</p>{% endif %}
</div>
{% endfor %}
<div class="vac-line-row">
<span class="vac-line-label">통보자</span>
<div class="vac-line-body">{% for p in line.notifiers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">없음</span>{% endfor %}</div>
</div>
<div class="vac-line-row">
<span class="vac-line-label">결재자</span>
<div class="vac-line-body">{% for p in line.approvers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">ERP 관리자</span>{% endfor %}</div>
</div>
</div>
{% if can_consult %}
<div class="vac-approve-box">
<form method="post" action="/vacation/{{ req.id }}/consult" class="vac-inline-form">
<input type="hidden" name="decision" value="approve" />
<button type="submit" class="erp-btn erp-btn-primary">협의 승인</button>
</form>
<form method="post" action="/vacation/{{ req.id }}/consult" class="vac-reject-form">
<input type="hidden" name="decision" value="reject" />
<input class="erp-input" type="text" name="reject_reason" placeholder="반려 사유" required />
<button type="submit" class="erp-btn erp-btn-danger">협의 반려</button>
</form>
</div>
{% endif %}
<!-- ── 승인자 액션 (제출 상태) ── -->
{% if is_approver and req.status == '제출' %}
<div class="vac-approve-box">
@@ -91,7 +128,7 @@
</form>
{% endif %}
{% if req.status in ('작성중', '제출', '반려') and (is_owner or is_admin) %}
{% if req.status in ('작성중', '협의중', '제출', '반려') and (is_owner or is_admin) %}
<form method="post" action="/vacation/{{ req.id }}/delete" class="vac-inline-form"
onsubmit="return confirm('이 휴가 신청을 삭제할까요? (복구 불가)');">
<button type="submit" class="erp-btn erp-btn-danger">삭제</button>
+105 -43
View File
@@ -1,9 +1,10 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
{#- 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop) -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />
{#- 달력 = ERP 공용 달력 서식(2026-11-02, erp-datepop mountRange) -#}
<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=20261102a" />{% endblock %}
{% block content %}
<section class="vac">
@@ -11,51 +12,112 @@
{% set action = '/vacation/new' if mode == 'new' else '/vacation/' ~ req.id ~ '/edit' %}
<form id="vac-form" method="post" action="{{ action }}" class="erp-card vac-form-card">
<div class="vac-form-grid">
<label class="erp-field"><span>휴가 종류 *</span>
<select class="erp-select" name="vacation_type" id="vac-type" required>
{% for t in vacation_types %}
<option value="{{ t }}" {% if req and req.vacation_type == t %}selected{% endif %}>{{ t }}</option>
{% endfor %}
</select>
</label>
<fieldset class="vac-types">
<legend>휴가 종류</legend>
{% for t in vacation_types %}
<label class="vac-type"><input type="radio" name="vacation_type" value="{{ t }}"
{% if (req and req.vacation_type == t) or (not req and loop.first) %}checked{% endif %} /><span>{{ t }}</span></label>
{% endfor %}
</fieldset>
<label class="erp-field"><span>시작일 *</span>
<input class="erp-input" type="date" name="start_date" id="vac-start" required
value="{{ req.start_date if req else default_date }}" />
</label>
<div class="vac-form-main">
<div class="vac-range-cal" id="vac-cal"></div>
<label class="erp-field" id="vac-start-half-field"><span>시작 구분</span>
<select class="erp-select" name="start_half" id="vac-start-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.start_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<div class="vac-form-side">
<input type="hidden" name="start_date" id="vac-start" value="{{ req.start_date if req else '' }}" />
<input type="hidden" name="end_date" id="vac-end" value="{{ req.end_date if req else '' }}" />
<div class="vac-form-grid">
<label class="erp-field"><span>시작일</span>
<input class="erp-input" type="text" id="vac-start-show" readonly placeholder="달력에서 선택" />
</label>
<label class="erp-field" id="vac-end-field"><span>종료일</span>
<input class="erp-input" type="text" id="vac-end-show" readonly placeholder="달력에서 선택" />
</label>
<label class="erp-field" id="vac-start-half-field"><span>시작 구분</span>
<select class="erp-select" name="start_half" id="vac-start-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.start_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<label class="erp-field" id="vac-end-half-field"><span>종료 구분</span>
<select class="erp-select" name="end_half" id="vac-end-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.end_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
</div>
<label class="erp-field" id="vac-end-field"><span>종료일 *</span>
<input class="erp-input" type="date" name="end_date" id="vac-end"
value="{{ req.end_date if req else default_date }}" />
</label>
<div class="vac-days-preview">
예상 사용 일수: <strong id="vac-days-out">—</strong>
<span class="erp-muted">(주말 · 공휴일 제외)</span>
</div>
<label class="erp-field" id="vac-end-half-field"><span>종료 구분</span>
<select class="erp-select" name="end_half" id="vac-end-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.end_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<label class="erp-field vac-reason"><span>휴가 사유</span>
<textarea class="erp-input" name="reason" rows="5"
placeholder="휴가 사유를 입력하세요.">{{ req.reason if req else '' }}</textarea>
</label>
</div>
</div>
<label class="erp-field vac-full"><span>사유</span>
<textarea class="erp-input" name="reason" rows="3"
placeholder="휴가 사유를 입력하세요.">{{ req.reason if req else '' }}</textarea>
</label>
{#- 결재 라인 — 협의자(구성원 전체에서 복수, 사람마다 협의 내용) · 통보자·결재자(옵션 값, 고칠 수 없음) -#}
<section class="vac-line" aria-label="결재 라인">
<h3>결재 라인</h3>
<div class="vac-days-preview">
예상 사용 일수: <strong id="vac-days-out">—</strong>
<span class="erp-muted">(주말 · 공휴일 제외)</span>
</div>
<div class="vac-line-row">
<span class="vac-line-label">협의자</span>
<div class="vac-line-body">
<button type="button" class="erp-btn erp-btn-outline" id="vac-pick-btn" aria-expanded="false"
{% if not consult_ready %}disabled{% endif %}>구성원 선택</button>
<label class="vac-check"><input type="checkbox" name="no_consult" id="vac-no-consult" value="1"
{% if not consult_ready %}checked disabled{% endif %} /> 협의자 없음</label>
{% if not consult_ready %}<span class="erp-muted">협의자 기능은 DB 마이그레이션 003 적용 뒤에 쓸 수 있습니다.</span>{% endif %}
</div>
</div>
<ul class="vac-pick" id="vac-pick" hidden>
{% for m in members %}
<li>
<label class="vac-opt-person">
<input type="checkbox" data-email="{{ m.email }}" {% if m.email in consult_chosen %}checked{% endif %} />
{{ vm.person(m) }}
</label>
</li>
{% else %}
<li class="erp-muted">고를 수 있는 구성원이 없습니다.</li>
{% endfor %}
</ul>
<div class="vac-consult-box" id="vac-consult-box" hidden>
<p class="vac-line-sub">협의자 전달 사항 <span class="erp-muted">— 협의자마다 자기 내용만 메일로 받습니다.</span></p>
{% for m in members %}
{% set on = m.email in consult_chosen %}
<div class="vac-consult-row" data-email="{{ m.email }}" {% if not on %}hidden{% endif %}>
<input type="hidden" name="consult_email" value="{{ m.email }}" {% if not on %}disabled{% endif %} />
{{ vm.person(m) }}
<textarea class="erp-input" name="consult_message" rows="2" placeholder="{{ m.name }}님에게 전달할 내용"
aria-label="{{ m.name }} 협의 내용" {% if not on %}disabled{% endif %}>{{ consult_chosen.get(m.email, '') }}</textarea>
<button type="button" class="vac-consult-x" aria-label="{{ m.name }} 빼기">✕</button>
</div>
{% endfor %}
</div>
<div class="vac-line-row">
<span class="vac-line-label">통보자</span>
<div class="vac-line-body">
{% for p in line.notifiers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">없음(옵션에서 지정)</span>{% endfor %}
</div>
</div>
<div class="vac-line-row">
<span class="vac-line-label">결재자</span>
<div class="vac-line-body">
{% for p in line.approvers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">ERP 관리자(옵션에서 지정)</span>{% endfor %}
</div>
</div>
</section>
<p class="vac-form-err" id="vac-form-err" role="alert" hidden></p>
<div class="erp-page-actions vac-form-actions">
<button type="submit" class="erp-btn erp-btn-primary" name="action" value="submit">제출</button>
@@ -72,5 +134,5 @@
{% endblock %}
{% block scripts %}<script type="application/json" id="vac-holidays">{{ holidays | tojson }}</script>
<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
<script src="/static/erp-datepop.js?v=20261102a" defer></script>
<script src="/static/vacation.js?v=20261102a" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac">
@@ -9,6 +9,12 @@
<div class="vac-actions">
<div class="vac-actions-main">
<a class="erp-btn erp-btn-primary" href="/vacation/new">+ 휴가 신청</a>
<a class="erp-btn erp-btn-outline" href="/vacation/mine">내 신청 내역</a>
{% if consult_count %}
<a class="erp-btn erp-btn-outline" href="/vacation/pending#consults">협의 대기
<span class="erp-badge erp-badge-inverse vac-mini">{{ consult_count }}</span>
</a>
{% endif %}
{% if is_approver %}
<a class="erp-btn erp-btn-outline" href="/vacation/pending">승인 대기
{% if pending_count %}<span class="erp-badge erp-badge-inverse vac-mini">{{ pending_count }}</span>{% endif %}
@@ -85,7 +91,7 @@
</div>
<div class="vac-legend">
<span class="vac-leg"><i class="vac-dot vac-bar-submit"></i>제출</span>
<span class="vac-leg"><i class="vac-dot vac-bar-submit"></i>협의·제출</span>
<span class="vac-leg"><i class="vac-dot vac-bar-approve"></i>승인</span>
<span class="vac-leg"><i class="vac-dot vac-bar-reject"></i>반려</span>
<span class="vac-leg"><i class="vac-dot vac-bar-cancel"></i>취소</span>
@@ -108,7 +114,7 @@
<strong>{{ r.owner_name or r.owner }}</strong>
{% set badge = 'erp-badge-neutral' %}
{% if r.status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif r.status == '제출' %}{% set badge = 'erp-badge-inverse' %}
{% elif r.status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif r.status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }}">{{ r.status }}</span>
</div>
@@ -0,0 +1,37 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac vac-options">
<div class="vac-actions">
<div class="vac-actions-main">
<a class="erp-btn erp-btn-outline" href="/vacation/">◀ 달력</a>
<a class="erp-btn erp-btn-primary" href="/vacation/new">+ 휴가 신청</a>
</div>
</div>
<div class="erp-card">
{% if items %}
<div class="erp-table-wrap">
<table class="erp-table">
<thead><tr><th>휴가종류</th><th>기간</th><th>일수</th><th>상태</th><th>결재 진행</th></tr></thead>
<tbody>
{% for r in items %}
<tr>
<td><a href="/vacation/{{ r.id }}">{{ r.vacation_type }}</a></td>
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td>{{ vm.status_badge(r.status) }}</td>
<td>{{ vm.progress(r, people) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-muted">휴가 신청 내역이 없습니다.</p>
{% endif %}
</div>
</section>
{% endblock %}
@@ -1,10 +1,10 @@
{% extends "erp_base.html" %}
{#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나).
메일: 제출 = 승인자·통보자, 승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
메일: 제출 = 승인자·통보자(+ 협의자마다 자기 몫), 협의 완료·승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />
<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=20261102a" />{% endblock %}
{% block content %}
<section class="vac vac-options">
@@ -149,5 +149,5 @@
</section>
{% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261102a" defer></script>
<script src="/static/vacation.js?v=20261102a" defer></script>{% endblock %}
@@ -1,17 +1,60 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac">
<div class="erp-card">
<section class="vac vac-options">
{#- 협의 대기(2026-11-02) — 내가 협의자인 신청. 내 몫 협의 내용만 -#}
<div class="erp-card" id="consults">
<div class="vac-card-head"><h2>협의 대기 <span class="erp-muted vac-opt-count">{{ consult_items | length }}건</span></h2></div>
{% if consult_items %}
<div class="erp-table-wrap">
<table class="erp-table vac-pending-table">
<thead>
<tr><th>신청자</th><th>휴가종류</th><th>기간</th><th>일수</th><th>협의 내용</th><th class="vac-act-col">동작</th></tr>
</thead>
<tbody>
{% for r in consult_items %}
<tr>
<td><a href="/vacation/{{ r.id }}">{{ r.owner_name or r.owner }}</a></td>
<td>{{ r.vacation_type }}</td>
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td class="vac-reason-cell">{{ r.my_message or '-' }}</td>
<td class="vac-act-col">
<div class="vac-pending-acts">
<form method="post" action="/vacation/{{ r.id }}/consult" class="vac-inline-form">
<input type="hidden" name="decision" value="approve" />
<button type="submit" class="erp-btn erp-btn-primary erp-btn-sm">승인</button>
</form>
<form method="post" action="/vacation/{{ r.id }}/consult" class="vac-reject-form">
<input type="hidden" name="decision" value="reject" />
<input class="erp-input erp-input-sm" type="text" name="reject_reason" placeholder="반려 사유" required />
<button type="submit" class="erp-btn erp-btn-danger erp-btn-sm">반려</button>
</form>
</div>
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-muted">협의할 휴가 신청이 없습니다.</p>
{% endif %}
</div>
{% if is_approver %}
<div class="erp-card" id="approvals">
<div class="vac-card-head"><h2>승인 대기 <span class="erp-muted vac-opt-count">{{ items | length }}건</span></h2></div>
{% if items %}
<div class="erp-table-wrap">
<table class="erp-table vac-pending-table">
<thead>
<tr>
<th>신청자</th><th>휴가종류</th><th>기간</th><th>일수</th>
<th>사유</th><th class="vac-act-col">동작</th>
<th>사유</th><th>협의</th><th class="vac-act-col">동작</th>
</tr>
</thead>
<tbody>
@@ -22,6 +65,11 @@
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td class="vac-reason-cell erp-muted">{{ r.reason }}</td>
<td class="vac-reason-cell">
{% for c in r.consults %}
<div class="vac-consult-brief"><b>{{ (people.get(c.email) or c).name or c.email }}</b> {{ c.state }}{% if c.message %} — {{ c.message }}{% endif %}</div>
{% else %}<span class="erp-muted">없음</span>{% endfor %}
</td>
<td class="vac-act-col">
<div class="vac-pending-acts">
<form method="post" action="/vacation/{{ r.id }}/approve" class="vac-inline-form">
@@ -43,5 +91,6 @@
<p class="erp-muted">승인 대기 중인 휴가 신청이 없습니다.</p>
{% endif %}
</div>
{% endif %}
</section>
{% endblock %}
+10
View File
@@ -102,6 +102,16 @@
.pj-dp-day { isolation: isolate; }
.pj-dp-day::before { z-index: -1; }
/* 붙박이 기간 달력(mountRange) — 시작~종료 둥근 막대, 양 끝은 선택 원. 줄이 바뀌는 곳도 둥글게 */
.pj-dp-day.is-band::after {
content: ""; position: absolute; top: 2px; height: 30px; left: 0; right: 0; z-index: -2; background: #dbe6fb;
}
.pj-dp-day.is-band-start::after { left: 50%; }
.pj-dp-day.is-band-end::after { right: 50%; }
.pj-dp-day.is-row-first::after { left: 4px; border-radius: 15px 0 0 15px; }
.pj-dp-day.is-row-last::after { right: 4px; border-radius: 0 15px 15px 0; }
.pj-dp-day.is-band-start.is-row-last::after, .pj-dp-day.is-band-end.is-row-first::after { display: none; }
.pj-dp-foot {
display: flex; justify-content: space-between; align-items: center;
margin-top: 8px; padding-top: 8px; border-top: 1px solid #eef0f2;
+88 -28
View File
@@ -4,7 +4,7 @@
· 브라우저 기본 달력(input[type=date])은 숨기고 그 옆에 날짜 버튼을 둔다 — input 은 값 저장소(.value 읽기/쓰기·change 이벤트 그대로).
· 팝업: 위 칸(시작일·종료일 — 직접 입력 2026-10-27 / 10.27 / 10월 27일 / 1027, Enter), 월 달력(일·공휴일 빨강, 토 파랑,
공휴일 이름은 숫자 밑, 오늘 테두리, 기간 옅은 파랑), 오늘 · 지우기. 바깥 클릭·Esc 로 닫힘, 앵커 아래(자리 없으면 위).
window.ErpDatePop = { open(anchor, opts), close(), enhance(input, opts), enhanceRange(startInput, endInput, opts), fmt(iso), fmtFull(iso) } */
window.ErpDatePop = { open(anchor, opts), close(), enhance(input, opts), enhanceRange(startInput, endInput, opts), mountRange(box, opts), fmt(iso), fmtFull(iso) } */
(function () {
"use strict";
@@ -62,6 +62,34 @@
}
const HOLIDAY_SHORT = { "부처님오신날": "석가탄신일", "추석·개천절": "추석" };
// 요일 줄 + 6주 날짜 칸(팝업·붙박이 달력 공용). extra(iso) = 그 칸에 더할 클래스 목록
function gridHtml(viewY, viewM, holidays, today, extra) {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
cls.push.apply(cls, extra(iso, d));
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '<button type="button" class="' + cls.join(" ") + '" data-iso="' + iso + '"' +
(holName ? ' title="' + esc(holName) + '"' : "") + ">" +
'<span class="pj-dp-num">' + d.getDate() + "</span>" +
(holName ? '<span class="pj-dp-hol">' + esc(holShort) + "</span>" : "") + "</button>";
}
return '<div class="pj-dp-grid">' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '<span class="pj-dp-wd' + (i === 0 ? " is-sun" : i === 6 ? " is-sat" : "") + '">' + w + "</span>";
}).join("") + days + "</div>";
}
let popEl = null, cleanup = null;
function close() {
if (cleanup) cleanup();
@@ -100,27 +128,6 @@
'" data-kind="' + kind + '" placeholder="' + esc(labels[kind]) + '" value="' + esc(fmtField(val)) + '" autocomplete="off" />';
}
function render() {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
if (iso === due || (showStart && iso === start)) cls.push("is-selected");
if (showStart && start && due && iso > start && iso < due) cls.push("is-inrange");
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '<button type="button" class="' + cls.join(" ") + '" data-iso="' + iso + '"' +
(holName ? ' title="' + esc(holName) + '"' : "") + ">" +
'<span class="pj-dp-num">' + d.getDate() + "</span>" +
(holName ? '<span class="pj-dp-hol">' + esc(holShort) + "</span>" : "") + "</button>";
}
pop.innerHTML =
'<div class="pj-dp-fields">' +
(opts.allowStart ? (showStart ? field("start", start) : '<button type="button" class="pj-dp-addstart">+ ' + esc(labels.start) + "</button>") : "") +
@@ -133,11 +140,12 @@
'<button type="button" class="pj-dp-navbtn" data-nav="1" title="다음 달"><span class="material-symbols-outlined">chevron_right</span></button>' +
(opts.yearNav ? '<button type="button" class="pj-dp-navbtn" data-nav="12" title="1년 뒤"><span class="material-symbols-outlined">keyboard_double_arrow_right</span></button>' : "") +
"</div>" +
'<div class="pj-dp-grid">' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '<span class="pj-dp-wd' + (i === 0 ? " is-sun" : i === 6 ? " is-sat" : "") + '">' + w + "</span>";
}).join("") + days +
"</div>" +
gridHtml(viewY, viewM, holidays, today, function (iso) {
const c = [];
if (iso === due || (showStart && iso === start)) c.push("is-selected");
if (showStart && start && due && iso > start && iso < due) c.push("is-inrange");
return c;
}) +
'<div class="pj-dp-foot">' +
'<button type="button" class="pj-dp-link pj-dp-today">오늘</button>' +
(opts.clear === false ? "" : '<button type="button" class="pj-dp-link pj-dp-clear">지우기</button>') +
@@ -345,5 +353,57 @@
return { sync: sync, buttons: btns };
}
window.ErpDatePop = { open: open, close: close, enhance: enhance, enhanceRange: enhanceRange, fmt: fmt, fmtFull: fmtFull, parse: parseTyped };
// 화면에 붙박이는 기간 달력(2026-11-02, 휴가 신청) — 팝업과 같은 달력 서식(.pj-dp-*).
// 첫 클릭 = 시작일(동그라미), 다음 클릭 = 종료일(둥근 막대), 그다음 클릭 = 새로 시작. 시작일보다 앞을 누르면 그 날이 새 시작일.
// opts: { start, end, holidays, single() — true 면 클릭마다 하루, onChange(start, end) }. 반환 { set(start, end) }
function mountRange(box, opts) {
const holidays = opts.holidays || {};
const today = isoToday();
let start = opts.start || "", end = opts.end || opts.start || "", picking = false;
const base = new Date((start || today) + "T00:00:00");
let viewY = base.getFullYear(), viewM = base.getMonth();
function bandClasses(iso, d) {
if (!start || iso < start || iso > end) return [];
if (start === end) return ["is-selected"];
const c = ["is-band"];
if (iso === start) c.push("is-selected", "is-band-start");
else if (iso === end) c.push("is-selected", "is-band-end");
if (d.getDay() === 0) c.push("is-row-first");
if (d.getDay() === 6) c.push("is-row-last");
return c;
}
function render() {
box.innerHTML =
'<div class="pj-dp-nav">' +
'<button type="button" class="pj-dp-navbtn" data-nav="-1" title="이전 달"><span class="material-symbols-outlined">chevron_left</span></button>' +
'<span class="pj-dp-title">' + viewY + "년 " + (viewM + 1) + "월</span>" +
'<button type="button" class="pj-dp-navbtn" data-nav="1" title="다음 달"><span class="material-symbols-outlined">chevron_right</span></button>' +
"</div>" + gridHtml(viewY, viewM, holidays, today, bandClasses);
}
box.addEventListener("click", function (e) {
const nav = e.target.closest(".pj-dp-navbtn");
if (nav) {
const d = new Date(viewY, viewM + +nav.dataset.nav, 1);
viewY = d.getFullYear(); viewM = d.getMonth();
render();
return;
}
const day = e.target.closest(".pj-dp-day");
if (!day) return;
const iso = day.dataset.iso;
if (!picking || iso < start || (opts.single && opts.single())) {
start = end = iso;
picking = !(opts.single && opts.single());
} else {
end = iso;
picking = false;
}
render();
if (opts.onChange) opts.onChange(start, end);
});
render();
return { set: function (s, e) { start = s; end = e; picking = false; render(); } };
}
window.ErpDatePop = { open: open, close: close, enhance: enhance, enhanceRange: enhanceRange, mountRange: mountRange, fmt: fmt, fmtFull: fmtFull, parse: parseTyped };
})();
+57 -5
View File
@@ -160,16 +160,68 @@
.vac-list-reason { font-size: 12px; margin-top: 4px; }
.vac-empty { padding: 12px 0; }
/* ── 신청 폼 ── */
.vac-form-card { padding: 16px; max-width: 760px; }
/* ── 신청 폼(2026-11-02) — 위 휴가 종류 · 왼쪽 달력 · 오른쪽 날짜·사유 · 아래 결재 라인 ── */
.vac [hidden] { display: none !important; }
.vac-form-card { padding: 20px; max-width: 1000px; flex-shrink: 0; display: flex; flex-direction: column; gap: 20px; }
.vac-types { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 0; padding: 0; border: 0; }
.vac-types legend { float: left; margin-right: 12px; padding: 0; font-size: 14px; font-weight: 600; line-height: 34px; }
.vac-type { display: inline-flex; cursor: pointer; }
.vac-type input { position: absolute; opacity: 0; width: 0; height: 0; }
.vac-type span { display: inline-flex; align-items: center; gap: 6px; height: 34px; padding: 0 14px; box-sizing: border-box;
border: 1px solid var(--vac-ash); border-radius: 9999px; font-size: 14px; color: var(--vac-black); background: #fff; }
.vac-type span::before { content: ""; width: 12px; height: 12px; box-sizing: border-box; border: 1.5px solid #a3a3a3; border-radius: 50%; }
.vac-type:hover span { background: var(--vac-ghost); }
.vac-type input:checked + span { background: #000; border-color: #000; color: #fff; font-weight: 700; }
.vac-type input:checked + span::before { border: 4px solid #fff; background: #000; }
.vac-type input:focus-visible + span { outline: 2px solid var(--vac-black); outline-offset: 2px; }
.vac-form-main { display: grid; grid-template-columns: 340px minmax(0, 1fr); gap: 24px; align-items: start; }
@media (max-width: 760px) { .vac-form-main { grid-template-columns: minmax(0, 1fr); } }
.vac-range-cal { border: 1px solid var(--vac-ash); border-radius: 12px; padding: 12px; font-size: 13px; }
.vac-form-side { display: flex; flex-direction: column; min-width: 0; }
.vac-form-grid {
display: grid; grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 12px; margin-bottom: 12px;
}
.vac-full { grid-column: 1 / -1; }
.vac-days-preview { margin: 12px 0; font-size: 14px; }
.vac-form-side .erp-input, .vac-form-side .erp-select { min-width: 0; width: 100%; box-sizing: border-box; }
.vac-form-side input[readonly] { background: var(--vac-ghost); cursor: default; }
.vac-reason textarea { resize: vertical; }
.vac-days-preview { margin: 0 0 12px; font-size: 14px; }
.vac-days-preview strong { font-size: 16px; font-weight: 600; }
.vac-form-actions { display: flex; gap: 8px; margin-top: 8px; }
.vac-form-err { margin: 0; color: var(--vac-red); font-size: 13px; font-weight: 600; }
.vac-form-actions { display: flex; gap: 8px; }
/* 결재 라인 — 신청 화면·상세 공용 */
.vac-line { border-top: 1px solid var(--vac-ash); padding-top: 16px; display: flex; flex-direction: column; gap: 12px; }
.vac-line h3 { margin: 0; font-size: 15px; font-weight: 600; }
.vac-line-row { display: flex; align-items: center; gap: 12px; }
.vac-line-label { flex: none; width: 56px; font-size: 13px; font-weight: 600; }
.vac-line-body { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 16px; min-width: 0; font-size: 14px; }
.vac-line-sub { margin: 0; font-size: 13px; font-weight: 600; }
.vac-line-progress { margin: 0; }
.vac-person { display: inline-flex; align-items: center; gap: 6px; min-width: 0; }
.vac-pick { list-style: none; margin: 0; padding: 8px; display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 4px;
max-height: 260px; overflow-y: auto; border: 1px solid var(--vac-ash); border-radius: 10px; }
.vac-consult-box { display: flex; flex-direction: column; gap: 8px; }
.vac-consult-row { display: grid; grid-template-columns: 140px minmax(0, 1fr) 28px; gap: 8px; align-items: center; }
.vac-consult-row .erp-input { min-width: 0; width: 100%; box-sizing: border-box; resize: vertical; }
.vac-consult-x { width: 28px; height: 28px; border: 0; border-radius: 6px; background: none; color: var(--vac-muted); cursor: pointer; }
.vac-consult-x:hover { background: var(--vac-ghost); color: var(--vac-red); }
.vac-line-consult { padding: 8px 12px; border-radius: 10px; background: var(--vac-ghost); font-size: 14px; }
.vac-line-consult p { margin: 4px 0 0; white-space: pre-wrap; }
.vac-line-comment { color: var(--vac-red); }
.vac-consult-brief { font-size: 12.5px; white-space: pre-wrap; }
/* 협의·결재 진행 상황 */
.vac-steps { display: inline-flex; flex-wrap: wrap; align-items: center; gap: 4px 6px; }
.vac-step { display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px 2px 4px; border-radius: 9999px; background: var(--vac-ghost);
font-size: 12.5px; white-space: nowrap; }
.vac-step b { font-weight: 700; }
.vac-step.is-ok b { color: var(--vac-green); }
.vac-step.is-no b { color: var(--vac-red); }
.vac-step.is-wait b { color: #b45309; }
.vac-step .vac-opt-face { width: 18px; height: 18px; font-size: 10px; }
.vac-step-arrow { color: var(--vac-muted); }
/* ── 상세 ── */
.vac-detail-card { padding: 16px; max-width: 760px; }
+81 -23
View File
@@ -1,13 +1,12 @@
/* 휴가 신청 폼 — 종류에 따른 필드 토글 + 예상 일수 미리보기.
서버(store.compute_days)가 공휴일 포함 정확히 재계산한다. 여기선 주말만 제외한 근사치.
시작일·종료일 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop.js — 숨긴 input 옆 날짜 버튼, 둘 중 어느 쪽을 눌러도
같은 기간 팝업, 반차는 하루짜리 팝업). 공휴일 = 국경일·대체공휴일(#vac-holidays). 아래쪽은 옵션 잔여 연차 표. */
서버(store.compute_days)가 공휴일 포함 정확히 재계산한다. 여기선 주말·공휴일을 뺀 근사치.
시작일·종료일 = 왼쪽 붙박이 달력(2026-11-02, ErpDatePop.mountRange)에서 고르면 숨긴 칸·오른쪽 표시 칸이 따라옴, 반차는 하루.
공휴일 = 국경일·대체공휴일(#vac-holidays). 결재 라인 = 협의자 고르기·사람별 협의 내용. 아래쪽은 옵션 잔여 연차 표. */
(function () {
"use strict";
var form = document.getElementById("vac-form");
if (!form) return;
var type = document.getElementById("vac-type");
var start = document.getElementById("vac-start");
var startHalf = document.getElementById("vac-start-half");
var endField = document.getElementById("vac-end-field");
@@ -17,6 +16,11 @@
var startHalfField = document.getElementById("vac-start-half-field");
var out = document.getElementById("vac-days-out");
var startShow = document.getElementById("vac-start-show");
var endShow = document.getElementById("vac-end-show");
var err = document.getElementById("vac-form-err");
function typeValue() { var c = form.querySelector('input[name="vacation_type"]:checked'); return c ? c.value : ""; }
function isHalfType(t) { return t === "오전반차" || t === "오후반차"; }
// 휴가 설정의 공휴일(빨강) {날짜: 이름} — 날짜 팝업 표시 + 예상 일수에서 제외(서버 compute_days 와 같은 표)
@@ -26,12 +30,11 @@
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
if (window.ErpDatePop) {
window.ErpDatePop.enhanceRange(start, end, {
labels: { start: "시작일", due: "종료일" }, holidays: holidays, singleLabel: "날짜",
single: function () { return isHalfType(type.value); },
});
}
var cal = window.ErpDatePop.mountRange(document.getElementById("vac-cal"), {
start: start.value, end: end.value, holidays: holidays,
single: function () { return isHalfType(typeValue()); },
onChange: function (s, e) { start.value = s; end.value = e; err.hidden = true; recalc(); },
});
function parseDate(s) {
if (!s) return null;
@@ -56,12 +59,15 @@
}
function recalc() {
var t = type.value;
var half = isHalfType(t);
var half = isHalfType(typeValue());
var oneDay = !!start.value && start.value === end.value;
startShow.value = window.ErpDatePop.fmtFull(start.value);
endShow.value = window.ErpDatePop.fmtFull(end.value);
// 반차 종류면 종료일/구분 숨김, 단일 0.5
endField.style.display = half ? "none" : "";
endHalfField.style.display = half ? "none" : "";
endHalfField.style.display = half || oneDay ? "none" : "";
endHalf.disabled = half || oneDay; // 하루짜리는 시작 구분만 쓴다(서버 compute_days 와 같음)
startHalfField.style.display = half ? "none" : "";
if (half) {
@@ -86,19 +92,71 @@
out.textContent = total > 0 ? String(total) : "0";
}
// 시작일 변경 시 종료일이 비었거나 더 빠르면 맞춰줌
start.addEventListener("change", function () {
if (!end.value || parseDate(end.value) < parseDate(start.value)) {
end.value = start.value;
}
recalc();
});
[type, end, startHalf, endHalf].forEach(function (el) {
if (el) el.addEventListener("change", recalc);
// 반차로 바꾸면 기간을 시작일 하루로
form.querySelectorAll('input[name="vacation_type"]').forEach(function (r) {
r.addEventListener("change", function () {
if (isHalfType(typeValue()) && start.value && end.value !== start.value) {
end.value = start.value;
cal.set(start.value, start.value);
}
recalc();
});
});
[startHalf, endHalf].forEach(function (el) { el.addEventListener("change", recalc); });
recalc();
// ── 결재 라인 — 구성원 선택(복수) → 사람마다 협의 내용 칸, 협의자 없음이면 잠금 ──
var pickBtn = document.getElementById("vac-pick-btn");
var pick = document.getElementById("vac-pick");
var noConsult = document.getElementById("vac-no-consult");
var box = document.getElementById("vac-consult-box");
function rowOf(email) { return box.querySelector('.vac-consult-row[data-email="' + CSS.escape(email) + '"]'); }
function chosen() { return Array.from(pick.querySelectorAll("input[data-email]:checked")); }
function paintConsults() {
var off = noConsult.checked;
var on = {};
chosen().forEach(function (c) { on[c.dataset.email] = true; });
box.querySelectorAll(".vac-consult-row").forEach(function (row) {
var show = !off && !!on[row.dataset.email];
row.hidden = !show;
row.querySelectorAll("input, textarea").forEach(function (x) { x.disabled = !show; });
});
box.hidden = off || !chosen().length;
pickBtn.disabled = off;
if (off) { pick.hidden = true; pickBtn.setAttribute("aria-expanded", "false"); }
if (chosen().length || off) err.hidden = true;
}
pickBtn.addEventListener("click", function () {
pick.hidden = !pick.hidden;
pickBtn.setAttribute("aria-expanded", String(!pick.hidden));
});
document.addEventListener("click", function (e) {
if (!pick.hidden && !pick.contains(e.target) && e.target !== pickBtn) {
pick.hidden = true;
pickBtn.setAttribute("aria-expanded", "false");
}
});
pick.addEventListener("change", paintConsults);
noConsult.addEventListener("change", paintConsults);
box.addEventListener("click", function (e) {
var x = e.target.closest(".vac-consult-x");
if (!x) return;
var c = pick.querySelector('input[data-email="' + CSS.escape(x.closest(".vac-consult-row").dataset.email) + '"]');
if (c) c.checked = false;
paintConsults();
});
paintConsults();
// 숨긴 칸은 브라우저 필수 검사가 안 되므로 여기서 — 날짜는 저장에도, 협의자는 제출에만 필요
form.addEventListener("submit", function (e) {
var submitting = e.submitter && e.submitter.value === "submit";
var msg = !start.value ? "달력에서 휴가 날짜를 고르세요."
: submitting && !noConsult.checked && !chosen().length ? "협의자를 고르거나 '협의자 없음'을 체크하세요." : "";
err.textContent = msg;
err.hidden = !msg;
if (msg) e.preventDefault();
});
})();
/* 휴가 옵션 — 잔여 연차 표(2026-10-27, 입사일 기준): 이름 옆 입사일 = 날짜 버튼(erp-datepop). 고르면 근속·이번 연차 기간·생기는 연차
+2
View File
@@ -272,6 +272,8 @@ docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 <
```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
# 003(2026-11-02, 멱등) — vacation_consults(협의자 결재: 협의 내용·상태), vacation_mail_log.event 에 consult_request·consulted 추가. 미적용이면 협의자 칸 잠김.
docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_003_consults.sql
```
### 운영 서버 초기화 (1회, 사용자 승인 후)
+32
View File
@@ -0,0 +1,32 @@
-- ════════════════════════════════════════════════════════════
-- vacation_db 003 — 협의자 결재 (2026-11-02)
-- ════════════════════════════════════════════════════════════
-- · vacation_consults: 휴가 신청마다 협의자 한 줄 — 이메일·이름·그 사람에게 쓴 협의 내용·상태(대기|승인|반려)·반려 사유·처리 시각.
-- 신청을 지우면 함께 지워진다. 협의자가 있으면 신청 상태가 '협의중' → 모두 승인하면 '제출'(결재자 승인 대기).
-- · vacation_mail_log.event 에 협의 메일 두 종류 추가(consult_request = 협의자에게, consulted = 협의 끝남).
-- 적용(운영, superuser, 1회 — 여러 번 돌려도 안전, 기존 데이터는 그대로):
-- docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_003_consults.sql
-- 미적용이면 앱은 협의자 없이 예전처럼 동작한다(신청 화면 협의자 칸 잠김).
\set ON_ERROR_STOP on
CREATE TABLE IF NOT EXISTS vacation_consults (
id BIGSERIAL PRIMARY KEY,
request_id TEXT NOT NULL REFERENCES vacation_requests (id) ON DELETE CASCADE,
email TEXT NOT NULL,
name TEXT NOT NULL DEFAULT '',
message TEXT NOT NULL DEFAULT '',
state TEXT NOT NULL DEFAULT '대기' CHECK (state IN ('대기', '승인', '반려')),
comment TEXT NOT NULL DEFAULT '',
decided_at TIMESTAMPTZ,
UNIQUE (request_id, email)
);
CREATE INDEX IF NOT EXISTS idx_vacation_consults_email ON vacation_consults (email, state);
ALTER TABLE vacation_mail_log DROP CONSTRAINT IF EXISTS vacation_mail_log_event_check;
ALTER TABLE vacation_mail_log ADD CONSTRAINT vacation_mail_log_event_check
CHECK (event IN ('submitted', 'approved', 'rejected', 'consult_request', 'consulted'));
GRANT SELECT, INSERT, UPDATE, DELETE ON vacation_consults TO vacation_app;
GRANT USAGE, SELECT ON SEQUENCE vacation_consults_id_seq TO vacation_app;
SELECT 'vacation_db 003 ready' AS status;
+6 -1
View File
@@ -26,7 +26,12 @@ def main() -> None:
ctx = {"user": {"email": "kim@test.local", "name": "김철수", "picture": ""}, "is_admin": False, "is_approver": False,
"nav_items": [], "page_title": "휴가 신청", "page_subtitle": "", "mode": "new", "req": None,
"default_date": "2026-10-27", "vacation_types": list(VACATION_TYPES), "halves": list(HALVES),
"half_labels": HALF_LABELS, "holidays": {"2026-10-03": "개천절", "2026-10-09": "한글날", "2026-12-25": "성탄절"}}
"half_labels": HALF_LABELS, "holidays": {"2026-10-03": "개천절", "2026-10-09": "한글날", "2026-12-25": "성탄절"},
"consult_ready": True, "consult_chosen": {},
"members": [{"email": "lee@test.local", "name": "이팀장", "picture": ""}, {"email": "park@test.local", "name": "박과장", "picture": ""},
{"email": "choi@test.local", "name": "최대리", "picture": ""}],
"line": {"approvers": [{"email": "rj@test.local", "name": "RJ", "picture": ""}],
"notifiers": [{"email": "ellen@test.local", "name": "Ellen", "picture": ""}]}}
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)
+132 -75
View File
@@ -1,8 +1,8 @@
// 휴가 신청 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop.js) — 실제 브라우저(Chromium).
// 휴가 신청 화면(2026-11-02) — 라디오 휴가 종류·붙박이 기간 달력·결재 라인 — 실제 브라우저(Chromium).
// python tests/js/render_vacation.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/vacation_datepop.browser.test.js
// 브라우저 기본 달력 없음(숨긴 input = 값 저장소), 시작일·종료일 날짜 버튼 → 기간 팝업(누른 칸이 먼저), 날짜를 고르면 시작 → 종료로 넘어가고
// 종료를 고르면 닫힘, 공휴일 빨강·이름, 직접 입력(Enter), 반차 = 하루짜리, 제출하면 고른 날짜가 그대로 서버로.
// 달력 클릭 → 시작일·종료일 자동, 같은 날 = 동그라미, 기간 = 둥근 막대, 반차 = 하루, 공휴일 빨강·이름, 일수.
// 협의자: 구성원 선택(복수) → 사람마다 협의 내용 칸, 협의자 없음 = 잠금, 제출 검사, 고른 사람과 내용이 어긋나지 않게 전송.
const fs = require("fs"), path = require("path");
const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", "..");
@@ -33,89 +33,146 @@ function check(name, cond, extra) {
await p.waitForTimeout(200);
const state = function () {
return p.evaluate(function () {
const s = document.getElementById("vac-start"), e = document.getElementById("vac-end");
return { start: s.value, end: e.value, startShown: getComputedStyle(s).display !== "none", endShown: getComputedStyle(e).display !== "none",
btns: Array.from(document.querySelectorAll(".erp-date-btn")).map(function (b) { return b.textContent.replace("calendar_month", "").trim(); }),
want: [ErpDatePop.fmt(s.value), ErpDatePop.fmt(e.value)],
days: document.getElementById("vac-days-out").textContent, pop: !!document.querySelector(".pj-datepop") };
const v = function (id) { return document.getElementById(id).value; };
const shown = function (id) { return getComputedStyle(document.getElementById(id)).display !== "none"; };
return { start: v("vac-start"), end: v("vac-end"), startShow: v("vac-start-show"), endShow: v("vac-end-show"),
days: document.getElementById("vac-days-out").textContent, endField: shown("vac-end-field"), endHalf: shown("vac-end-half-field"),
startHalf: shown("vac-start-half-field"),
selected: Array.from(document.querySelectorAll("#vac-cal .pj-dp-day.is-selected")).map(function (b) { return b.dataset.iso; }),
band: Array.from(document.querySelectorAll("#vac-cal .pj-dp-day.is-band")).map(function (b) { return b.dataset.iso; }),
title: document.querySelector("#vac-cal .pj-dp-title").textContent };
});
};
// 달력은 오늘 달로 시작 — 테스트 날짜(2026-10)까지 옮긴다
const toMonth = async function (label) {
for (let i = 0; i < 60; i++) {
const t = (await state()).title;
if (t === label) return;
const [y, m] = t.match(/\d+/g).map(Number), [ty, tm] = label.match(/\d+/g).map(Number);
await p.click('#vac-cal .pj-dp-navbtn[data-nav="' + (y * 12 + m < ty * 12 + tm ? 1 : -1) + '"]');
}
};
const day = function (iso) { return p.click('#vac-cal .pj-dp-day[data-iso="' + iso + '"]'); };
// 휴가 종류 — 라디오, 고른 것만 검은 배경 + 흰 굵은 글씨
const look = function (value) {
return p.evaluate(function (val) {
const s = getComputedStyle(document.querySelector('input[name="vacation_type"][value="' + val + '"] + span'));
return [s.backgroundColor, s.color, s.fontWeight];
}, value);
};
const types = await p.evaluate(function () {
return Array.from(document.querySelectorAll('input[type="radio"][name="vacation_type"]')).map(function (r) { return r.value; });
});
check("휴가 종류 = 라디오(7가지), 드롭다운 없음", types.length === 7 && !(await p.$("select#vac-type")), types);
const on = await look("연차"), off = await look("병가");
check("고른 종류 = 검은 배경·흰 글씨·굵게, 나머지는 아님", on[0] === "rgb(0, 0, 0)" && on[1] === "rgb(255, 255, 255)" && +on[2] >= 700 && off[0] !== on[0], [on, off]);
const s0 = await state();
// 버튼 글자 = 프로젝트 날짜 버튼과 같은 규칙(오늘·내일·어제, 아니면 mm/dd(요일)) — 오늘 날짜에 따라 달라서 같은 함수로 비교
const fmtCheck = await p.evaluate(function () {
return [ErpDatePop.fmt("2026-10-29"), ErpDatePop.fmt("2027-01-04")];
check("처음엔 날짜 없음·브라우저 달력 없음", s0.start === "" && s0.end === "" && s0.selected.length === 0 && !(await p.$('input[type="date"]')), s0);
await p.waitForSelector('#vac-cal .pj-dp-grid');
await toMonth("2026년 10월");
const cal = await p.evaluate(function () {
const hol = document.querySelector('#vac-cal .pj-dp-day[data-iso="2026-10-09"]');
const box = document.getElementById("vac-cal").getBoundingClientRect(), side = document.querySelector(".vac-form-side").getBoundingClientRect();
return { hol: hol.classList.contains("is-sun") && hol.textContent, sat: document.querySelector('#vac-cal .pj-dp-day[data-iso="2026-10-24"]').classList.contains("is-sat"), left: box.right <= side.left };
});
check("기본 달력 input 숨김 · 날짜 버튼 두 개(시작·종료)", !s0.startShown && !s0.endShown && s0.btns.length === 2 &&
JSON.stringify(s0.btns) === JSON.stringify(s0.want) && s0.want[0] !== "", s0);
check("날짜 글자 mm/dd(요일), 다른 해는 연도", ["10/29(목)", "오늘", "내일", "어제"].indexOf(fmtCheck[0]) >= 0 &&
["2027/01/04(월)", "01/04(월)"].indexOf(fmtCheck[1]) >= 0, fmtCheck);
// 시작일 버튼 → 기간 팝업(시작일 칸 활성)
await p.click('.erp-date-btn[data-kind="start"]');
const pop = await p.evaluate(function () {
const el = document.querySelector(".pj-datepop");
const f = Array.from(el.querySelectorAll(".pj-dp-field")).map(function (x) { return [x.placeholder, x.value, x.classList.contains("is-active")]; });
const hol = el.querySelector('.pj-dp-day[data-iso="2026-10-09"]');
return { fields: f, title: el.querySelector(".pj-dp-title").textContent, hol: hol && hol.classList.contains("is-sun") && hol.textContent,
clear: !!el.querySelector(".pj-dp-clear"), parent: el.parentElement === document.body,
sat: document.querySelector('.pj-dp-day[data-iso="2026-10-24"]').classList.contains("is-sat") };
});
check("시작일 버튼 → 기간 팝업(시작일·종료일 칸, 시작일 활성, body 에, 지우기 없음)", pop.parent && !pop.clear &&
JSON.stringify(pop.fields) === '[["시작일","10월 27일",true],["종료일","10월 27일",false]]' && pop.title === "2026년 10월", pop);
check("공휴일 빨강 + 이름(한글날), 토요일 파랑", pop.hol === "9한글날" && pop.sat, pop);
// 시작일 10/29 → 종료일(10/27)이 더 빨라 10/29 로 맞춤, 종료일 칸으로 넘어감(팝업 그대로)
await p.click('.pj-dp-day[data-iso="2026-10-29"]');
check("공용 달력 서식 — 공휴일 빨강·이름, 토 파랑, 달력은 왼쪽", cal.hol === "9한글날" && cal.sat && cal.left, cal);
// 하루 = 동그라미, 시작·종료 칸 자동, 종료 구분은 숨김(하루는 시작 구분만)
await day("2026-10-20");
const s1 = await state();
const act = await p.evaluate(function () { const a = document.querySelector(".pj-dp-field.is-active"); return a && a.dataset.kind; });
check("시작일 고름 → 시작·종료 10/29, 팝업은 열린 채 종료일 칸으로", s1.start === "2026-10-29" && s1.end === "2026-10-29" && s1.pop && act === "due", [s1, act]);
await p.click('.pj-dp-day[data-iso="2026-11-02"]');
await p.waitForTimeout(50);
check("첫 클릭 → 시작=종료, 동그라미, 오른쪽 칸 자동", s1.start === "2026-10-20" && s1.end === "2026-10-20" && s1.startShow === "2026.10.20(화)" &&
s1.endShow === "2026.10.20(화)" && JSON.stringify(s1.selected) === '["2026-10-20"]' && s1.band.length === 0 && s1.days === "1" && !s1.endHalf, s1);
// 기간 = 둥근 막대(주가 바뀌어도), 양 끝 원
await day("2026-10-27");
const s2 = await state();
check("종료일 고름 → 11/02, 팝업 닫힘, 버튼 글자·예상 일수(주말 빼고 3)", s2.end === "2026-11-02" && !s2.pop &&
s2.btns[1] === s2.want[1] && s2.days === "3", s2);
// 종료일 버튼 → 종료일 칸이 먼저, 기간 칸 옅은 파랑
await p.click('.erp-date-btn[data-kind="due"]');
const pop2 = await p.evaluate(function () {
const a = document.querySelector(".pj-dp-field.is-active");
return { active: a && a.dataset.kind, inrange: document.querySelectorAll(".pj-dp-day.is-inrange").length,
selected: Array.from(document.querySelectorAll(".pj-dp-day.is-selected")).map(function (b) { return b.dataset.iso; }) };
check("둘째 클릭 → 종료일, 기간 전체 막대, 양 끝 선택, 일수 6", s2.end === "2026-10-27" && s2.endShow === "2026.10.27(화)" && s2.band.length === 8 &&
JSON.stringify(s2.selected) === '["2026-10-20","2026-10-27"]' && s2.days === "6" && s2.endHalf, s2);
const bar = await p.evaluate(function () {
const st = function (iso) {
const c = getComputedStyle(document.querySelector('#vac-cal .pj-dp-day[data-iso="' + iso + '"]'), "::after");
return { bg: c.backgroundColor, h: c.height, r: c.borderTopRightRadius, l: c.borderTopLeftRadius };
};
return { mid: st("2026-10-22"), sat: st("2026-10-24"), sun: st("2026-10-25") };
});
// 종료일 달(11월)이 보인다 — 11/1 이 일요일이라 10월 날짜는 이 달력에 없음: 기간 = 11/1, 선택 = 11/2
check("종료일 버튼 → 종료일 칸 활성·종료일 달, 기간 표시", pop2.active === "due" && pop2.inrange === 1 &&
JSON.stringify(pop2.selected) === '["2026-11-02"]', pop2);
// 예상 일수는 휴가 설정 공휴일도 뺀다 — 10/8~10/12 = 8·9(한글날)·10·11(주말)·12 → 2일
await p.click('.erp-date-btn[data-kind="start"]');
await p.fill('.pj-dp-field[data-kind="start"]', "10/8");
await p.press('.pj-dp-field[data-kind="start"]', "Enter");
await p.fill('.pj-dp-field[data-kind="due"]', "10/12");
await p.press('.pj-dp-field[data-kind="due"]', "Enter");
const sh = await state();
check("예상 일수 = 주말·공휴일(한글날) 빼고 2", sh.start === "2026-10-08" && sh.end === "2026-10-12" && sh.days === "2", sh);
await p.click('.erp-date-btn[data-kind="due"]');
// 직접 입력 — 종료일 칸에 11/3 Enter
await p.fill('.pj-dp-field[data-kind="due"]', "11/3");
await p.press('.pj-dp-field[data-kind="due"]', "Enter");
check("막대 색칠, 줄 끝·줄 처음은 둥글게", bar.mid.bg !== "rgba(0, 0, 0, 0)" && bar.mid.h === "30px" && parseInt(bar.sat.r) === 15 && parseInt(bar.sun.l) === 15, bar);
// 셋째 클릭 = 새로 시작, 시작일보다 앞을 누르면 새 시작일
await day("2026-10-08");
await day("2026-10-06");
const s3 = await state();
check("직접 입력 11/3 Enter → 종료일 11/03, 닫힘", s3.end === "2026-11-03" && !s3.pop, s3);
// Esc 로 닫기
await p.click('.erp-date-btn[data-kind="start"]');
await p.waitForTimeout(50);
await p.keyboard.press("Escape");
check("Esc → 닫힘", !(await state()).pop);
// 반차 — 종료일 칸 숨김, 날짜 버튼 하나로 하루짜리 팝업(시작=종료)
await p.selectOption("#vac-type", "오전반차");
await p.click('.erp-date-btn[data-kind="start"]');
const half = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".pj-dp-field")).map(function (x) { return x.placeholder; });
});
await p.click('.pj-dp-day[data-iso="2026-11-05"]');
check("다시 고르기 — 새 시작, 앞날 클릭은 시작일로", s3.start === "2026-10-06" && s3.end === "2026-10-06", s3);
await day("2026-10-12");
check("일수에서 주말·공휴일(한글날) 뺌", (await state()).days === "4", await state());
// 달을 넘어가도 기간 유지
await p.click('#vac-cal .pj-dp-navbtn[data-nav="1"]');
check("달을 옮겨도 값 유지", (await state()).start === "2026-10-06");
await p.click('#vac-cal .pj-dp-navbtn[data-nav="-1"]');
// 반차 — 하루로 줄고 칸 숨김, 클릭마다 하루
await p.click('label.vac-type:has(input[value="오전반차"])');
const s4 = await state();
check("반차 → 날짜 칸 하나 팝업, 고르면 시작=종료=11/05, 0.5일", JSON.stringify(half) === '["날짜"]' &&
s4.start === "2026-11-05" && s4.end === "2026-11-05" && !s4.pop && s4.days === "0.5", [half, s4]);
// 제출 — 고른 날짜가 그대로 폼으로
await p.selectOption("#vac-type", "연차");
check("반차 선택 → 시작일 하루로, 종료·구분 칸 숨김, 0.5일", s4.end === "2026-10-06" && !s4.endField && !s4.startHalf && s4.days === "0.5", s4);
await day("2026-10-14"); await day("2026-10-15");
const s5 = await state();
check("반차 — 클릭마다 하루", s5.start === "2026-10-15" && s5.end === "2026-10-15" && s5.band.length === 0, s5);
await p.click('label.vac-type:has(input[value="연차"])');
// 결재 라인 — 통보자·결재자는 아이콘 + 이름(고칠 칸 없음)
const line = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".vac-line-row")).map(function (r) { return r.textContent.replace(/\s+/g, " ").trim(); });
});
check("통보자·결재자 = 옵션 값 표시만", line[1] === "통보자 EEllen" && line[2] === "결재자 RRJ", line);
const vis = function (sel) { return p.evaluate(function (s) { const e = document.querySelector(s); return !!e && e.offsetParent !== null; }, sel); };
check("협의자 전달 사항 칸은 처음엔 없음", !(await vis("#vac-consult-box")));
// 제출 검사 — 협의자도 협의자 없음도 없으면 막힘
await p.click('button[name="action"][value="submit"]');
await p.waitForTimeout(80);
const err = await p.textContent("#vac-form-err");
check("협의자 미지정 제출 → 안내, 전송 안 됨", /협의자를 고르거나/.test(err) && posts.length === 0, [err, posts]);
// 구성원 선택 → 아이콘 + 이름 목록, 복수 선택, 사람마다 내용 칸
await p.click("#vac-pick-btn");
check("구성원 선택 → 목록(아이콘 + 이름)", await vis("#vac-pick") && (await p.$$("#vac-pick .vac-opt-face")).length === 3);
await p.check('#vac-pick input[data-email="park@test.local"]');
await p.check('#vac-pick input[data-email="choi@test.local"]');
const rows = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".vac-consult-row")).filter(function (r) { return !r.hidden; }).map(function (r) { return r.dataset.email; });
});
check("고른 사람마다 협의 내용 칸", await vis("#vac-consult-box") && JSON.stringify(rows.sort()) === '["choi@test.local","park@test.local"]', rows);
await p.click(".vac-line h3"); // 바깥 클릭 — 목록 닫힘
check("바깥을 누르면 목록 닫힘", !(await vis("#vac-pick")));
await p.fill('.vac-consult-row[data-email="choi@test.local"] textarea', "최대리에게 부탁");
// 협의자 없음 — 잠그면 칸이 사라지고 전송되지 않음, 풀면 내용 복구
await p.check("#vac-no-consult");
const locked = await p.evaluate(function () {
return { btn: document.getElementById("vac-pick-btn").disabled, sent: new FormData(document.getElementById("vac-form")).getAll("consult_email").length };
});
check("협의자 없음 → 선택 잠금·칸 숨김·전송 안 함", locked.btn && locked.sent === 0 && !(await vis("#vac-consult-box")), locked);
await p.uncheck("#vac-no-consult");
check("협의자 없음 해제 → 쓰던 내용 그대로", (await p.inputValue('.vac-consult-row[data-email="choi@test.local"] textarea')) === "최대리에게 부탁");
// ✕ 로 빼기
await p.click('.vac-consult-row[data-email="park@test.local"] .vac-consult-x');
check("✕ → 그 사람 빠짐, 선택 목록도 해제", !(await vis('.vac-consult-row[data-email="park@test.local"]')) &&
!(await p.isChecked('#vac-pick input[data-email="park@test.local"]', { strict: false })));
await p.click("#vac-pick-btn");
await p.check('#vac-pick input[data-email="lee@test.local"]');
await p.click(".vac-line h3");
// 제출 — 사람과 내용이 같은 순서로(빈 내용 포함)
await p.fill('textarea[name="reason"]', "가족 행사");
await p.click('button[name="action"][value="submit"]');
await p.waitForTimeout(200);
check("제출 → start_date·end_date 가 고른 날짜로 전송", posts.length === 1 && /start_date=2026-11-05/.test(posts[0]) && /end_date=2026-11-05/.test(posts[0]), posts);
const q = new URLSearchParams(posts[0] || "");
check("제출 → 날짜·종류·협의자·내용 전송(어긋나지 않음)", posts.length === 1 && q.get("start_date") === "2026-10-15" && q.get("end_date") === "2026-10-15" &&
q.get("vacation_type") === "연차" && JSON.stringify(q.getAll("consult_email")) === '["lee@test.local","choi@test.local"]' &&
JSON.stringify(q.getAll("consult_message")) === '["","최대리에게 부탁"]' && !q.get("no_consult"), posts);
} finally {
await browser.close();
}
+60
View File
@@ -3,6 +3,7 @@
VACATION_TEST_DB_URL 이 localhost/127.0.0.1 일 때만 돈다(아니면 skip). 앱 계정(vacation_app)으로 접속해 권한(GRANT)까지 본다.
psql … -v app_password=… -f scripts/sql/vacation_db_init.sql
psql … -d vacation_db -f scripts/sql/vacation_db_001_options_mail.sql
psql … -d vacation_db -f scripts/sql/vacation_db_003_consults.sql
VACATION_TEST_DB_URL=postgresql://vacation_app:<pw>@localhost:55432/vacation_db python -m pytest tests/test_vacation_db.py
"""
import os
@@ -43,6 +44,65 @@ class VacationOptionsDBTests(unittest.TestCase):
again = self.st.save_options(approvers=[], notifiers=[], by="admin@test.local") # 덮어쓰기(키 하나)
self.assertEqual((again["approvers"], again["notifiers"]), ([], []))
def _consult_req(self, owner, status="제출"):
return self.st.create_request(
owner=owner, owner_name="김철수", status=status,
payload={"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-06", "start_half": "full", "end_half": "full", "reason": "x"},
consults=[{"email": "park@test.local", "name": "박과장", "message": "박 내용"},
{"email": "choi@test.local", "name": "최대리", "message": "최 내용"}])
def test_consult_all_approve_moves_to_approver(self):
"""협의자(003) — 모두 승인해야 결재자에게, 그 전엔 승인 못 함, 내 협의 목록·권한."""
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
req = self._consult_req(owner)
rid = req["id"]
self.assertEqual(req["status"], "협의중")
self.assertEqual([(c["email"], c["message"], c["state"]) for c in self.st.list_consults(request_id=rid)],
[("park@test.local", "박 내용", "대기"), ("choi@test.local", "최 내용", "대기")])
with self.assertRaises(ValueError): # 협의 중에는 결재자가 승인 못 함
self.st.approve(request_id=rid, approver_email="lee@test.local")
self.assertNotIn(rid, [r["id"] for r in self.st.list_pending()])
self.assertIn(rid, [r["id"] for r in self.st.my_consults(email="PARK@test.local")])
with self.assertRaises(PermissionError):
self.st.decide_consult(request_id=rid, email="nobody@test.local", approve=True)
got, event = self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
self.assertEqual((got["status"], event), ("협의중", None)) # 한 명 남음
self.assertNotIn(rid, [r["id"] for r in self.st.my_consults(email="park@test.local")])
with self.assertRaises(ValueError): # 같은 사람이 두 번은 못 함
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=True)
self.assertEqual((got["status"], event), ("제출", "consulted"))
self.assertIn(rid, [r["id"] for r in self.st.list_pending()])
self.assertEqual(self.st.approve(request_id=rid, approver_email="lee@test.local")["status"], "승인")
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=True)
self.assertEqual(self.st.list_consults(request_id=rid), []) # 신청을 지우면 함께
def test_consult_reject_edit_and_resubmit(self):
"""협의자 한 명이 반려 → 신청 반려, 고쳐서 다시 제출하면 협의가 처음부터, 협의자 없이 내면 바로 제출."""
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
rid = self._consult_req(owner)["id"]
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
with self.assertRaisesRegex(ValueError, "사유"):
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False)
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="일정 겹침")
self.assertEqual((got["status"], got["reject_reason"], got["approver_email"], event), ("반려", "일정 겹침", "choi@test.local", "rejected"))
again = self.st.submit(request_id=rid, owner=owner)
self.assertEqual(again["status"], "협의중")
self.assertEqual({c["state"] for c in self.st.list_consults(request_id=rid)}, {"대기"})
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="x")
payload = {"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-05", "reason": "y"}
self.st.update_request(request_id=rid, owner=owner, payload=payload, consults=[])
self.assertEqual(self.st.list_consults(request_id=rid), [])
self.assertEqual(self.st.submit(request_id=rid, owner=owner)["status"], "제출")
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=False)
def test_consult_mail_log_events(self):
"""003 이 메일 기록 CHECK 를 넓혔는지 — 협의 메일도 기록된다."""
rid = uuid.uuid4().hex[:12]
for ev in ("consult_request", "consulted"):
self.st.add_mail_log(request_id=rid, event=ev, sender="a@test.local", via="smtp", recipients=["b@test.local"], subject="s", ok=True)
self.assertEqual([m["event"] for m in self.st.list_mail_log(request_id=rid)], ["consult_request", "consulted"])
def test_submit_approve_mail_log_end_to_end(self):
"""신청 → 제출 → 승인을 실제 DB 로, 메일은 가짜 SMTP — 기록이 상세 화면용 목록으로 나온다."""
from app.modules.vacation import notify
+111
View File
@@ -88,6 +88,45 @@ class ContentTests(unittest.TestCase):
self.assertIn("제출 — 승인 대기", one["text"])
class ConsultMailTests(unittest.TestCase):
"""협의자(2026-11-02) — 협의자마다 자기 몫만, 결재자·통보자는 전체."""
CONSULTS = [{"email": "park@test.local", "name": "박과장", "message": "박과장 전용 <업무>", "state": "대기"},
{"email": "choi@test.local", "name": "최대리", "message": "최대리 전용 내용", "state": "대기"}]
OWNER = {"email": "kim@test.local", "name": "김철수"}
def test_each_consultant_gets_only_own_message_and_others_get_all(self):
store = FakeStore(["lee@test.local"], ["hr@test.local"])
sent = []
with patch("app.mail.send_email", side_effect=lambda **kw: sent.append(kw) or True), patch("app.mail.mail_enabled", return_value=True):
res = notify.deliver(store, None, event="submitted", req=dict(REQ, status="협의중", consults=self.CONSULTS),
actor=self.OWNER, users=USERS, link="https://erp.test/vacation/r1")
self.assertEqual([m["to"] for m in sent], [["park@test.local"], ["choi@test.local"], ["lee@test.local", "hr@test.local"]])
park, choi, line = sent
self.assertIn("[휴가 협의 요청]", park["subject"])
self.assertIn("박과장 전용 &lt;업무&gt;", park["html"])
self.assertNotIn("최대리", park["html"] + park["body"])
self.assertIn("최대리 전용 내용", choi["body"])
self.assertNotIn("박과장", choi["html"] + choi["body"])
for text in ("박과장", "박과장 전용 <업무>", "최대리", "최대리 전용 내용", "협의 진행 중"):
self.assertIn(text, line["body"])
self.assertIn("협의자가 모두 승인하면", line["html"])
self.assertEqual([log["event"] for log in store.logs], ["consult_request", "consult_request", "submitted"])
self.assertTrue(res["ok"])
self.assertEqual(res["to"], ["lee@test.local", "hr@test.local"])
def test_consulted_goes_to_approver_notifier_owner_and_lists_consults(self):
done = [dict(c, state="승인") for c in self.CONSULTS]
store = FakeStore(["lee@test.local"], ["hr@test.local"])
with patch("app.mail.send_email", return_value=True) as smtp, patch("app.mail.mail_enabled", return_value=True):
notify.deliver(store, None, event="consulted", req=dict(REQ, consults=done), actor={"email": "choi@test.local"},
users=USERS, link="x")
kw = smtp.call_args.kwargs
self.assertEqual(smtp.call_count, 1)
self.assertEqual(kw["to"], ["lee@test.local", "hr@test.local", "kim@test.local"])
self.assertIn("[휴가 협의 완료]", kw["subject"])
self.assertIn("협의자 박과장: 승인", kw["body"])
class DeliverTests(unittest.TestCase):
ACTOR = {"email": "lee@test.local", "name": "이팀장"}
@@ -197,6 +236,14 @@ class Store:
self.req.update(status="반려", reject_reason=reason); return dict(self.req)
def list_mail_log(self, request_id):
return []
def consults_ready(self):
return True
def list_consults(self, request_id):
return []
def consults_for(self, request_ids):
return {}
def my_consults(self, email):
return []
def list_balances(self, year):
return []
def used_days(self, user_email, year):
@@ -360,6 +407,70 @@ run(body)
self.assertIn("OK", res.stdout)
def test_consult_access_and_form(self):
"""협의자(2026-11-02) — 폼 값 저장 규칙, 휴가 권한 없는 협의자도 자기 신청은 보고 처리, 다른 협의자 내용은 안 보임."""
res = _run('''
outsider = U("out@test.local"); outsider["modules"] = {}
other = U("other@test.local"); other["modules"] = {}
users.extend([outsider, other])
CONSULTS = [{"email": "out@test.local", "name": "out", "message": "바깥 사람 전용", "state": "대기", "comment": "", "decided_at": None},
{"email": "lee@test.local", "name": "lee", "message": "이팀장 전용", "state": "대기", "comment": "", "decided_at": None}]
class Store3(Store):
created = None
decided = []
def list_consults(self, request_id):
return [dict(c) for c in CONSULTS]
def get_request(self, request_id):
return dict(self.req)
def create_request(self, owner, owner_name, payload, status, consults=None):
Store3.created = {"status": status, "consults": consults, "owner": owner}
return dict(self.req, id="new1")
def decide_consult(self, request_id, email, approve, reason=""):
Store3.decided.append((email, approve, reason))
return dict(self.req, status="제출"), ("consulted" if approve else "rejected")
def list_overlapping(self, date_from, date_to):
return []
def list_pending(self):
return []
st3 = Store3()
st3.req["status"] = "협의중"
FORM = {"vacation_type": "연차", "start_date": "2026-11-03", "end_date": "2026-11-03", "action": "submit"}
def body(c):
main.app.state.vacation_store = st3
who["u"] = kim
# 신청 화면 — 구성원 전체(휴가 권한 없는 사람 포함, 나 빼고)
t = c.get("/vacation/new").text
assert 'data-email="out@test.local"' in t and 'data-email="lee@test.local"' in t and 'data-email="kim@test.local"' not in t
# 제출 — 협의자도 "협의자 없음"도 없으면 400, 작성중 저장은 통과
assert c.post("/vacation/new", data=FORM).status_code == 400
assert c.post("/vacation/new", data=dict(FORM, action="draft")).status_code == 303 and Store3.created["consults"] == []
assert c.post("/vacation/new", data=dict(FORM, no_consult="1")).status_code == 303 and Store3.created["consults"] == []
# 빈 협의 내용이 있어도 사람과 내용 칸이 어긋나지 않음, 본인은 빠짐
r = c.post("/vacation/new", data=dict(FORM, consult_email=["kim@test.local", "lee@test.local", "out@test.local"], consult_message=["나", "", "부탁드립니다"]))
assert r.status_code == 303, r.text
assert Store3.created["consults"] == [{"email": "lee@test.local", "name": "lee", "message": ""},
{"email": "out@test.local", "name": "out", "message": "부탁드립니다"}], Store3.created
assert c.post("/vacation/new", data=dict(FORM, consult_email=["nobody@test.local"], consult_message=[""])).status_code == 400
# 휴가 권한 없는 협의자 — 메일 링크로 자기 신청을 열어 처리, 자기 내용만
who["u"] = outsider
t = c.get("/vacation/r1").text
assert "바깥 사람 전용" in t and "이팀장 전용" not in t and "협의 승인" in t
assert c.get("/vacation/").status_code == 403
assert c.post("/vacation/r1/consult", data={"decision": "approve"}).status_code == 303
assert Store3.decided[-1] == ("out@test.local", True, "") and sent[-1][0] == "consulted", sent
# 협의자가 아니고 권한도 없으면 못 봄
who["u"] = other
assert c.get("/vacation/r1").status_code == 403
# 신청자·결재자는 전체, 내 신청 내역은 라우팅이 신청 id 보다 먼저
who["u"] = kim
t = c.get("/vacation/r1").text
assert "바깥 사람 전용" in t and "이팀장 전용" in t and "협의 승인" not in t
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_balances_in_options_settings_and_calendar_holidays(self):
"""2026-10-27 — 잔여 연차는 옵션(관리자, 참여자 전원 아이콘·이름 미리), 설정엔 없음, 달력 공휴일 이름."""
res = _run('''