Files
king 7f94e5efe7 feat(프로젝트): 매일 하는 업무 — 날짜 팝업 [매일]·반복 아이콘·시각별 알림
- 마이그레이션 033 tasks.repeat_daily — [매일]이면 마감일·시각 비움, 마감일을 고르면 꺼짐(미적용이면 버튼 숨김·PUT 503)
- 마감 칸(카드·목록·내 업무·세부 업무·업무 창)에 반복 아이콘 + "매일"
- reminders.run_daily_alerts: 영업일, Project 옵션 daily_alert_times 중 지난 가장 늦은 시각마다 담당자(없으면 협업자)에게 type=daily 알림(task_reminders 로 중복 방지, 데몬 1분 주기)
- 큰 알림 팝업·PC 알림 프로그램에서 매일 업무 줄은 노란 배경
- Project 옵션 "알림" 분류: 알림 시각 여러 개 추가·삭제(최대 12)
- 도움말·모듈 CLAUDE.md·DEPLOYMENT(033) 갱신, 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 14:35:59 +09:00

1237 lines
55 KiB
Python

"""프로젝트 관리 모듈 — 상수 / 기본값 / 순수 검증 로직.
DB I/O 는 db.py(ProjectStore)가 담당하고, 여기서는 상수와 입력 검증 등
DB 없이 단위 테스트 가능한 순수 함수만 둔다(malaysia.store 패턴).
"""
from __future__ import annotations
import json
import re
from datetime import date, timedelta
from html import escape
from html.parser import HTMLParser
from typing import Any
# 참고용 기본 세션(칸반 컬럼) 이름 목록 — 프로젝트 생성 시 자동으로 만들지는
# 않는다(세션은 아사나처럼 사용자가 직접 추가한다). 보드 컬럼 정렬 시 이
# 이름들을 우선순위로만 쓴다(router.py `_order`).
# (name, is_done_stage) — 마지막 '완료' 단계로 옮기면 업무 완료 처리.
DEFAULT_STAGES: tuple[tuple[str, bool], ...] = (
("할 일", False),
("진행 중", False),
("검토", False),
("완료", True),
)
# 업무 우선순위
PRIORITIES: tuple[str, ...] = ("low", "normal", "high")
PRIORITY_LABELS: dict[str, str] = {"low": "낮음", "normal": "보통", "high": "높음"}
# 프로젝트 상태
PROJECT_STATUSES: tuple[str, ...] = ("active", "completed", "archived")
# 멤버 역할
MEMBER_ROLES: tuple[str, ...] = ("manager", "member")
# 활동(activity) 종류 — 메일 트리거/타임라인 표시용
ACTION_CREATED = "created"
ACTION_ASSIGNED = "assigned"
ACTION_COMPLETED = "completed"
ACTION_STAGE_CHANGED = "stage_changed"
ACTION_REOPENED = "reopened"
ACTION_SUBTASK_MOVED = "subtask_moved" # 세부 업무를 다른 상위 업무로 옮김(보드 드래그)
ACTION_PROJECT_MOVED = "project_moved" # 업무를 다른 프로젝트로 옮김(왼쪽 프로젝트 목록으로 드래그)
# 프로젝트 색상 팔레트 — 32색(8칸 × 4줄). 앞 16색은 아사나 프로젝트 색(아사나 색상표
# 순서 그대로), 뒤 16색은 같은 칸(열)에 대응하는 진한 색 — 3줄째 = 1줄째의 진한 색,
# 4줄째 = 2줄째의 진한 색.
# 새 프로젝트 기본색은 DEFAULT_PROJECT_COLOR(파랑). 예전 팔레트 색으로 만든 프로젝트는
# 그 색 그대로 둔다(검증은 hex 형식만 본다).
COLOR_PALETTE: tuple[str, ...] = (
"#c7c4c4", # none(연회색)
"#f06a6a", # red
"#ec8d71", # orange
"#f1bd6c", # yellow-orange
"#f8df72", # yellow
"#aecf55", # yellow-green
"#5da283", # green
"#4ecbc4", # blue-green
"#9ee7e3", # aqua
"#4573d2", # blue
"#8d84e8", # indigo
"#b36bd4", # purple
"#f9aaef", # magenta
"#f26fb2", # hot-pink
"#fc979a", # pink
"#6d6e6f", # cool-gray
# ── 진한 색 16가지 ──
"#9a9696", # warm-gray
"#c93c3c", # deep-red
"#cf6340", # burnt-orange
"#d9962e", # amber
"#cfae1f", # mustard
"#7ea32a", # olive
"#2f7d5b", # forest
"#1c9a92", # teal
"#2a9dc4", # cerulean
"#2c4fa3", # navy
"#5b50c4", # deep-indigo
"#7e3fa8", # deep-purple
"#c55cc0", # orchid
"#c73c86", # raspberry
"#a0714f", # brown
"#37383a", # charcoal
)
DEFAULT_PROJECT_COLOR = "#4573d2"
# 프로젝트 아이콘 — 아사나 프로젝트 아이콘 목록과 같은 종류를 Material Symbols
# (앱이 self-host 하는 아이콘 글꼴)의 이름으로. 빈 값/목록 밖 = 아이콘 없음(첫 글자).
PROJECT_ICONS: tuple[str, ...] = (
"format_list_bulleted", # 목록
"view_kanban", # 보드
"view_timeline", # 타임라인
"calendar_month", # 캘린더
"rocket_launch", # 로켓
"groups", # 사람들
"trending_up", # 그래프
"stars", # 별
"bug_report", # 버그
"lightbulb", # 전구
"language", # 지구
"settings", # 톱니
"menu_book", # 노트
"desktop_windows", # 모니터
"check_circle", # 체크
"adjust", # 과녁
"code", # 코드
"campaign", # 확성기
"forum", # 말풍선
"work", # 서류가방
"dashboard", # 페이지 레이아웃
"flag", # 깃발
"extension", # 퍼즐
"slideshow", # 발표
"confirmation_number", # 티켓
"shopping_basket", # 장바구니
"cloud", # 구름
"payments", # 돈
"favorite", # 하트
"redeem", # 선물
"trophy", # 트로피
"photo_camera", # 카메라
"palette", # 디자인
"school", # 교육
"local_shipping", # 배송
"inventory_2", # 재고
"storefront", # 상점
"science", # 실험
"videocam", # 영상
"description", # 문서
"handshake", # 협업
"build", # 도구
)
# 아사나 아이콘(2026-10-08) — 아사나 프로젝트 아이콘과 같은 채워진 모양. 저장 값은 "asana:" + 이름,
# 글꼴은 이 33개만 담은 채워진 Material Symbols(static/vendor/material-symbols/material-symbols-asana.woff2).
# 이름을 늘리면 그 글꼴도 다시 받아야 한다(docs/PROJECT_MODULE.md 6-12).
ASANA_ICON_PREFIX = "asana:"
PROJECT_ASANA_ICONS: tuple[str, ...] = (
"format_list_bulleted", "view_kanban", "view_timeline", "calendar_month",
"rocket_launch", "group", "monitoring", "stars",
"bug_report", "lightbulb", "language", "settings",
"book_2", "desktop_windows", "check_circle", "adjust",
"code_blocks", "campaign", "forum", "work",
"article", "landscape", "extension", "id_card",
"conversion_path", "speed", "workspace_premium", "steps",
"shopping_basket", "map", "confirmation_number", "toll",
"web",
)
# 섹션(칸반 컬럼) 색상표 — 모든 편집창이 프로젝트 색상표(32색) 하나를 쓴다.
# 섹션에서는 첫 칸(연회색 #c7c4c4, 아사나의 "색 없음")을 고르면 색 없음(NULL, 기본 회색 머리).
STAGE_COLOR_PALETTE: tuple[str, ...] = COLOR_PALETTE
STAGE_NO_COLOR = COLOR_PALETTE[0]
# 예전 섹션 색상표(10색) — 이 색으로 칠해 둔 섹션은 그대로 유지(저장해도 지워지지 않게).
LEGACY_STAGE_COLORS: tuple[str, ...] = (
"#4573d2", # blue
"#37a3a3", # teal
"#62a420", # green
"#e8a33d", # amber
"#e8384f", # red
"#aa62e3", # purple
"#f06a6a", # coral
"#5a6772", # slate
"#e8398a", # pink
"#a15c43", # brown
)
# ════════════════════════════════════════════════════════════
# 대한민국 국경일·공휴일(2026~2030) — 프로젝트 달력 표시 전용.
#
# vacation 모듈도 공휴일을 관리하지만(vacation_holidays 테이블) 그건
# 휴가 일수 계산용으로 vacation_db 에 강하게 결합돼 있고, 여기는 달력에
# 빨간 글씨로 "보여만" 주면 되는 용도라 별도 DB 연결 없이 정적 표로 둔다.
# 근로자의 날(5/1)은 관공서 공휴일이 아니라서 제외했다. 제헌절(7/17)은
# 2026년부터 다시 공휴일이라 넣었다(쿠팡 모듈 holidays.py 와 같은 기준).
# 대체공휴일은 "관공서의 공휴일에 관한 규정" 대체공휴일 규정을 그대로 반영함
# (설날·추석·어린이날·삼일절/광복절/개천절/한글날·부처님오신날·성탄절 대상,
# 신정·현충일·제헌절은 대체 없음). 새 연도가 필요하면 이 표에 추가한다.
# ════════════════════════════════════════════════════════════
KR_HOLIDAYS: dict[str, str] = {
# 2026
"2026-01-01": "신정",
"2026-02-16": "설날 연휴", "2026-02-17": "설날", "2026-02-18": "설날 연휴",
"2026-03-01": "삼일절", "2026-03-02": "삼일절 대체",
"2026-05-05": "어린이날",
"2026-05-24": "부처님오신날", "2026-05-25": "부처님오신날 대체",
"2026-06-06": "현충일",
"2026-07-17": "제헌절",
"2026-08-15": "광복절", "2026-08-17": "광복절 대체",
# 추석 9/26 은 토요일만 겹침 → 대체공휴일 없음(설·추석은 일요일/공휴일 겹칠 때만).
"2026-09-24": "추석 연휴", "2026-09-25": "추석", "2026-09-26": "추석 연휴",
"2026-10-03": "개천절", "2026-10-05": "개천절 대체",
"2026-10-09": "한글날",
"2026-12-25": "성탄절",
# 2027
"2027-01-01": "신정",
"2027-02-06": "설날 연휴", "2027-02-07": "설날", "2027-02-08": "설날 연휴",
"2027-02-09": "설날 대체",
"2027-03-01": "삼일절",
"2027-05-05": "어린이날",
"2027-05-13": "부처님오신날",
"2027-06-06": "현충일",
"2027-07-17": "제헌절",
"2027-08-15": "광복절", "2027-08-16": "광복절 대체",
"2027-09-14": "추석 연휴", "2027-09-15": "추석", "2027-09-16": "추석 연휴",
"2027-10-03": "개천절", "2027-10-04": "개천절 대체",
"2027-10-09": "한글날", "2027-10-11": "한글날 대체",
"2027-12-25": "성탄절", "2027-12-27": "성탄절 대체",
# 2028
"2028-01-01": "신정",
"2028-01-26": "설날 연휴", "2028-01-27": "설날", "2028-01-28": "설날 연휴",
"2028-03-01": "삼일절",
"2028-05-02": "부처님오신날",
"2028-05-05": "어린이날",
"2028-06-06": "현충일",
"2028-07-17": "제헌절",
"2028-08-15": "광복절",
"2028-10-02": "추석 연휴", "2028-10-03": "추석·개천절", "2028-10-04": "추석 연휴",
"2028-10-05": "개천절 대체",
"2028-10-09": "한글날",
"2028-12-25": "성탄절",
# 2029
"2029-01-01": "신정",
"2029-02-12": "설날 연휴", "2029-02-13": "설날", "2029-02-14": "설날 연휴",
"2029-03-01": "삼일절",
"2029-05-05": "어린이날", "2029-05-07": "어린이날 대체",
"2029-05-20": "부처님오신날", "2029-05-21": "부처님오신날 대체",
"2029-06-06": "현충일",
"2029-07-17": "제헌절",
"2029-08-15": "광복절",
"2029-09-21": "추석 연휴", "2029-09-22": "추석", "2029-09-23": "추석 연휴",
"2029-09-24": "추석 대체",
"2029-10-03": "개천절",
"2029-10-09": "한글날",
"2029-12-25": "성탄절",
# 2030
"2030-01-01": "신정",
"2030-02-02": "설날 연휴", "2030-02-03": "설날", "2030-02-04": "설날 연휴",
"2030-02-05": "설날 대체",
"2030-03-01": "삼일절",
"2030-05-05": "어린이날", "2030-05-06": "어린이날 대체",
"2030-05-09": "부처님오신날",
"2030-06-06": "현충일",
"2030-07-17": "제헌절",
"2030-08-15": "광복절",
"2030-09-11": "추석 연휴", "2030-09-12": "추석", "2030-09-13": "추석 연휴",
"2030-10-03": "개천절",
"2030-10-09": "한글날",
"2030-12-25": "성탄절",
}
def holiday_name(iso_date: str) -> str:
"""해당 날짜(YYYY-MM-DD)가 공휴일이면 이름을, 아니면 빈 문자열을 반환."""
return KR_HOLIDAYS.get(iso_date, "")
def norm_str(s: Any, *, lower: bool = False) -> str:
out = str(s or "").strip()
return out.lower() if lower else out
def validate_priority(p: Any) -> str:
v = norm_str(p, lower=True)
return v if v in PRIORITIES else "normal"
def validate_role(r: Any) -> str:
v = norm_str(r, lower=True)
return v if v in MEMBER_ROLES else "member"
def validate_project_name(name: Any) -> str:
v = norm_str(name)
if not v:
raise ValueError("프로젝트 이름은 필수입니다.")
if len(v) > 200:
raise ValueError("프로젝트 이름이 너무 깁니다(200자 이내).")
return v
def validate_task_title(title: Any) -> str:
v = norm_str(title)
if not v:
raise ValueError("업무 제목은 필수입니다.")
if len(v) > 300:
raise ValueError("업무 제목이 너무 깁니다(300자 이내).")
return v
def validate_color(color: Any) -> str:
v = norm_str(color)
if not v:
return DEFAULT_PROJECT_COLOR
# 매우 단순한 hex 검증 — #RGB / #RRGGBB
if v.startswith("#") and len(v) in (4, 7):
try:
int(v[1:], 16)
return v.lower()
except ValueError:
pass
return DEFAULT_PROJECT_COLOR
def validate_project_icon(icon: Any) -> str | None:
"""프로젝트 아이콘 — PROJECT_ICONS 안의 이름 또는 "asana:" + PROJECT_ASANA_ICONS 이름만, 빈값/목록 밖은 None(첫 글자 표시)."""
v = norm_str(icon)
if v.startswith(ASANA_ICON_PREFIX):
return v if v[len(ASANA_ICON_PREFIX):] in PROJECT_ASANA_ICONS else None
return v if v in PROJECT_ICONS else None
def validate_stage_color(color: Any) -> str | None:
"""섹션 색상 — 색상표(또는 예전 10색) 안의 값만. 첫 칸(색 없음)·빈값·목록 밖은
저장 안 함(NULL, 기본 회색 머리)."""
v = norm_str(color).lower()
if v == STAGE_NO_COLOR:
return None
return v if (v in STAGE_COLOR_PALETTE or v in LEGACY_STAGE_COLORS) else None
def validate_date(d: Any) -> str | None:
"""'YYYY-MM-DD' 형식만 통과. 빈값은 None."""
from datetime import date as _date # noqa: WPS433
v = norm_str(d)
if not v:
return None
try:
_date.fromisoformat(v[:10])
except (ValueError, TypeError):
raise ValueError(f"날짜 형식이 올바르지 않습니다: {d}")
return v[:10]
DATE_RANGE_ERROR = "시작일이 마감일보다 늦을 수 없습니다."
TIME_RANGE_ERROR = "같은 날이면 시작 시각이 마감 시각보다 늦을 수 없습니다."
def validate_date_range(
start_date: Any, due_date: Any, start_time: Any = None, due_time: Any = None
) -> None:
"""최종 상태(부분 수정이면 기존 값 + 바꾼 값)의 날짜 범위 검사 — 프로젝트·작업 공용.
둘 다 있으면 start_date <= due_date. 같은 날이고 두 시각이 모두 있으면 start_time <= due_time.
한쪽이 비어 있는 입력은 허용. 값 형식 오류는 validate_date/validate_time 이 먼저 낸다.
"""
sd = validate_date(start_date)
dd = validate_date(due_date)
if sd and dd:
if sd > dd:
raise ValueError(DATE_RANGE_ERROR)
if sd == dd:
st = validate_time(start_time)
dt = validate_time(due_time)
if st and dt and st > dt:
raise ValueError(TIME_RANGE_ERROR)
def validate_time(t: Any) -> str | None:
"""'HH:MM' 형식만 통과(초는 버림). 빈값/None 은 None(=종일)."""
v = norm_str(t)
if not v:
return None
parts = v.split(":")
try:
hh = int(parts[0])
mm = int(parts[1]) if len(parts) > 1 else 0
except (ValueError, IndexError):
raise ValueError(f"시간 형식이 올바르지 않습니다: {t}")
if not (0 <= hh <= 23 and 0 <= mm <= 59):
raise ValueError(f"시간 범위가 올바르지 않습니다: {t}")
return f"{hh:02d}:{mm:02d}"
# ════════════════════════════════════════════════════════════
# Project 옵션 — 시스템 전체 설정(마이그레이션 029 project_options, 수퍼관리자·Admin 수정)
# 폰트 같은 "일반" 옵션은 브라우저별(localStorage)이라 여기 없다.
# ════════════════════════════════════════════════════════════
PROJECT_VIEWS: tuple[str, ...] = ("board", "list", "calendar", "timeline", "dashboard")
PROJECT_OPTION_DEFAULTS: dict[str, Any] = {
"default_view": "board", # 왼쪽에서 프로젝트를 열 때 처음 보이는 탭
"board_cover": True, # 보드 카드 표지(설명의 첫 이미지)
"all_view_users": None, # 왼쪽 "전체 보기" 메뉴를 볼 사람(이메일 목록) — None = 예전처럼 Pro user 이상
"daily_alert_times": ["09:00"], # 매일 업무(033 repeat_daily) 알림 시각들(KST, 영업일)
}
ALL_VIEW_USERS_MAX = 2000
DAILY_ALERT_TIMES_MAX = 12
def _time_list(raw: Any) -> list[str] | None:
"""'HH:MM' 목록 → 정규화·중복 제거·정렬. 목록이 아니거나 잘못된 시각이 끼면 None(빈 목록 = 알림 끔)."""
if not isinstance(raw, list) or len(raw) > DAILY_ALERT_TIMES_MAX:
return None
out: set[str] = set()
for t in raw:
if not isinstance(t, str):
return None
try:
v = validate_time(t)
except ValueError:
return None
if v is None:
return None
out.add(v)
return sorted(out)
def _email_list(raw: Any) -> list[str] | None:
"""이메일 목록 → 소문자·중복 제거·정렬. 목록이 아니거나 이상한 값이 끼면 None."""
if not isinstance(raw, list) or len(raw) > ALL_VIEW_USERS_MAX:
return None
out: set[str] = set()
for e in raw:
if not isinstance(e, str) or "@" not in e or len(e) > 254:
return None
out.add(e.strip().lower())
return sorted(out)
def normalize_project_options(raw: dict[str, Any] | None) -> dict[str, Any]:
"""DB 에서 읽은 값 → 화면용. 모르는 키는 버리고, 이상한 값·없는 키는 기본값(읽기는 실패하지 않는다)."""
out = dict(PROJECT_OPTION_DEFAULTS)
raw = raw or {}
if raw.get("default_view") in PROJECT_VIEWS:
out["default_view"] = raw["default_view"]
if isinstance(raw.get("board_cover"), bool):
out["board_cover"] = raw["board_cover"]
if raw.get("all_view_users") is not None:
out["all_view_users"] = _email_list(raw["all_view_users"])
times = _time_list(raw.get("daily_alert_times"))
if times is not None:
out["daily_alert_times"] = times
else:
out["daily_alert_times"] = list(PROJECT_OPTION_DEFAULTS["daily_alert_times"])
return out
def validate_project_options(payload: Any) -> dict[str, Any]:
"""저장 요청 검사 — 보낸 키만 돌려준다(일부만 바꿀 수 있게). 모르는 키·잘못된 값·빈 요청은 ValueError."""
if not isinstance(payload, dict) or not payload:
raise ValueError("바꿀 옵션이 없습니다.")
unknown = set(payload) - set(PROJECT_OPTION_DEFAULTS)
if unknown:
raise ValueError("알 수 없는 옵션입니다: " + ", ".join(sorted(unknown)))
out: dict[str, Any] = {}
if "default_view" in payload:
if payload["default_view"] not in PROJECT_VIEWS:
raise ValueError("처음 여는 탭 값이 올바르지 않습니다.")
out["default_view"] = payload["default_view"]
if "board_cover" in payload:
if not isinstance(payload["board_cover"], bool):
raise ValueError("카드 표지 값이 올바르지 않습니다.")
out["board_cover"] = payload["board_cover"]
if "all_view_users" in payload:
v = payload["all_view_users"]
out["all_view_users"] = None if v is None else _email_list(v)
if v is not None and out["all_view_users"] is None:
raise ValueError("전체 보기 대상자 값이 올바르지 않습니다.")
if "daily_alert_times" in payload:
times = _time_list(payload["daily_alert_times"])
if times is None:
raise ValueError(f"매일 업무 알림 시각이 올바르지 않습니다(HH:MM, 최대 {DAILY_ALERT_TIMES_MAX}개).")
out["daily_alert_times"] = times
return out
# ════════════════════════════════════════════════════════════
# 연간 목표 (마이그레이션 013) — 사이드바 "목표" → 연도
# ════════════════════════════════════════════════════════════
GOAL_METRICS: tuple[str, ...] = ("sales", "roas") # 매출 · 로아스(단위 %)
GOAL_KINDS: tuple[str, ...] = ("target", "actual") # 목표 · 실적
# 업무 영역 줄 배경색 — 스프레드시트처럼 연한 색 16가지(글자는 항상 진한 색, 8칸×2줄).
# 처음 8색(상품·마케팅·컨텐츠·유통 기본색 포함)은 예전 목록 그대로 들어 있다.
# 빈 문자열 = 색 없음(흰 배경, GOAL_NO_COLOR).
GOAL_AREA_COLORS: tuple[str, ...] = (
"#fcd9d9", "#fde4c8", "#fbe1d5", "#fff2c2", "#eef5c8", "#d9f2d0", "#c9ecd9", "#d3f0ee",
"#cfeaf7", "#dbe8fb", "#e3dcfb", "#f0cdec", "#fcdcec", "#eadcd0", "#d4d4d4", "#eef0f2",
)
GOAL_NO_COLOR = ""
# 새 연도를 만들 때 이전 연도가 없으면 이 영역으로 시작한다(이전 연도가 있으면 그 구조를 복사).
DEFAULT_GOAL_AREAS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
("상품", "#fbe1d5", ("",)),
("마케팅", "#d9f2d0", ("",)),
("컨텐츠", "#d4d4d4", ("",)),
("유통", "#f0cdec", ("콜라보", "인플", "쿠팡", "기타")),
)
GOAL_TEXT_MAX = 4000
def validate_goal_year(y: Any) -> int:
try:
v = int(str(y).strip())
except (TypeError, ValueError):
raise ValueError("연도가 올바르지 않습니다.")
if not 2000 <= v <= 2100:
raise ValueError("연도는 2000 ~ 2100 사이여야 합니다.")
return v
class GoalMigration014Needed(RuntimeError):
"""기간(분기) 글 칸·월 칸 병합은 마이그레이션 014(goal_cell_merges) 뒤에만 된다."""
class GoalMigration017Needed(RuntimeError):
"""2·4분기 글 칸(15·16)은 마이그레이션 017(분기) 뒤에만 된다."""
class GoalCellConflict(RuntimeError):
"""셀 이동 전에 다른 창에서 원본 또는 대상 내용이 바뀜."""
class MeetingCellMigrationNeeded(RuntimeError):
"""회의록 셀 병합 메타데이터(019)가 아직 없다."""
class MeetingLocked(RuntimeError):
"""회의 완료(022)된 회의록은 고칠 수 없다(관리자가 완료 해제하면 다시)."""
class MeetingMigration022Needed(RuntimeError):
"""회의 완료(잠금)는 마이그레이션 022 뒤에만 된다."""
class MeetingMigration027Needed(RuntimeError):
"""같은 항목 칸 안 줄 추가·항목 칸 나누기(goal_meeting_items.label_cont)는 마이그레이션 027 뒤에만 된다."""
class MeetingTaskMigrationNeeded(RuntimeError):
"""회의록 작업 등록 표(서버 저장)는 마이그레이션 025 뒤에만 된다."""
class MeetingParentTaskMigrationNeeded(RuntimeError):
"""작업 등록 표의 작업 칸(이미 있는 작업의 세부 작업으로)은 마이그레이션 026 뒤에만 된다."""
class MeetingMigration030Needed(Exception):
"""주차 목표 두 칸(유통·인플 / 카페24·네이버)은 project_db 마이그레이션 030 필요."""
class MeetingMigration020Needed(RuntimeError):
"""새 주차(월요일이 아닌 시작일)·결과 글 칸·주차별 목표는 마이그레이션 020 뒤에만 된다."""
GOAL_YEAR = 0 # 업무 영역 글 칸 — 연간
# 분기 글 칸(2026-10-01 상·하반기 → 1~4분기). 칸 번호는 예전 반기 칸을 그대로 이어 쓴다 — 데이터 옮기기 없이
# 예전 상반기 글(13)은 1분기, 하반기 글(14)은 3분기에 보인다. 2분기(15)·4분기(16)는 마이그레이션 017 뒤에 저장.
GOAL_QUARTER_COL: dict[int, int] = {1: 13, 2: 15, 3: 14, 4: 16}
GOAL_COL_QUARTER: dict[int, int] = {c: q for q, c in GOAL_QUARTER_COL.items()}
GOAL_Q_NEW: tuple[int, ...] = (15, 16) # 017 이 있어야 저장되는 분기 칸
GOAL_MAX_COL = 16
def goal_quarter_of(month: int) -> int:
"""1~3월 → 1분기, 4~6월 → 2분기, 7~9월 → 3분기, 10~12월 → 4분기."""
return (int(month) - 1) // 3 + 1
def validate_goal_month(m: Any, *, allow_year: bool = False) -> int:
"""1~12월. allow_year 이면 업무 영역 글 칸 — 0(연간)·13~16(분기 칸, GOAL_QUARTER_COL)도 허용."""
try:
v = int(m)
except (TypeError, ValueError):
raise ValueError("월이 올바르지 않습니다.")
if not ((0 if allow_year else 1) <= v <= (GOAL_MAX_COL if allow_year else 12)):
raise ValueError("월이 올바르지 않습니다.")
return v
def validate_goal_merge(start: Any, end: Any) -> tuple[int, int]:
"""월 칸 병합 범위(start~end 월, 2칸 이상) — 분기를 넘지 않는다."""
try:
s, e = int(start), int(end)
except (TypeError, ValueError):
raise ValueError("병합할 월이 올바르지 않습니다.")
if s > e:
s, e = e, s
if not (1 <= s and e <= 12) or s == e:
raise ValueError("병합은 1~12월 안에서 2칸 이상 골라야 합니다.")
if goal_quarter_of(s) != goal_quarter_of(e):
raise ValueError("분기(1~3·4~6·7~9·10~12월)를 넘어 병합할 수 없습니다.")
return s, e
def validate_goal_value(v: Any) -> float | None:
"""지표 숫자 — '1,234.5' 같은 쉼표·공백·% 는 떼고 읽는다. 빈값은 None(=지움)."""
s = norm_str(v).replace(",", "").replace("%", "").replace(" ", "")
if not s:
return None
try:
f = float(s)
except ValueError:
raise ValueError(f"숫자가 아닙니다: {v}")
if f != f or abs(f) >= 1e16: # NaN · NUMERIC(18,2) 범위 밖
raise ValueError(f"숫자 범위를 벗어났습니다: {v}")
return round(f, 2)
def validate_goal_area_name(name: Any) -> str:
v = norm_str(name)
if not v:
raise ValueError("업무 영역 이름을 입력하세요.")
if len(v) > 50:
raise ValueError("업무 영역 이름은 50자 이하로 입력하세요.")
return v
def validate_goal_row_label(label: Any) -> str:
v = norm_str(label)
if len(v) > 50:
raise ValueError("줄 이름은 50자 이하로 입력하세요.")
return v
def validate_goal_color(color: Any) -> str:
"""영역 색 — 16색 중 하나, 빈값/"none" 은 색 없음(""), 목록 밖은 첫 색."""
v = norm_str(color).lower()
if v in ("", "none"):
return GOAL_NO_COLOR
return v if v in GOAL_AREA_COLORS else GOAL_AREA_COLORS[0]
def validate_goal_text(body: Any) -> str:
v = str(body or "").replace("\r\n", "\n").strip()
if v.startswith(GOAL_RICH_PREFIX):
runs = goal_text_runs(v, strict=True)
if not "".join(r["text"] for r in runs).strip():
return ""
return GOAL_RICH_PREFIX + json.dumps(runs, ensure_ascii=False, separators=(",", ":"))
if len(v) > GOAL_TEXT_MAX:
raise ValueError(f"칸 하나에 {GOAL_TEXT_MAX}자까지 쓸 수 있습니다.")
return v
# 기존 TEXT 칸에 버전이 있는 텍스트 조각을 저장한다. 예전 평문은 그대로 유지한다.
GOAL_RICH_PREFIX = "pj-rich:v1:"
# 조각 하이퍼링크(2026-10-26, `link`) — http(s) 주소만, 공백·따옴표·꺾쇠 없는 2,000자까지(그 밖은 조용히 버림).
GOAL_LINK_RE = re.compile(r"https?://[^\s\"'<>]{1,2000}", re.IGNORECASE)
def goal_link(value: Any) -> str:
v = str(value or "").strip()
return v if len(v) <= 2000 and GOAL_LINK_RE.fullmatch(v) else ""
def goal_text_runs(body: Any, *, strict: bool = False) -> list[dict[str, Any]]:
value = str(body or "")
if not value.startswith(GOAL_RICH_PREFIX):
return [{"text": value}]
try:
raw = json.loads(value[len(GOAL_RICH_PREFIX):])
if not isinstance(raw, list) or len(raw) > GOAL_TEXT_MAX:
raise ValueError("서식 데이터가 올바르지 않습니다.")
runs = []
for item in raw:
if not isinstance(item, dict) or not isinstance(item.get("text"), str):
raise ValueError("서식 데이터가 올바르지 않습니다.")
run: dict[str, Any] = {"text": item["text"]}
for key in ("bold", "italic", "underline"):
if isinstance(item.get(key), bool):
run[key] = item[key]
if re.fullmatch(r"#[0-9a-fA-F]{6}", str(item.get("color", ""))):
run["color"] = item["color"].lower()
size = item.get("size")
if isinstance(size, int) and not isinstance(size, bool) and 10 <= size <= 32:
run["size"] = size
link = goal_link(item.get("link"))
if link:
run["link"] = link
if run["text"]:
runs.append(run)
if sum(len(r["text"]) for r in runs) > GOAL_TEXT_MAX:
raise ValueError(f"칸 하나에 {GOAL_TEXT_MAX}자까지 쓸 수 있습니다.")
return runs
except (ValueError, TypeError) as err:
if strict:
raise ValueError("칸의 서식 데이터가 올바르지 않습니다.") from err
return [{"text": value}]
def goal_text_plain(body: Any) -> str:
return "".join(r["text"] for r in goal_text_runs(body))
def goal_text_html(body: Any, *, include_size: bool = True) -> str:
"""허용한 글자 서식만 HTML로 만든다. 사용자 텍스트는 항상 escape한다.
월간 계획 요약에서는 include_size=False로 글자 크기만 화면 기본값을 사용한다."""
out = []
for run in goal_text_runs(body):
style = []
if "bold" in run:
style.append("font-weight:" + ("700" if run["bold"] else "400"))
if "italic" in run:
style.append("font-style:" + ("italic" if run["italic"] else "normal"))
if "underline" in run:
style.append("text-decoration:" + ("underline" if run["underline"] else "none"))
if "color" in run:
style.append("color:" + run["color"])
if include_size and "size" in run:
style.append(f'font-size:{run["size"]}px')
text = escape(run["text"])
piece = f'<span style="{";".join(style)}">{text}</span>' if style else text
if run.get("link"):
piece = (f'<a class="pj-goal-link" href="{escape(run["link"], quote=True)}" target="_blank" '
f'rel="noopener noreferrer">{piece}</a>')
out.append(piece)
return "".join(out)
def merge_goal_texts(bodies: list[str]) -> str:
values = [v for v in bodies if goal_text_plain(v).strip()]
if not any(v.startswith(GOAL_RICH_PREFIX) for v in values):
return validate_goal_text("\n".join(values))
runs = []
for value in values:
if runs:
runs.append({"text": "\n"})
runs.extend(goal_text_runs(value))
return validate_goal_text(GOAL_RICH_PREFIX + json.dumps(runs, ensure_ascii=False))
def validate_meeting_content(body: Any) -> str:
"""회의록 편집기와 같은 서식 조각 합치기로 이동 예상값을 비교한다."""
value = validate_goal_text(body)
if not value.startswith(GOAL_RICH_PREFIX):
return value
runs: list[dict[str, Any]] = []
keys = ("bold", "italic", "underline", "color", "size", "link")
for run in goal_text_runs(value):
if runs and all(runs[-1].get(k) == run.get(k) for k in keys):
runs[-1]["text"] += run["text"]
else:
runs.append(dict(run))
if not any(len(run) > 1 for run in runs):
return validate_goal_text("".join(run["text"] for run in runs))
return GOAL_RICH_PREFIX + json.dumps(runs, ensure_ascii=False, separators=(",", ":"))
# ── 엑셀식 사각형 병합(마이그레이션 015) ──────────────────────────────
class GoalMigration015Needed(RuntimeError):
"""세로 병합·주간 회의록은 마이그레이션 015 뒤에만 된다."""
class GoalMigration016Needed(RuntimeError):
"""항목 칸(2열) 묶음(같은 항목 칸 안에 줄 추가)은 마이그레이션 016 뒤에만 된다."""
# 업무 영역 글 칸의 화면 순서 — 연간 · 1~3월 · 1분기 · 4~6월 · 2분기 · 7~9월 · 3분기 · 10~12월 · 4분기
GOAL_COL_ORDER: tuple[int, ...] = (0, 1, 2, 3, 13, 4, 5, 6, 15, 7, 8, 9, 14, 10, 11, 12, 16)
def goal_col_group(m: int) -> str:
"""병합 가능 묶음 — 가로 병합은 같은 묶음 안에서만(연간·분기 칸은 혼자, 월은 같은 분기끼리)."""
if m == GOAL_YEAR:
return "year"
if m in GOAL_COL_QUARTER:
return f"q{GOAL_COL_QUARTER[m]}"
return f"months{goal_quarter_of(m)}"
def validate_goal_rect_cols(col_from: Any, col_to: Any) -> tuple[int, int]:
"""병합할 칸 범위(화면 순서의 양 끝 칸 번호) → (시작 칸 번호, 가로 칸 수).
가로로 여러 칸이면 같은 분기의 월 칸끼리만 — 연간·분기 칸은 세로로만 합칠 수 있다."""
try:
a, b = int(col_from), int(col_to)
except (TypeError, ValueError):
raise ValueError("병합할 칸이 올바르지 않습니다.")
if a not in GOAL_COL_ORDER or b not in GOAL_COL_ORDER:
raise ValueError("병합할 칸이 올바르지 않습니다.")
ia, ib = sorted((GOAL_COL_ORDER.index(a), GOAL_COL_ORDER.index(b)))
cols = GOAL_COL_ORDER[ia:ib + 1]
if len({goal_col_group(m) for m in cols}) > 1:
raise ValueError("연간·분기 칸은 세로로만, 월 칸은 같은 분기 안에서만 합칠 수 있습니다.")
return cols[0], len(cols)
# ── 주간 회의록(마이그레이션 015) — 월 머리를 누르면 그 달 주차별 회의록 ──────────
MEETING_STATUS: dict[str, str] = {"": "", "done": "완료", "partial": "일부", "miss": "미달"}
MEETING_TEXT_MAX = 4000
MEETING_LABEL_MAX = 50
MEETING_AMOUNT_TEXT_MAX = 100 # 정량 목표·결과 글(021, 예: "20개")
# 첫 회의록(이전 주 회의록이 없을 때)의 구역별 줄 — 사용자 회의록 양식(2026-10). 목표 표의 업무 영역 이름과 같으면
# 그 줄들로, 없는 구역은 빈 줄 하나. 다음 주부터는 지난주 회의록 줄을 그대로 이어받는다.
MEETING_TEMPLATE: dict[str, tuple[str, ...]] = {
"상품": ("상품1", "상품2", "상품3", "상품4", "상품5"),
"마케팅": ("메타", "구글", "네이버", "기타.신규"),
"컨텐츠": ("내용1", "내용2", "내용3", "내용4", "내용5"),
"유통": ("신규 인플루언서", "콜라보", "쿠팡", "네이버", "gs", "토스", "애터미", "해외", "오프라인", "기타"),
}
# 유통 줄 이름 → 실적 모듈 쇼핑몰 코드(그 주 결과를 실적에서 자동으로). 첫 단어 기준, 소문자 비교.
MEETING_MARKET_GUESS: tuple[tuple[str, str], ...] = (
("쿠팡", "coupang"), ("네이버", "naver"), ("스마트스토어", "naver"), ("gs", "gsshop"), ("토스", "toss"),
("11번가", "elevenst"), ("카페24", "cafe24"), ("자사몰", "cafe24"), ("롯데", "lotteon"), ("지마켓", "gmarket"),
("g마켓", "gmarket"), ("카카오", "kakao"), ("오늘의집", "ohouse"),
)
def guess_meeting_market(section: str, label: str) -> str:
"""유통 구역 줄 이름으로 실적 쇼핑몰 코드 추측(없으면 ""). 마케팅의 "네이버"(광고)는 연결하지 않는다."""
if norm_str(section) != "유통":
return ""
lb = norm_str(label).lower()
for word, code in MEETING_MARKET_GUESS:
if lb.startswith(word):
return code
return ""
def week_monday(d: date) -> date:
return d - timedelta(days=d.weekday())
def month_last_day(year: int, month: int) -> date:
return date(year + (month == 12), month % 12 + 1, 1) - timedelta(days=1)
def month_weeks(year: int, month: int) -> list[tuple[date, date]]:
"""그 달의 주차(시작일, 끝일) — 2026-10-07 사용자 기준. 주차는 늘 그 달 안(달을 넘지 않는다).
· 1일이 월~금이면 1주차 = 1일 ~ 그 주 일요일(월요일 시작이 아니어도 1주차)
· 1일이 토·일이면 1주차 = 1일 ~ 다음 주 일요일(토·일 + 다음 월~일)
· 그 뒤는 월~일. 말일이 월·화이면 그 하루·이틀은 앞 주차에 붙는다(마지막 주차 = 월~다음 주 월·화).
예: 2026년 10월(1일 목·31일 토) = 10/1~4 · 5~11 · 12~18 · 19~25 · 26~31.
월간 목표·누적은 늘 1일~말일."""
first = date(year, month, 1)
last = month_last_day(year, month)
wd = first.weekday()
end = first + timedelta(days=6 - wd + (7 if wd >= 5 else 0))
out = [(first, end)]
s = end + timedelta(days=1)
while s <= last:
out.append((s, min(s + timedelta(days=6), last)))
s += timedelta(days=7)
if len(out) > 1 and last.weekday() <= 1: # 말일이 월·화 — 앞 주차에 붙인다
out.pop()
out[-1] = (out[-1][0], last)
return out
def week_period(d: date) -> tuple[date, date]:
"""그 날짜가 든 주차(시작일, 끝일)."""
return next(p for p in month_weeks(d.year, d.month) if p[0] <= d <= p[1])
def prev_week_period(start: date) -> tuple[date, date]:
"""바로 앞 주차(앞 달 마지막 주차일 수 있다) — 회의록의 "지난주"."""
return week_period(start - timedelta(days=1))
def week_number(start: date) -> int:
"""주차 시작일 → 그 달 몇 주차(1부터). 주차 시작일이 아니면 그 날짜가 든 주차."""
return next(i + 1 for i, (a, b) in enumerate(month_weeks(start.year, start.month)) if a <= start <= b)
def calendar_weeks(year: int, month: int) -> list[tuple[date, date]]:
"""작은 달력용 — 그 달 날짜가 하나라도 든 줄(월요일 시작) 전부(1일이 든 줄부터 말일이 든 줄까지)."""
first, last = date(year, month, 1), month_last_day(year, month)
out, mon = [], week_monday(first)
while mon <= last:
out.append((mon, mon + timedelta(days=6)))
mon += timedelta(days=7)
return out
def validate_week_start(v: Any) -> date:
"""회의록 시작일(날짜) — 020 부터 월요일이 아닐 수 있다. 주차 시작일인지는 validate_period_start."""
try:
d = date.fromisoformat(str(v).strip()[:10])
except ValueError:
raise ValueError("주 시작일이 올바르지 않습니다.")
if not 2000 <= d.year <= 2100:
raise ValueError("주 시작일이 올바르지 않습니다.")
return d
def validate_period_start(v: Any) -> date:
"""주차 시작일만(month_weeks 의 시작일) — 새 회의록·주차별 목표."""
d = validate_week_start(v)
if week_period(d)[0] != d:
raise ValueError("주차 시작일이 아닙니다. 새로고침해 주세요.")
return d
def _korean_amount(s: str) -> float:
""""1억2천만"·"3천만"·"1.5억"·"120만"·"3천5백" → 숫자. 단위 없는 숫자는 그대로. 틀리면 ValueError."""
def small(t: str) -> float: # 만 아래 자리 — 천·백·십
val = 0.0
for unit, mul in (("천", 1_000), ("백", 100), ("십", 10)):
if unit in t:
a, t = t.split(unit, 1)
val += (float(a) if a else 1.0) * mul
return val + (float(t) if t else 0.0)
total, rest = 0.0, s
for unit, mul in (("억", 100_000_000), ("만", 10_000)):
if unit in rest:
a, rest = rest.split(unit, 1)
total += (small(a) if a else 1.0) * mul
return total + small(rest)
def validate_meeting_amount(v: Any) -> int | None:
"""금액(원) — 쉼표·공백·"원" 은 떼고, "120만"·"1.5억"·"3천만"·"1억2천만" 도 읽는다. 빈값은 None(=지움)."""
s = norm_str(v).replace(",", "").replace(" ", "").rstrip("원")
if not s:
return None
try:
f = _korean_amount(s)
except ValueError:
raise ValueError(f"금액은 숫자로 입력하세요(예: 1,200,000 · 120만 · 1.5억 · 3천만): {v}")
if f != f or abs(f) >= 1e15:
raise ValueError(f"금액 범위를 벗어났습니다: {v}")
return int(round(f))
def validate_meeting_text(v: Any, *, limit: int = MEETING_TEXT_MAX, what: str = "내용") -> str:
s = str(v or "").replace("\r\n", "\n").strip()
if len(s) > limit:
raise ValueError(f"{what}은(는) {limit}자까지 쓸 수 있습니다.")
return s
def validate_meeting_status(v: Any) -> str:
s = norm_str(v)
if s not in MEETING_STATUS:
raise ValueError("평가 값이 올바르지 않습니다.")
return s
def sales_unit_multiplier(unit: str) -> int | None:
"""목표 표의 매출 단위 글자 → 원 배수("백만원" → 1,000,000). 모르는 단위면 None(원 환산 안 함)."""
u = norm_str(unit).replace(" ", "").rstrip("원") or ""
table = {"": 1, "천": 1_000, "만": 10_000, "십만": 100_000, "백만": 1_000_000, "천만": 10_000_000, "억": 100_000_000}
return table.get(u)
def build_subject_assigned(*, project_name: str, task_title: str, assignee: str) -> str:
return f"[DBX 프로젝트] 업무 배정: {project_name} · {task_title} → {assignee}"
def build_subject_completed(*, project_name: str, task_title: str) -> str:
return f"[DBX 프로젝트] 업무 완료: {project_name} · {task_title}"
def build_subject_project_done(*, project_name: str) -> str:
return f"[DBX 프로젝트] 프로젝트 완료: {project_name}"
# ════════════════════════════════════════════════════════════
# 업무 설명 HTML 정리 (이미지 붙여넣기/업로드 삽입 지원)
#
# 업무 편집창의 설명란은 contenteditable 이라 브라우저가 임의의 HTML을
# 만들어 보낼 수 있다. 여기서 허용 태그만 남기고 스크립트/이벤트 속성/위험
# URL 스킴을 제거한다 — 외부 라이브러리(bleach 등) 없이 표준 라이브러리
# html.parser 만으로 구현한다(카페24 모듈 자체호스팅 원칙과 동일).
#
# 기존에 일반 텍스트로 저장돼 있던 설명은 마이그레이션(project_db_003)에서
# 한 번에 안전한 HTML로 변환해뒀다 — 여기서는 "이게 HTML이냐 텍스트냐"를
# 런타임에 추측하지 않는다(추측은 오탐이 난다). description 컬럼은 이제
# 항상 HTML이라고 가정한다.
# ════════════════════════════════════════════════════════════
_DESC_ALLOWED_TAGS: frozenset[str] = frozenset({
"p", "br", "b", "strong", "i", "em", "u", "a", "img",
"ul", "ol", "li", "blockquote", "code", "pre", "span", "div",
# 취소선(서식 도구 "S" — 브라우저에 따라 strike/s/del 로 만든다)
"s", "strike", "del",
# 체크박스(서식 도구 "☑") — type="checkbox" 만, 속성은 checked 뿐(아래 _emit_start)
"input",
})
_DESC_VOID_TAGS: frozenset[str] = frozenset({"br", "img", "input"})
# a: target/rel 은 "새 탭에서 열기"용. 화면(설명란)에서 링크를 클릭하면
# 새 탭으로 여는데, 저장했다 다시 열었을 때도 같은 동작이어야 해서 허용한다.
# span: 멘션 칩(@이름) 전용 — class="pj-mention" + data-email 만 남긴다.
_DESC_ALLOWED_ATTRS: dict[str, frozenset[str]] = {
"a": frozenset({"href", "target", "rel"}),
"img": frozenset({"src", "alt", "width", "height"}),
"span": frozenset({"class", "data-email"}),
"input": frozenset({"type", "checked"}),
# ul: 체크리스트(서식 도구 ☑ — 줄마다 체크박스) 표시용 class="pj-checklist" 하나만
"ul": frozenset({"class"}),
# li: 체크리스트 줄의 체크 여부 — data-checked="true" 만(체크박스는 CSS 가 글머리처럼 그린다)
"li": frozenset({"data-checked"}),
}
# URL 은 금지 목록이 아니라 허용 목록으로 검사한다. 금지 목록(javascript: 등)은
# "jav&#x09;ascript:" 처럼 중간에 탭/개행을 끼우면 통과하는데, 브라우저는 URL 을
# 해석할 때 그 문자들을 지워버려 그대로 스크립트가 실행된다.
_DESC_SAFE_SCHEMES: frozenset[str] = frozenset({"http", "https", "mailto", "tel"})
# <img src> 에만 허용하는 data: 이미지(붙여넣기 폴백). svg 는 스크립트를 품을 수 있어 제외.
_DESC_SAFE_DATA_IMAGE = re.compile(r"^data:image/(png|jpe?g|gif|webp|bmp);", re.I)
_URL_SCHEME_RE = re.compile(r"^([a-z][a-z0-9+.\-]*):", re.I)
_C0_AND_SPACE = "".join(chr(i) for i in range(0x21)) # 브라우저가 URL 앞뒤에서 떼는 문자
# 첨부를 브라우저 안에서 바로 보여줘도 되는 형식(`/inline`). 그 밖의 형식(HTML·SVG
# 등)은 같은 도메인에서 열리면 스크립트가 돌 수 있어 항상 다운로드로 내려준다.
INLINE_SAFE_CONTENT_TYPES: frozenset[str] = frozenset({
"image/png", "image/jpeg", "image/jpg", "image/gif", "image/webp", "image/bmp",
})
def inline_safe_content_type(content_type: Any) -> bool:
return norm_str(content_type, lower=True).split(";", 1)[0].strip() in INLINE_SAFE_CONTENT_TYPES
# 멘션 칩: <span class="pj-mention" data-email="...">@이름</span>
_MENTION_CLASS = "pj-mention"
# 태그별로 남길 수 있는 class 값(하나씩) — 그 밖의 class 는 버린다.
_DESC_ALLOWED_CLASS: dict[str, str] = {"span": _MENTION_CLASS, "ul": "pj-checklist"}
# script/style 은 태그 자체는 물론 그 안의 텍스트(코드)도 통째로 버린다 —
# 허용 태그 목록에 없어 태그는 이미 안 남지만, HTMLParser는 이 둘의 내용을
# 별도 데이터로 넘기므로 handle_data 에서 따로 걸러야 한다.
_DESC_RAW_TEXT_TAGS: frozenset[str] = frozenset({"script", "style"})
# 글자 색·크기(서식 도구, 2026-10-08) — 평범한 span 의 style 에서 이 둘만, 정해진 형식만 남긴다.
_DESC_STYLE_COLOR = re.compile(r"^(#[0-9a-f]{3}|#[0-9a-f]{6}|rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\))$", re.I)
DESC_FONT_SIZES: frozenset[str] = frozenset({"12px", "18px", "22px", "28px"})
def desc_inline_style(value: str) -> str:
"""span style → "color: …; font-size: …" 중 허용된 것만(나머지 선언·url()·expression 등은 버림)."""
kept: list[str] = []
for decl in (value or "").split(";"):
if ":" not in decl:
continue
prop, val = (x.strip().lower() for x in decl.split(":", 1))
if prop == "color" and _DESC_STYLE_COLOR.match(val) and not any(k.startswith("color:") for k in kept):
kept.append(f"color: {val}")
elif prop == "font-size" and val in DESC_FONT_SIZES and not any(k.startswith("font-size:") for k in kept):
kept.append(f"font-size: {val}")
# 링크 굵기 "보통"(2026-10-30) — 링크 기본이 굵게라 보통으로 되돌릴 때만 쓴다(굵게는 값 없음)
elif prop == "font-weight" and val in ("400", "normal") and not any(k.startswith("font-weight:") for k in kept):
kept.append("font-weight: 400")
return "; ".join(kept)
def _desc_escape_text(text: str) -> str:
return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
def _desc_escape_attr(value: str) -> str:
return _desc_escape_text(value).replace('"', "&quot;")
def desc_url_is_safe(value: str, *, allow_data_image: bool = False) -> bool:
"""href/src 허용 여부. 스킴이 없으면(상대경로·#앵커) 허용, 있으면 허용 목록만.
브라우저와 같은 방식으로 정규화한 뒤 검사한다 — 앞뒤 공백/제어문자를 떼고,
중간의 탭·개행(\\t \\n \\r)은 지운다(WHATWG URL 파서 동작).
"""
v = re.sub(r"[\t\n\r]", "", value or "").strip(_C0_AND_SPACE)
m = _URL_SCHEME_RE.match(v)
if not m:
# "javascript&colon;..." 같은 건 convert_charrefs 로 이미 풀려 여기 오지
# 않는다. 스킴이 없는 값 중 ':' 가 첫 '/' 보다 앞에 있으면 해석이 모호하니 막는다.
head = v.split("/", 1)[0]
return ":" not in head
scheme = m.group(1).lower()
if scheme in _DESC_SAFE_SCHEMES:
return True
return allow_data_image and bool(_DESC_SAFE_DATA_IMAGE.match(v))
class _DescriptionSanitizer(HTMLParser):
"""허용 태그/속성만 통과시키는 최소 HTML 정리기."""
def __init__(self) -> None:
super().__init__(convert_charrefs=True)
self.out: list[str] = []
self._open: list[str] = []
self._raw = False # <script>/<style> 내부(태그 자체와 별개로 텍스트도 버림)
def _emit_start(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
if tag in _DESC_RAW_TEXT_TAGS:
self._raw = True
return
if tag not in _DESC_ALLOWED_TAGS:
return
# input 은 체크박스만 — 다른 종류(text·file·hidden 등)는 태그째 버리고,
# 체크 여부 말고는 아무 속성도 남기지 않는다.
if tag == "input":
if (dict(attrs).get("type") or "").strip().lower() != "checkbox":
return
checked = any(name == "checked" for name, _ in attrs)
self.out.append('<input type="checkbox" checked>' if checked else '<input type="checkbox">')
return
allowed = _DESC_ALLOWED_ATTRS.get(tag, frozenset())
# span 은 멘션 칩일 때만 속성을 갖는다 — class 가 pj-mention 이 아니면
# data-email 까지 통째로 버린다(평범한 span 으로만 남는다).
if tag == "span" and (dict(attrs).get("class") or "").strip() != _MENTION_CLASS:
allowed = frozenset({"style"}) # 평범한 span — 글자 색·크기만(desc_inline_style)
kept: list[str] = []
for name, value in attrs:
if name not in allowed:
continue
value = value or ""
if name == "href" and not desc_url_is_safe(value):
continue
if name == "src" and not desc_url_is_safe(value, allow_data_image=True):
continue
# class 는 태그마다 정해진 값 하나만(멘션 칩·체크리스트) — 임의 클래스로
# 화면 스타일을 흔들 여지를 남기지 않는다.
if name == "class" and value.strip() != _DESC_ALLOWED_CLASS.get(tag):
continue
if name == "data-checked" and value.strip() != "true":
continue
if name == "style":
value = desc_inline_style(value)
if not value:
continue
kept.append(f'{name}="{_desc_escape_attr(value)}"')
attr_text = (" " + " ".join(kept)) if kept else ""
self.out.append(f"<{tag}{attr_text}>")
if tag not in _DESC_VOID_TAGS:
self._open.append(tag)
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
self._emit_start(tag, attrs)
def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
self._emit_start(tag, attrs)
def handle_endtag(self, tag: str) -> None:
if tag in _DESC_RAW_TEXT_TAGS:
self._raw = False
return
if tag not in _DESC_ALLOWED_TAGS or tag in _DESC_VOID_TAGS:
return
if tag not in self._open:
return
# 짝이 안 맞는 깨진 HTML 방어 — 스택에서 같은 태그가 나올 때까지 닫는다.
while self._open:
top = self._open.pop()
self.out.append(f"</{top}>")
if top == tag:
break
def handle_data(self, data: str) -> None:
if self._raw:
return
self.out.append(_desc_escape_text(data))
def close(self) -> None:
super().close()
while self._open:
self.out.append(f"</{self._open.pop()}>")
def sanitize_description_html(html: str) -> str:
"""업무 설명 HTML을 허용 태그만 남기고 정리한다.
스크립트·이벤트 속성(onerror 등)·위험 URL 스킴(javascript: 등)을 제거한다.
저장 직전 항상 이 함수를 거친다 — 화면에서 붙여넣은 이미지/서식은 거의
그대로 남고, 위험한 부분만 사라진다.
"""
parser = _DescriptionSanitizer()
parser.feed(html or "")
parser.close()
return "".join(parser.out).strip()
# ════════════════════════════════════════════════════════════
# 멘션(@태그)
#
# 설명란은 HTML이라 멘션 칩(<span class="pj-mention" data-email="...">)에서
# 이메일을 그대로 꺼낼 수 있다 — 클라이언트가 따로 알려주는 목록을 믿지 않고
# 저장될 본문에서 직접 읽는다(본문과 알림이 어긋나지 않는다).
# 댓글은 평문이라 칩을 넣을 수 없으므로, 그쪽만 클라이언트가 보낸 이메일
# 목록을 받아 normalize_emails 로 정리해 쓴다.
# ════════════════════════════════════════════════════════════
class _MentionCollector(HTMLParser):
def __init__(self) -> None:
super().__init__(convert_charrefs=True)
self.emails: list[str] = []
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
if tag != "span":
return
attr = dict(attrs)
if (attr.get("class") or "").strip() != _MENTION_CLASS:
return
email = norm_str(attr.get("data-email") or "", lower=True)
if email and email not in self.emails:
self.emails.append(email)
def extract_mentions_from_html(html: str) -> list[str]:
"""설명 HTML 안의 멘션 칩에서 이메일을 뽑는다(중복 제거, 순서 유지)."""
parser = _MentionCollector()
parser.feed(html or "")
parser.close()
return parser.emails
class _TextCollector(HTMLParser):
_BREAK_TAGS = frozenset({"br", "p", "div", "li", "blockquote", "pre"})
def __init__(self) -> None:
super().__init__(convert_charrefs=True)
self.parts: list[str] = []
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
if tag in self._BREAK_TAGS:
self.parts.append(" ")
def handle_data(self, data: str) -> None:
self.parts.append(data)
def html_to_text(html: str) -> str:
"""설명 HTML → 한 줄 평문(검색 확인·미리보기용). 공백은 하나로 줄인다."""
parser = _TextCollector()
parser.feed(html or "")
parser.close()
return re.sub(r"\s+", " ", "".join(parser.parts)).strip()
def search_snippet(text: str, query: str, *, width: int = 60) -> str:
"""text 에서 query 주변만 잘라 보여준다(앞뒤 … 표시). 없으면 앞부분."""
t = text or ""
i = t.lower().find((query or "").lower())
if i < 0:
return t[:width * 2] + ("…" if len(t) > width * 2 else "")
start = max(0, i - width)
end = min(len(t), i + len(query) + width)
return ("…" if start else "") + t[start:end] + ("…" if end < len(t) else "")
def normalize_emails(values: Any) -> list[str]:
"""임의 입력(리스트/문자열)을 소문자 이메일 목록으로 정리한다."""
if isinstance(values, str):
values = values.split(",")
if not isinstance(values, (list, tuple)):
return []
out: list[str] = []
for v in values:
e = norm_str(str(v or ""), lower=True)
if e and "@" in e and e not in out:
out.append(e)
return out