Files
dbx-main/app/modules/project/store.py
T
king 20232baf06 feat(project): add font options and selected goal text formatting
Restore the board header add button to the task side panel while keeping footer quick entry. Add safe, persisted goal text formatting and self-hosted Project font preferences with shared help updates and regression coverage.
2026-10-02 17:28:54 +09:00

997 lines
43 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" # 하위 업무를 다른 상위 업무로 옮김(보드 드래그)
# 프로젝트 색상 팔레트 — 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", # 도구
)
# 섹션(칸반 컬럼) 색상표 — 모든 편집창이 프로젝트 색상표(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 안의 이름만, 빈값/목록 밖은 None(첫 글자 표시)."""
v = norm_str(icon)
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}"
# ════════════════════════════════════════════════════════════
# 연간 목표 (마이그레이션 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(분기) 뒤에만 된다."""
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:"
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"]}
if isinstance(item.get("bold"), bool):
run["bold"] = item["bold"]
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
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) -> str:
"""허용한 글자 서식만 HTML로 만든다. 사용자 텍스트는 항상 escape한다."""
out = []
for run in goal_text_runs(body):
style = []
if "bold" in run:
style.append("font-weight:" + ("700" if run["bold"] else "400"))
if "color" in run:
style.append("color:" + run["color"])
if "size" in run:
style.append(f'font-size:{run["size"]}px')
text = escape(run["text"])
out.append(f'<span style="{";".join(style)}">{text}</span>' if style else text)
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))
# ── 엑셀식 사각형 병합(마이그레이션 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
# 첫 회의록(이전 주 회의록이 없을 때)의 구역별 줄 — 사용자 회의록 양식(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]]:
"""그 달의 주(월요일~일요일) 목록 — **1주차 = 그 달 첫 월요일이 있는 주**, 주는 월요일이 속한 달의 것
(2026-10-01 사용자 기준). 예: 2026년 10월 = 10/5·12·19·26 주, 9/28~10/4 주는 9월 마지막 주.
월간 목표·누적은 이와 따로 늘 1일~말일."""
first = date(year, month, 1)
last = month_last_day(year, month)
out, mon = [], first + timedelta(days=(7 - first.weekday()) % 7)
while mon <= last:
out.append((mon, mon + timedelta(days=6)))
mon += timedelta(days=7)
return out
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:
try:
d = date.fromisoformat(str(v).strip()[:10])
except ValueError:
raise ValueError("주 시작일이 올바르지 않습니다.")
if d.weekday() != 0:
raise ValueError("주 시작일은 월요일이어야 합니다.")
if not 2000 <= d.year <= 2100:
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"})
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()
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
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