fix(project): 보안·권한·데이터 버그 수정 및 성능 개선

보안
- 첨부 /inline: 업로드한 쪽이 정한 content-type 을 그대로 띄워 HTML/SVG
  첨부로 저장형 XSS 가능 → 안전한 이미지 형식만 인라인, 나머지는 다운로드.
  nosniff + CSP sandbox 헤더 추가.
- 설명란 sanitizer: URL 금지 목록이 "jav	ascript:" 로 우회됨 →
  허용 목록(http/https/mailto/tel/상대경로, img 는 data: 이미지)으로 변경.

권한
- 업무 생성 시 parent_task_id 로 권한 없는 프로젝트에 하위 업무 생성 가능 → 거부.
- 세션 수정/순서/삭제 API 가 세션이 URL 프로젝트 소속인지 안 봄 → 404.
- 업무 생성·수정·연결 시 세션이 해당 프로젝트 것인지 검증.
- 멤버/세션/업무/활동 조회 API 와 프로젝트 화면을 멤버·owner·admin 만.
  users/tasks 전체 조회는 볼 수 있는 프로젝트 업무만.

데이터
- 연결(멀티호밍) 업무를 연결된 프로젝트에서 열어 저장하면 세션 선택이 비어
  stage_id=null 이 전송돼 원래 세션·완료 상태가 지워짐 → home_stage_id 사용,
  빈 세션은 보내지 않음.
- mergeTask 가 같은 id 의 첫 행만 고쳐 연결 업무 카드가 중복/사라짐 → 모든
  맥락 행을 고치되 맥락별 세션 필드는 보존. 새 업무가 다음 동기화까지 안
  보이던 문제도 수정.
- 삭제·세션 이름변경·첨부 추가가 실시간 반영 안 됨 → 트리거 카운터
  (마이그레이션 007, 미적용 시 MAX 폴백). 화면 열자마자 기준값을 잡아
  첫 8초 사이 변경 누락도 해결. 동기화 시 이 프로젝트 행을 통째로 교체.
- 사이드바 "내 업무" 개수가 화면마다 다르던 것 → count_my_open 하나로 통일.
- 업무/프로젝트/댓글 삭제 시 디스크 첨부 파일 정리.

성능
- 라우터 핸들러 async def → def (동기 psycopg 가 이벤트 루프를 막음).
- 프로젝트 화면 N+1 → 업무·세션 각각 쿼리 1회.
- live-version 풀스캔 → PK 한 줄 조회. 탭 숨김 시 폴링 중지.
- 동기화 API 3개 → /snapshot 1개, 배지 숫자는 /my-tasks/open-count.
- 순서 변경 UPDATE N번 → unnest 1번. 첨부는 한도+1 바이트만 읽음.

기타
- 마이그레이션 003 번호 중복 → project_db_003b_task_times.sql.
- CLAUDE.md 의 옛 권한 설명 정정, PROJECT_MODULE.md 갱신. 캐시 버전 20260923b.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-09-23 12:59:37 +09:00
parent b0062504b6
commit ca9beab729
11 changed files with 631 additions and 207 deletions
+1 -1
View File
@@ -36,7 +36,7 @@ Claude Code는 이 저장소에서 작업을 시작하기 전에 **반드시 아
- 말레이시아 창고 재고관리 (`app/modules/malaysia/`, `malaysia_stock_db`) — 낱개(MT/MX/MZ) 입출고·조정, 세트(MY) BOM, 일일 재고조사(세트→낱개 자동 분해), 현재고 현황. 뚜껑(MD-)은 재고 집계 제외 — 단, 창고 랙에는 위치 확인용으로 배치 가능(`store.LID_ITEMS`). 상품은 `itemcode_db` 읽기 전용. 권한키 `malaysia`
- 말레이시아 배송 (`app/modules/dispatch/`, `dispatch_db`) — TikTok·Shopee 출고관리. 플랫폼별 데이터 엑셀 업로드(TikTok=03_TikTok_Order_Export.xlsx, Shopee=Packing List.Doorstep Delivery.xlsx) → 1상자=1카드 출고 작업 리스트·SKU 피킹 요약·Kagayaku 전달표 자동 생성. 1상자 묶음 기준 Package ID > Tracking ID > Order ID, 같은 상자 같은 SKU 합산. 작업 상태 토글(`dispatch_logs` 기록). 받는 사람 이름/전화/주소는 상자 단위로 저장(작업 카드 표시 + 출고 엑셀 생성용 — 개인정보). 배치 다운로드 zip 에 업로드 원본 + 취합 출고 엑셀(`YYYY.MM.DD(Ddd)_tictoc|shopee.xlsx`) 포함. 엑셀은 openpyxl 파싱/생성. 권한키 `dispatch`. 상세는 `docs/DISPATCH_MODULE.md`
- 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력. 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널). 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지(업로드 → `POST /admin/products/images` → PUT `detail_image`+`image_upload_type=A`), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지. 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력. 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지). **카페24 관리자 API 는 PUT 뒤 한동안 GET 에서 예전 값을 돌려준다(읽기 지연)** — 우리 캐시 문제가 아니다. 그래서 "마지막 쓰기가 권위": 상세설명은 카페24 값이 최근 revision 중 하나와 같으면 지연으로 보고 마지막 MANUAL/SCHEDULED 를 표시·지문 기준으로 쓰고(`store.resolve_description`), 스칼라(상품명·가격·이미지·진열/판매)는 PUT 응답 스냅샷(`cafe24_products.last_write_snapshot`, 마이그레이션 004)과 GET 의 `updated_date` 를 비교해 덮어씌운다(`store.overlay_recent_write`). 유예시간 `CAFE24_READ_LAG_GRACE_MIN`(기본 360분). 쓰기 후 화면은 PUT 응답으로 그리고 다시 GET 하지 않는다. 예약은 DB 저장 + 별도 worker(`app/modules/cafe24/worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다. 권한키 `cafe24`(연결/해제는 admin 전용). 상세는 `docs/CAFE24_MODULE.md`
- 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·업무(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 업무 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 달력(FullCalendar)/타임라인(vis-timeline)/보드/리스트/대시보드 뷰 토글. 좌측 사이드바는 두 화면 공용(`templates/project/_side.html`). 보드는 아사나처럼 세션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 업무(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 업무가 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성/삭제·사용자 배정은 `is_admin` 만, 배정 멤버(또는 owner)는 서브프로젝트/업무/단계 CRUD. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 업무 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 상세는 `docs/PROJECT_MODULE.md`
- 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·업무(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 업무 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 달력(FullCalendar)/타임라인(vis-timeline)/보드/리스트/대시보드 뷰 토글. 좌측 사이드바는 두 화면 공용(`templates/project/_side.html`). 보드는 아사나처럼 세션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 업무(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 업무가 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/업무/단계 CRUD — URL 의 세션·부모 업무가 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 업무 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 상세는 `docs/PROJECT_MODULE.md`
상세는 `docs/PROJECT_OVERVIEW.md`.
+209 -69
View File
@@ -13,9 +13,12 @@
from __future__ import annotations
import logging
from datetime import date, datetime, time
import time
from datetime import date, datetime
from datetime import time as dtime
from typing import Any
from psycopg import errors as psycopg_errors
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
@@ -36,6 +39,7 @@ class ProjectStore:
open=False,
)
self._pool.open(wait=False)
self._live_retry_at = 0.0 # latest_version: 007 카운터 테이블 재시도 시각
def close(self) -> None:
self._pool.close()
@@ -166,12 +170,26 @@ class ProjectStore:
raise KeyError(project_id)
return self._serialize(row)
def delete_project(self, *, project_id: int) -> None:
"""프로젝트(서브프로젝트·단계·업무 CASCADE) 삭제."""
def delete_project(self, *, project_id: int) -> list[int]:
"""프로젝트(서브프로젝트·단계·업무 CASCADE) 삭제.
같이 지워진 업무 id 목록을 돌려준다 — DB 행은 CASCADE 로 사라지지만
디스크의 첨부 폴더(DATA_DIR/project/<task_id>)는 라우터가 치워야 한다.
"""
with self._pool.connection() as conn:
cur = conn.execute("DELETE FROM projects WHERE id = %s", (project_id,))
if cur.rowcount == 0:
raise KeyError(project_id)
with conn.transaction():
rows = conn.execute(
"WITH RECURSIVE tree AS ("
" SELECT id FROM projects WHERE id = %s "
" UNION ALL "
" SELECT p.id FROM projects p JOIN tree ON p.parent_id = tree.id"
") SELECT t.id FROM tasks t WHERE t.project_id IN (SELECT id FROM tree)",
(project_id,),
).fetchall()
cur = conn.execute("DELETE FROM projects WHERE id = %s", (project_id,))
if cur.rowcount == 0:
raise KeyError(project_id)
return [int(r["id"]) for r in rows]
# ════════════════════════════════════════════════════════════
# 멤버
@@ -237,6 +255,23 @@ class ProjectStore:
).fetchall()
return [self._serialize(r) for r in rows]
def list_stages_for_projects(self, *, project_ids: list[int]) -> dict[int, list[dict[str, Any]]]:
"""여러 프로젝트의 세션을 한 번에 — {project_id: [stage, ...]} (세션 없는 프로젝트도 빈 목록)."""
ids = [int(i) for i in project_ids]
out: dict[int, list[dict[str, Any]]] = {i: [] for i in ids}
if not ids:
return out
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM project_stages WHERE project_id = ANY(%s) "
"ORDER BY project_id, sort_order ASC, id ASC",
(ids,),
).fetchall()
for r in rows:
s = self._serialize(r)
out.setdefault(s["project_id"], []).append(s)
return out
def add_stage(
self, *, project_id: int, name: str, is_done_stage: bool = False,
color: str | None = None, created_by: str = "",
@@ -266,6 +301,31 @@ class ProjectStore:
).fetchone()
return self._serialize(row) if row else None
@staticmethod
def _check_stage_in_project(conn: Any, stage_id: Any, project_id: int) -> int | None:
"""세션이 그 프로젝트 것인지 확인하고 int 로 돌려준다(None 은 그대로).
확인 안 하면 다른 프로젝트의 세션 id 를 넣어 업무를 엉뚱한 세션에
묶거나(보드에서 사라짐) 남의 세션 완료 여부로 완료 처리가 될 수 있다.
"""
if stage_id in (None, ""):
return None
try:
sid = int(stage_id)
except (TypeError, ValueError):
raise ValueError("세션 값이 올바르지 않습니다.")
row = conn.execute(
"SELECT 1 FROM project_stages WHERE id = %s AND project_id = %s",
(sid, project_id),
).fetchone()
if not row:
raise ValueError("이 프로젝트의 세션이 아닙니다.")
return sid
def stage_in_project(self, *, stage_id: Any, project_id: int) -> int | None:
with self._pool.connection() as conn:
return self._check_stage_in_project(conn, stage_id, project_id)
def delete_stage(self, *, stage_id: int) -> None:
with self._pool.connection() as conn:
cur = conn.execute("DELETE FROM project_stages WHERE id = %s", (stage_id,))
@@ -360,48 +420,84 @@ class ProjectStore:
def _list_tasks_for_project_with_links(
self, *, project_id: int, assignee_email: str | None, limit: int,
) -> list[dict[str, Any]]:
"""`list_tasks` 의 "이 프로젝트 + 여기 연결된 업무" 경로.
"""`list_tasks` 의 "이 프로젝트 + 여기 연결된 업무" 경로."""
return self.list_tasks_for_projects(
project_ids=[project_id], assignee_email=assignee_email, limit=limit,
)
`t.*` 뒤에 같은 이름(`stage_id`)을 다시 셀렉트해 덮어쓴다 — psycopg 의
dict_row 는 중복 컬럼명이 있으면 마지막 값으로 덮어쓰므로, "이 프로젝트
맥락에서의 세션"(연결이면 link.stage_id, 기본홈이면 t.stage_id)이
최종값이 된다. 원래 소속 프로젝트 배지(`project_name`/`project_color`)는
`t.project_id` 기준 그대로 둬 "다른 프로젝트에서 온 업무"임을 알 수 있게
한다.
def list_tasks_for_projects(
self, *, project_ids: list[int], assignee_email: str | None = None,
limit: int = 20000,
) -> list[dict[str, Any]]:
"""여러 프로젝트의 최상위 업무(+ 각 프로젝트에 연결된 업무)를 쿼리 한 번에.
프로젝트 화면은 접근 가능한 모든 프로젝트의 업무를 그리는데, 예전엔
프로젝트마다 쿼리를 따로 날렸다(N+1). 행마다 붙는 값:
context_project_id : 어느 프로젝트 맥락의 행인지(연결 업무는 연결된 쪽)
is_linked : 다른 프로젝트에서 연결돼 온 행인지
stage_id : 그 맥락에서의 세션(연결이면 link.stage_id — 없으면 NULL)
home_stage_id : 원래 소속 세션(tasks.stage_id). 업무 편집 팝업의
"세션" 선택은 항상 이 값을 쓴다.
`t.*` 뒤에 같은 이름(`stage_id`)을 다시 셀렉트해 덮어쓴다 — dict_row 는
중복 컬럼명이면 마지막 값을 쓴다. 원래 소속 배지(`project_name`/`color`)는
`t.project_id` 기준 그대로 둬 "다른 프로젝트에서 온 업무"임을 보인다.
"""
clauses = [
"t.parent_task_id IS NULL",
"(t.project_id = %(pid)s OR link.project_id = %(pid)s)",
]
params: dict[str, Any] = {"pid": project_id, "limit": int(limit)}
ids = [int(i) for i in project_ids]
if not ids:
return []
params: dict[str, Any] = {"ids": ids, "limit": int(limit)}
extra = ""
if assignee_email:
clauses.append("t.assignee_email = %(assignee)s")
extra = "AND t.assignee_email = %(assignee)s"
params["assignee"] = store.norm_str(assignee_email, lower=True)
where = "WHERE " + " AND ".join(clauses)
with self._pool.connection() as conn:
rows = conn.execute(
f"""
SELECT t.*, p.name AS project_name, p.color AS project_color,
(SELECT COUNT(*) FROM task_comments c WHERE c.task_id = t.id) AS comment_count,
{self._SUBTASK_COUNTS_SQL},
(link.id IS NOT NULL) AS is_linked,
COALESCE(es.name, s.name) AS stage_name,
COALESCE(es.is_done_stage, s.is_done_stage) AS is_done_stage,
COALESCE(link.stage_id, t.stage_id) AS stage_id
FROM tasks t
x.context_project_id,
x.is_linked,
t.stage_id AS home_stage_id,
CASE WHEN x.is_linked THEN es.name ELSE s.name END AS stage_name,
CASE WHEN x.is_linked THEN es.is_done_stage ELSE s.is_done_stage END AS is_done_stage,
CASE WHEN x.is_linked THEN x.link_stage_id ELSE t.stage_id END AS stage_id
FROM (
SELECT id AS task_id, project_id AS context_project_id,
FALSE AS is_linked, NULL::bigint AS link_stage_id
FROM tasks
WHERE parent_task_id IS NULL AND project_id = ANY(%(ids)s)
UNION ALL
SELECT l.task_id, l.project_id, TRUE, l.stage_id
FROM task_project_links l
JOIN tasks lt ON lt.id = l.task_id
WHERE l.project_id = ANY(%(ids)s)
AND lt.parent_task_id IS NULL
AND lt.project_id <> l.project_id
) x
JOIN tasks t ON t.id = x.task_id
JOIN projects p ON p.id = t.project_id
LEFT JOIN project_stages s ON s.id = t.stage_id
LEFT JOIN task_project_links link
ON link.task_id = t.id AND link.project_id = %(pid)s
AND t.project_id <> %(pid)s
LEFT JOIN project_stages es ON es.id = link.stage_id
{where}
ORDER BY t.sort_order ASC, t.id ASC LIMIT %(limit)s
LEFT JOIN project_stages es ON es.id = x.link_stage_id
WHERE TRUE {extra}
ORDER BY x.context_project_id, t.sort_order ASC, t.id ASC
LIMIT %(limit)s
""",
params,
).fetchall()
return [self._serialize(r) for r in rows]
def count_my_open(self, *, assignee_email: str) -> int:
"""사이드바 "내 업무" 배지 — 내가 담당인 미완료 업무 수(하위 업무 포함,
내 업무 화면 목록과 같은 기준)."""
with self._pool.connection() as conn:
row = conn.execute(
"SELECT COUNT(*) AS n FROM tasks "
"WHERE assignee_email = %s AND completed_at IS NULL",
(store.norm_str(assignee_email, lower=True),),
).fetchone()
return int(row["n"] or 0)
def list_my_tasks(self, *, assignee_email: str, limit: int = 1000) -> list[dict[str, Any]]:
""""내 업무" 화면 전용 — 내가 담당자인 업무를 레벨(최상위/하위) 상관없이
전부 반환한다. 하위 업무 행에는 부모 업무 정보(`parent_title` 등)를 같이
@@ -475,9 +571,15 @@ class ProjectStore:
).fetchone()
if not parent:
raise KeyError(f"상위 업무를 찾을 수 없습니다: {parent_task_id}")
project_id = parent["project_id"]
# 권한은 URL 의 project_id 로 검사했으므로, 부모가 다른 프로젝트
# 업무면 거부한다(예전엔 부모 프로젝트로 조용히 바꿔 권한 없는
# 프로젝트에 하위 업무를 만들 수 있었다).
if int(parent["project_id"]) != int(project_id):
raise ValueError("상위 업무가 이 프로젝트에 속하지 않습니다.")
stage_id = None
elif stage_id is None:
elif stage_id not in (None, ""):
stage_id = self._check_stage_in_project(conn, stage_id, project_id)
else:
# stage 미지정 시 프로젝트의 첫 세션으로
st = conn.execute(
"SELECT id FROM project_stages WHERE project_id = %s "
@@ -568,7 +670,9 @@ class ProjectStore:
# 를 그대로 다시 보내는데, 여기서 무조건 판정하면 방금 "완료로 표시"로
# 켠 completed_at 을(단계는 그대로인데) 다시 꺼버리는 버그가 있었다.
if "stage_id" in fields:
new_stage = fields["stage_id"]
new_stage = self.stage_in_project(
stage_id=fields["stage_id"], project_id=prev["project_id"]
)
sets.append("stage_id = %s")
params.append(new_stage)
if new_stage != prev.get("stage_id"):
@@ -611,11 +715,22 @@ class ProjectStore:
out["_newly_completed"] = newly_completed
return out
def delete_task(self, *, task_id: int) -> None:
def delete_task(self, *, task_id: int) -> list[int]:
"""업무(+하위 업무 CASCADE) 삭제. 지워진 업무 id 목록 반환 — 첨부 폴더 정리용."""
with self._pool.connection() as conn:
cur = conn.execute("DELETE FROM tasks WHERE id = %s", (task_id,))
if cur.rowcount == 0:
raise KeyError(task_id)
with conn.transaction():
rows = conn.execute(
"WITH RECURSIVE sub AS ("
" SELECT id FROM tasks WHERE id = %s "
" UNION ALL "
" SELECT t.id FROM tasks t JOIN sub ON t.parent_task_id = sub.id"
") SELECT id FROM sub",
(task_id,),
).fetchall()
cur = conn.execute("DELETE FROM tasks WHERE id = %s", (task_id,))
if cur.rowcount == 0:
raise KeyError(task_id)
return [int(r["id"]) for r in rows]
def _stage_is_done(self, stage_id: Any) -> bool:
if stage_id is None:
@@ -753,16 +868,26 @@ class ProjectStore:
).fetchone()
return self._serialize(out)
def delete_comment(self, *, comment_id: int, requester: str, is_admin: bool) -> None:
def delete_comment(
self, *, comment_id: int, requester: str, is_admin: bool
) -> list[dict[str, Any]]:
"""댓글 삭제. 댓글에 딸린 첨부 행은 CASCADE 로 같이 지워지므로, 디스크
파일을 치울 수 있게 그 첨부(task_id, stored_name) 목록을 돌려준다."""
with self._pool.connection() as conn:
row = conn.execute(
"SELECT author_email FROM task_comments WHERE id = %s", (comment_id,)
).fetchone()
if not row:
raise KeyError(comment_id)
if not is_admin and row["author_email"] != store.norm_str(requester, lower=True):
raise PermissionError("본인 댓글만 삭제할 수 있습니다.")
conn.execute("DELETE FROM task_comments WHERE id = %s", (comment_id,))
with conn.transaction():
row = conn.execute(
"SELECT author_email FROM task_comments WHERE id = %s", (comment_id,)
).fetchone()
if not row:
raise KeyError(comment_id)
if not is_admin and row["author_email"] != store.norm_str(requester, lower=True):
raise PermissionError("본인 댓글만 삭제할 수 있습니다.")
files = conn.execute(
"SELECT task_id, stored_name FROM task_attachments WHERE comment_id = %s",
(comment_id,),
).fetchall()
conn.execute("DELETE FROM task_comments WHERE id = %s", (comment_id,))
return [dict(f) for f in files]
# ════════════════════════════════════════════════════════════
# 첨부 (task_attachments) — 메타만 저장. 파일은 라우터가 디스크 처리.
@@ -847,25 +972,25 @@ class ProjectStore:
def reorder_projects(self, *, ordered_ids: list[int]) -> None:
"""홈 화면 프로젝트 카드 드래그 순서 변경. 최상위 프로젝트(parent_id
IS NULL)만 대상 — 서브프로젝트 정렬(부모 안에서의 순서)은 건드리지 않는다."""
# 순서 재배정은 전부 UPDATE 한 번으로 — unnest(...) WITH ORDINALITY 가
# 배열 순서(1부터)를 매겨준다. 예전엔 항목 수만큼 UPDATE 를 날렸다.
with self._pool.connection() as conn:
with conn.transaction():
for i, pid in enumerate(ordered_ids):
conn.execute(
"UPDATE projects SET sort_order = %s "
"WHERE id = %s AND parent_id IS NULL",
(i, int(pid)),
)
conn.execute(
"UPDATE projects p SET sort_order = v.ord - 1 "
"FROM unnest(%s::bigint[]) WITH ORDINALITY AS v(id, ord) "
"WHERE p.id = v.id AND p.parent_id IS NULL",
([int(i) for i in ordered_ids],),
)
def reorder_stages(self, *, project_id: int, ordered_ids: list[int]) -> None:
"""주어진 순서대로 sort_order 재배정. 해당 프로젝트 단계만 갱신."""
with self._pool.connection() as conn:
with conn.transaction():
for i, sid in enumerate(ordered_ids):
conn.execute(
"UPDATE project_stages SET sort_order = %s "
"WHERE id = %s AND project_id = %s",
(i, int(sid), project_id),
)
conn.execute(
"UPDATE project_stages s SET sort_order = v.ord - 1 "
"FROM unnest(%s::bigint[]) WITH ORDINALITY AS v(id, ord) "
"WHERE s.id = v.id AND s.project_id = %s",
([int(i) for i in ordered_ids], project_id),
)
def reorder_tasks(self, *, stage_id: int, ordered_ids: list[int]) -> None:
"""보드 카드 드래그로 같은 세션 안에서 순서 바꾸기. sort_order 는
@@ -873,13 +998,12 @@ class ProjectStore:
무방 — 화면은 항상 세션으로 먼저 필터링한 뒤 이 값으로 정렬한다),
여기서는 이 세션 소속 업무만 골라 0부터 다시 매긴다."""
with self._pool.connection() as conn:
with conn.transaction():
for i, tid in enumerate(ordered_ids):
conn.execute(
"UPDATE tasks SET sort_order = %s "
"WHERE id = %s AND stage_id = %s",
(i, int(tid), stage_id),
)
conn.execute(
"UPDATE tasks t SET sort_order = v.ord - 1 "
"FROM unnest(%s::bigint[]) WITH ORDINALITY AS v(id, ord) "
"WHERE t.id = v.id AND t.stage_id = %s",
([int(i) for i in ordered_ids], stage_id),
)
# ════════════════════════════════════════════════════════════
# 알림센터 (project_notifications)
@@ -1035,6 +1159,22 @@ class ProjectStore:
# 실시간 새로고침 — 프로젝트/업무/댓글/멤버/단계 중 가장 최근 변경 시각
# ════════════════════════════════════════════════════════════
def latest_version(self) -> str:
"""열어둔 화면이 8초마다 묻는 "뭔가 바뀌었나" 값.
마이그레이션 007 이 있으면 트리거가 올려주는 카운터 한 줄(PK)만 읽는다
— 삭제·세션 이름변경·첨부 추가까지 감지된다. 없으면 예전 MAX() 방식.
"""
if time.monotonic() >= self._live_retry_at:
try:
with self._pool.connection() as conn:
row = conn.execute(
"SELECT version FROM project_live_version WHERE id = 1"
).fetchone()
return f"v{row['version']}" if row else ""
except psycopg_errors.UndefinedTable:
# 5분 뒤 다시 시도 — 재기동 없이 마이그레이션을 적용해도 따라간다.
logger.warning("project_live_version 없음 — project_db_007 마이그레이션 적용 필요(MAX 방식으로 폴백)")
self._live_retry_at = time.monotonic() + 300
with self._pool.connection() as conn:
row = conn.execute(
"SELECT GREATEST("
@@ -1060,7 +1200,7 @@ class ProjectStore:
for k, v in list(out.items()):
if isinstance(v, datetime):
out[k] = v.astimezone(KST).isoformat(timespec="seconds")
elif isinstance(v, time):
elif isinstance(v, dtime):
out[k] = v.strftime("%H:%M")
elif isinstance(v, date):
out[k] = v.isoformat()
+216 -93
View File
@@ -10,6 +10,10 @@
- 메일: 업무가 직원에게 '배정'되거나 '완료'되면 관리자에게 알림(BackgroundTasks).
뷰: 메인은 달력(FullCalendar)/타임라인(vis-timeline) 토글. 추가로 보드(칸반)·리스트.
핸들러는 전부 `def`(sync)다. DB 드라이버(psycopg ConnectionPool)가 동기라서
`async def` 안에서 부르면 쿼리 도는 동안 이벤트 루프(=앱 전체 요청 처리)가
멈춘다. `def` 로 두면 FastAPI 가 스레드풀에서 돌린다.
"""
from __future__ import annotations
@@ -45,6 +49,12 @@ from . import store
# 첨부 업로드 제한
_MAX_ATTACH_BYTES = 20 * 1024 * 1024 # 20MB
# 첨부 응답 공통 헤더 — 브라우저가 내용을 보고 형식을 추측(sniff)해 HTML 로
# 실행하지 못하게 하고, 혹시 문서로 열려도 스크립트를 막는다.
_ATTACH_HEADERS = {
"X-Content-Type-Options": "nosniff",
"Content-Security-Policy": "default-src 'none'; img-src 'self'; style-src 'unsafe-inline'; sandbox",
}
logger = logging.getLogger("project.router")
@@ -110,6 +120,35 @@ def _can_delete(user: dict[str, Any], created_by: str | None) -> bool:
_DELETE_DENIED = "삭제는 만든 사람만 할 수 있습니다."
def _accessible_project_ids(st: Any, user: dict[str, Any]) -> set[int] | None:
"""사용자가 볼 수 있는 프로젝트 id 집합. 관리자는 None(=전체)."""
from app.store import is_admin # noqa: WPS433
if is_admin(user):
return None
return {
p["id"] for p in st.list_projects(include_archived=True, member_email=user["email"])
}
def _remove_task_dirs(request: Request, task_ids: list[int]) -> None:
"""삭제된 업무들의 첨부 폴더(DATA_DIR/project/<task_id>)를 지운다.
DB 행은 CASCADE 로 사라지지만 디스크 파일은 남아 계속 쌓였다. 실패해도
삭제 자체는 이미 끝났으므로 로그만 남긴다.
"""
import shutil # noqa: WPS433
base = Path(str(getattr(request.app.state, "data_dir", "."))) / "project"
for tid in task_ids:
d = base / str(int(tid))
if d.is_dir():
try:
shutil.rmtree(d)
except Exception: # noqa: BLE001
logger.warning("첨부 폴더 삭제 실패: %s", d)
def _admin_emails(request: Request) -> list[str]:
"""알림 수신 관리자 이메일 목록.
@@ -381,7 +420,7 @@ def _build_task_calendar(
# 페이지
# ────────────────────────────────────────────────────────────
@router.get("/health")
async def health(request: Request) -> JSONResponse:
def health(request: Request) -> JSONResponse:
st = _store(request)
if st is None:
return JSONResponse({"status": "not_configured"}, status_code=503)
@@ -393,7 +432,7 @@ async def health(request: Request) -> JSONResponse:
@router.get("/api/live-version")
async def api_live_version(request: Request) -> JSONResponse:
def api_live_version(request: Request) -> JSONResponse:
"""프로젝트/업무/댓글/멤버/단계 중 가장 최근 변경 시각.
페이지를 열어둔 클라이언트가 주기적으로 조회해 값이 바뀌면 새로고침한다
@@ -405,7 +444,7 @@ async def api_live_version(request: Request) -> JSONResponse:
@router.get("/", response_class=HTMLResponse)
async def my_tasks_page(request: Request) -> HTMLResponse:
def my_tasks_page(request: Request) -> HTMLResponse:
"""프로젝트 모듈의 첫 화면 = 내 업무.
예전 홈(프로젝트 카드 그리드)은 없앴다 — 좌측 "내 업무" 메뉴와 같은
@@ -461,7 +500,7 @@ async def my_tasks_page(request: Request) -> HTMLResponse:
@router.get("/t/{task_id}")
async def task_permalink(request: Request, task_id: int):
def task_permalink(request: Request, task_id: int):
"""업무 공유 링크(퍼머링크) — 업무 편집 팝업의 "링크 복사"가 만드는 주소.
누구에게 주소가 가더라도 **회사 계정으로 로그인한 그 프로젝트 멤버(또는
@@ -519,7 +558,7 @@ async def task_permalink(request: Request, task_id: int):
@router.get("/p/{project_id}", response_class=HTMLResponse)
async def project_page(request: Request, project_id: int) -> HTMLResponse:
def project_page(request: Request, project_id: int) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
@@ -533,38 +572,52 @@ async def project_page(request: Request, project_id: int) -> HTMLResponse:
raise HTTPException(status_code=404, detail="프로젝트를 찾을 수 없습니다.")
admin = is_admin(user)
# 멤버(또는 owner/관리자)가 아니면 이 프로젝트 화면을 열 수 없다 — 공유
# 링크(/project/t/{id})와 같은 원칙. 예전엔 세션·멤버 목록이 그대로 보였다.
can_manage = _can_manage(request, st, user, project_id)
if not can_manage:
return render_template(
request,
"denied.html",
{
"reason": "이 프로젝트의 멤버만 볼 수 있습니다. "
"프로젝트 관리자에게 멤버 배정을 요청하세요.",
"user": user,
"is_admin": admin,
"nav_items": build_erp_nav(user, active="project"),
},
status_code=403,
)
all_projects = st.list_projects(
include_archived=False,
member_email=None if admin else user["email"],
)
stages = st.list_stages(project_id=project_id)
tasks = st.list_tasks(project_id=project_id, limit=2000)
members = st.list_members(project_id=project_id)
can_manage = _can_manage(request, st, user, project_id)
top_projects = [p for p in all_projects if not p.get("parent_id")] # 과거 서브프로젝트 제외
top_ids = [p["id"] for p in top_projects]
# 좌측 트리 + 전체 집계: 4개 뷰(달력/타임라인/보드/리스트)는 '전체 프로젝트'를 보여준다.
# all_tasks : 접근 가능한 모든 프로젝트의 업무(뷰 데이터)
# stages_by_project : 프로젝트별 단계(보드 이름→단계 매핑 + 모달 단계 선택용)
# projects_meta : 프로젝트 메타(타임라인 그룹/보드 카드 배지용)
# 업무·세션은 프로젝트 수와 상관없이 각각 쿼리 한 번으로 받는다(예전엔
# 프로젝트마다 2번씩 — N+1). 행마다 context_project_id(어느 프로젝트를 보다가
# 담겼는지)가 붙어 있다 — 멀티호밍된 업무는 원 프로젝트와 연결된 프로젝트
# 양쪽에서 한 번씩 나오고, "전체 프로젝트" 집계는 원 소속 행만 센다.
all_tasks = st.list_tasks_for_projects(project_ids=top_ids)
stages_by_project = st.list_stages_for_projects(project_ids=top_ids)
stages = (
stages_by_project[project_id] if project_id in stages_by_project
else st.list_stages(project_id=project_id) # 보관된 프로젝트 등 목록 밖
)
tasks_by_ctx: dict[int, list[dict[str, Any]]] = {}
for t in all_tasks:
tasks_by_ctx.setdefault(t["context_project_id"], []).append(t)
nav_projects: list[dict[str, Any]] = []
all_tasks: list[dict[str, Any]] = []
stages_by_project: dict[int, list[dict[str, Any]]] = {}
projects_meta: list[dict[str, Any]] = []
for p in all_projects:
if p.get("parent_id"):
continue # 과거 서브프로젝트는 트리에서 제외
p_tasks = (
tasks if p["id"] == project_id
else st.list_tasks(project_id=p["id"], limit=2000)
)
# 이 업무가 '어느 프로젝트를 보다가' 담겼는지 표시 — 멀티호밍된 업무는
# 원 프로젝트(t.project_id)와 연결된 프로젝트(p.id) 양쪽에서 각각 한 번씩
# 나온다(각 프로젝트 화면에 보여야 하므로). "전체 프로젝트" 집계 화면은
# context_project_id == project_id(원 소속)인 것만 세어 중복을 없앤다.
for t in p_tasks:
t["context_project_id"] = p["id"]
all_tasks.extend(p_tasks)
stages_by_project[p["id"]] = st.list_stages(project_id=p["id"])
for p in top_projects:
p_tasks = tasks_by_ctx.get(p["id"], [])
projects_meta.append({
"id": p["id"],
"name": p["name"],
@@ -609,12 +662,8 @@ async def project_page(request: Request, project_id: int) -> HTMLResponse:
if u.get("picture")
}
# 우측 "내 업무" 패널 — 홈 화면과 동일한 쿼리/그룹핑(프로젝트별)을 재사용.
# 좌측 사이드바 "내 업무" 배지(진행 중 개수)와 수신함 배지.
my_open_total = sum(
1 for t in st.list_tasks(assignee_email=user["email"], limit=1000)
if not t.get("completed_at")
)
my_open_total = st.count_my_open(assignee_email=user["email"])
mention_unread = _safe_mention_unread(st, user["email"])
# 달력(휴가식 월간 그리드) — ?y=&m= 로 월 이동, 기본 이번 달
@@ -678,7 +727,7 @@ def _db_or_503(request: Request) -> Any:
@router.get("/api/projects")
async def api_list_projects(request: Request) -> JSONResponse:
def api_list_projects(request: Request) -> JSONResponse:
from app.store import is_admin # noqa: WPS433
user = _require_user(request)
@@ -692,7 +741,7 @@ async def api_list_projects(request: Request) -> JSONResponse:
@router.post("/api/projects")
async def api_create_project(
def api_create_project(
request: Request, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""최상위 프로젝트 생성 — 로그인해 프로젝트 모듈에 접근할 수 있는 사용자 누구나."""
@@ -715,7 +764,7 @@ async def api_create_project(
@router.post("/api/projects/{project_id}/subprojects")
async def api_create_subproject(
def api_create_subproject(
request: Request, project_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""서브프로젝트 생성 — 멤버(또는 관리자)."""
@@ -741,7 +790,7 @@ async def api_create_subproject(
@router.put("/api/projects/order")
async def api_reorder_projects(
def api_reorder_projects(
request: Request, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""홈 화면 프로젝트 카드 드래그 순서 변경. 최상위 프로젝트만 대상이며,
@@ -762,7 +811,7 @@ async def api_reorder_projects(
@router.put("/api/projects/{project_id}")
async def api_update_project(
def api_update_project(
request: Request, project_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
user = _require_user(request)
@@ -778,7 +827,7 @@ async def api_update_project(
@router.delete("/api/projects/{project_id}")
async def api_delete_project(request: Request, project_id: int) -> JSONResponse:
def api_delete_project(request: Request, project_id: int) -> JSONResponse:
"""프로젝트 삭제 — '만든 사람'만(슈퍼관리자 예외). 안의 업무도 CASCADE."""
user = _require_user(request)
st = _db_or_503(request)
@@ -787,7 +836,11 @@ async def api_delete_project(request: Request, project_id: int) -> JSONResponse:
raise HTTPException(status_code=404, detail="프로젝트를 찾을 수 없습니다.")
if not _can_delete(user, project.get("created_by")):
raise HTTPException(status_code=403, detail=_DELETE_DENIED)
st.delete_project(project_id=project_id)
try:
removed_task_ids = st.delete_project(project_id=project_id)
except KeyError:
raise HTTPException(status_code=404, detail="프로젝트를 찾을 수 없습니다.")
_remove_task_dirs(request, removed_task_ids)
return JSONResponse({"ok": True})
@@ -795,7 +848,7 @@ async def api_delete_project(request: Request, project_id: int) -> JSONResponse:
# JSON API — 멤버 (관리자가 사용자 배정)
# ────────────────────────────────────────────────────────────
@router.get("/api/assignable-users")
async def api_assignable_users(request: Request) -> JSONResponse:
def api_assignable_users(request: Request) -> JSONResponse:
"""배정 후보 = 등록된 사용자 중 프로젝트 권한(project 모듈) 보유자. 관리자 전용.
관리자 페이지의 '프로젝트 관리' 토글을 켠 직원이 자동으로 후보가 된다.
@@ -819,7 +872,7 @@ async def api_assignable_users(request: Request) -> JSONResponse:
@router.get("/api/all-users")
async def api_all_users(request: Request) -> JSONResponse:
def api_all_users(request: Request) -> JSONResponse:
"""프로젝트 화면 좌측 "전체 멤버" 표시용 — project 모듈 권한 보유 등록
사용자 전원. assignable-users 와 후보군은 같지만, 이건 멤버 배정(쓰기)이
아니라 단순 열람용이라 관리자가 아니어도 볼 수 있다."""
@@ -842,31 +895,37 @@ async def api_all_users(request: Request) -> JSONResponse:
@router.get("/api/users/tasks")
async def api_user_tasks(
def api_user_tasks(
request: Request, email: str, project_id: int | None = None
) -> JSONResponse:
"""'전체 멤버'/사이드바 '프로젝트 멤버' 아이콘 클릭 팝업 — 지정한 사용자가
담당자인 업무 목록(프로젝트/세션/마감일). project_id 를 주면 그 프로젝트
안에서 담당하는 업무만(멀티호밍으로 연결된 업무 포함, list_tasks 의
project_id 단일 조회 경로 재사용). 안 주면 전체 프로젝트 대상."""
_require_user(request)
user = _require_user(request)
st = _db_or_503(request)
if project_id is not None:
_require_manage(request, st, user, project_id)
tasks = st.list_tasks(project_id=project_id, assignee_email=email, limit=500)
else:
tasks = st.list_tasks(assignee_email=email, limit=500)
# 전체 대상이면 내가 볼 수 있는 프로젝트의 업무만 남긴다(비관리자).
allowed = _accessible_project_ids(st, user)
if allowed is not None:
tasks = [t for t in tasks if t["project_id"] in allowed]
return JSONResponse({"tasks": tasks})
@router.get("/api/projects/{project_id}/members")
async def api_list_members(request: Request, project_id: int) -> JSONResponse:
_require_user(request)
def api_list_members(request: Request, project_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
return JSONResponse({"members": st.list_members(project_id=project_id)})
@router.post("/api/projects/{project_id}/members")
async def api_add_member(
def api_add_member(
request: Request, project_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""사용자를 프로젝트에 배정 — 관리자 전용."""
@@ -885,7 +944,7 @@ async def api_add_member(
@router.delete("/api/projects/{project_id}/members/{user_email}")
async def api_remove_member(
def api_remove_member(
request: Request, project_id: int, user_email: str
) -> JSONResponse:
_require_admin(request)
@@ -898,14 +957,15 @@ async def api_remove_member(
# JSON API — 단계 (stages)
# ────────────────────────────────────────────────────────────
@router.get("/api/projects/{project_id}/stages")
async def api_list_stages(request: Request, project_id: int) -> JSONResponse:
_require_user(request)
def api_list_stages(request: Request, project_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
return JSONResponse({"stages": st.list_stages(project_id=project_id)})
@router.post("/api/projects/{project_id}/stages")
async def api_add_stage(
def api_add_stage(
request: Request, project_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
user = _require_user(request)
@@ -924,8 +984,17 @@ async def api_add_stage(
return JSONResponse({"stage": stage}, status_code=201)
def _stage_of_project(st: Any, stage_id: int, project_id: int) -> dict[str, Any]:
"""URL 의 세션이 URL 의 프로젝트 것인지 확인. 권한 검사는 project_id 로
하므로, 이걸 안 보면 아무 프로젝트 멤버나 남의 세션을 고칠 수 있다."""
stage = st.get_stage(stage_id=stage_id)
if stage is None or stage["project_id"] != project_id:
raise HTTPException(status_code=404, detail="세션을 찾을 수 없습니다.")
return stage
@router.delete("/api/projects/{project_id}/stages/{stage_id}")
async def api_delete_stage(
def api_delete_stage(
request: Request, project_id: int, stage_id: int
) -> JSONResponse:
"""세션(단계) 삭제 — 만든 사람만(슈퍼관리자 예외). 생성자 정보가 없는 과거
@@ -933,9 +1002,7 @@ async def api_delete_stage(
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
stage = st.get_stage(stage_id=stage_id)
if stage is None:
raise HTTPException(status_code=404, detail="세션을 찾을 수 없습니다.")
stage = _stage_of_project(st, stage_id, project_id)
if not _can_delete(user, stage.get("created_by")):
raise HTTPException(status_code=403, detail=_DELETE_DENIED)
try:
@@ -949,22 +1016,49 @@ async def api_delete_stage(
# JSON API — 업무 (tasks)
# ────────────────────────────────────────────────────────────
@router.get("/api/projects/{project_id}/tasks")
async def api_list_tasks(request: Request, project_id: int) -> JSONResponse:
_require_user(request)
def api_list_tasks(request: Request, project_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
tasks = st.list_tasks(project_id=project_id, include_subprojects=True, limit=2000)
return JSONResponse({"tasks": tasks})
@router.get("/api/projects/{project_id}/snapshot")
def api_project_snapshot(request: Request, project_id: int) -> JSONResponse:
"""프로젝트 화면 실시간 동기화용 — 업무(이 프로젝트 + 여기 연결된 업무,
context_project_id·home_stage_id 포함)·세션·멤버를 요청 한 번에.
예전엔 API 3개를 따로 불렀고, 업무 API 는 연결 업무를 빼고 돌려줘서
화면의 연결 업무 행과 맞지 않았다.
"""
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
return JSONResponse({
"tasks": st.list_tasks_for_projects(project_ids=[project_id]),
"stages": st.list_stages(project_id=project_id),
"members": st.list_members(project_id=project_id),
})
@router.get("/api/my-tasks")
async def api_my_tasks(request: Request) -> JSONResponse:
def api_my_tasks(request: Request) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
return JSONResponse({"tasks": st.list_my_tasks(assignee_email=user["email"], limit=1000)})
@router.get("/api/my-tasks/open-count")
def api_my_open_count(request: Request) -> JSONResponse:
"""사이드바 "내 업무" 배지 숫자만 — 목록 전체를 받지 않는다."""
user = _require_user(request)
st = _db_or_503(request)
return JSONResponse({"open": st.count_my_open(assignee_email=user["email"])})
@router.post("/api/projects/{project_id}/tasks")
async def api_create_task(
def api_create_task(
request: Request,
project_id: int,
bg: BackgroundTasks,
@@ -1029,7 +1123,7 @@ async def api_create_task(
@router.put("/api/tasks/{task_id}")
async def api_update_task(
def api_update_task(
request: Request,
task_id: int,
bg: BackgroundTasks,
@@ -1103,7 +1197,7 @@ async def api_update_task(
@router.delete("/api/tasks/{task_id}")
async def api_delete_task(request: Request, task_id: int) -> JSONResponse:
def api_delete_task(request: Request, task_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
existing = st.get_task(task_id=task_id)
@@ -1111,12 +1205,16 @@ async def api_delete_task(request: Request, task_id: int) -> JSONResponse:
raise HTTPException(status_code=404, detail="업무를 찾을 수 없습니다.")
if not _can_delete(user, existing.get("created_by")):
raise HTTPException(status_code=403, detail=_DELETE_DENIED)
st.delete_task(task_id=task_id)
try:
removed_task_ids = st.delete_task(task_id=task_id)
except KeyError:
raise HTTPException(status_code=404, detail="업무를 찾을 수 없습니다.")
_remove_task_dirs(request, removed_task_ids) # 하위 업무 첨부 폴더까지
return JSONResponse({"ok": True})
@router.get("/api/tasks/{task_id}")
async def api_get_task(request: Request, task_id: int) -> JSONResponse:
def api_get_task(request: Request, task_id: int) -> JSONResponse:
"""업무 상세 — 하위 업무·연결된 프로젝트 포함. 업무 편집 팝업을 열 때 쓴다."""
user = _require_user(request)
st = _db_or_503(request)
@@ -1133,7 +1231,7 @@ async def api_get_task(request: Request, task_id: int) -> JSONResponse:
# JSON API — 업무 멀티호밍 (다른 프로젝트/세션에 연결)
# ────────────────────────────────────────────────────────────
@router.post("/api/tasks/{task_id}/links")
async def api_add_task_link(
def api_add_task_link(
request: Request, task_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""업무를 다른 프로젝트(의 한 세션)에도 연결한다(아사나의 멀티호밍).
@@ -1162,16 +1260,21 @@ async def api_add_task_link(
)
if not already_linked:
_require_manage(request, st, user, task["project_id"])
stage_id = payload.get("stage_id")
try:
stage_id = st.stage_in_project(
stage_id=payload.get("stage_id") or None, project_id=target_project_id
)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
link = st.add_task_link(
task_id=task_id, project_id=target_project_id,
stage_id=int(stage_id) if stage_id else None, created_by=user["email"],
stage_id=stage_id, created_by=user["email"],
)
return JSONResponse({"link": link}, status_code=201)
@router.delete("/api/tasks/{task_id}/links/{project_id}")
async def api_remove_task_link(request: Request, task_id: int, project_id: int) -> JSONResponse:
def api_remove_task_link(request: Request, task_id: int, project_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
task = st.get_task(task_id=task_id)
@@ -1184,9 +1287,10 @@ async def api_remove_task_link(request: Request, task_id: int, project_id: int)
@router.get("/api/projects/{project_id}/activity")
async def api_activity(request: Request, project_id: int) -> JSONResponse:
_require_user(request)
def api_activity(request: Request, project_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
return JSONResponse({"activity": st.list_activity(project_id=project_id, limit=100)})
@@ -1194,7 +1298,7 @@ async def api_activity(request: Request, project_id: int) -> JSONResponse:
# JSON API — 댓글
# ────────────────────────────────────────────────────────────
@router.get("/api/tasks/{task_id}/comments")
async def api_list_comments(request: Request, task_id: int) -> JSONResponse:
def api_list_comments(request: Request, task_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
task = st.get_task(task_id=task_id)
@@ -1205,7 +1309,7 @@ async def api_list_comments(request: Request, task_id: int) -> JSONResponse:
@router.post("/api/tasks/{task_id}/comments")
async def api_add_comment(
def api_add_comment(
request: Request, task_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
user = _require_user(request)
@@ -1242,7 +1346,7 @@ async def api_add_comment(
@router.put("/api/comments/{comment_id}")
async def api_update_comment(
def api_update_comment(
request: Request, comment_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
from app.store import is_admin # noqa: WPS433
@@ -1264,17 +1368,25 @@ async def api_update_comment(
@router.delete("/api/comments/{comment_id}")
async def api_delete_comment(request: Request, comment_id: int) -> JSONResponse:
def api_delete_comment(request: Request, comment_id: int) -> JSONResponse:
from app.store import is_admin # noqa: WPS433
user = _require_user(request)
st = _db_or_503(request)
try:
st.delete_comment(comment_id=comment_id, requester=user["email"], is_admin=is_admin(user))
files = st.delete_comment(
comment_id=comment_id, requester=user["email"], is_admin=is_admin(user)
)
except KeyError:
raise HTTPException(status_code=404, detail="댓글을 찾을 수 없습니다.")
except PermissionError as exc:
raise HTTPException(status_code=403, detail=str(exc))
# 댓글 첨부 행은 CASCADE 로 사라졌다 — 디스크 파일도 치운다.
for f in files:
try:
(_attach_dir(request, f["task_id"]) / f["stored_name"]).unlink(missing_ok=True)
except Exception: # noqa: BLE001
logger.warning("댓글 첨부 파일 삭제 실패: %s", f.get("stored_name"))
return JSONResponse({"ok": True})
@@ -1289,7 +1401,7 @@ def _attach_dir(request: Request, task_id: int) -> Path:
@router.get("/api/tasks/{task_id}/attachments")
async def api_list_attachments(request: Request, task_id: int) -> JSONResponse:
def api_list_attachments(request: Request, task_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
task = st.get_task(task_id=task_id)
@@ -1300,7 +1412,7 @@ async def api_list_attachments(request: Request, task_id: int) -> JSONResponse:
@router.post("/api/tasks/{task_id}/attachments")
async def api_upload_attachment(
def api_upload_attachment(
request: Request, task_id: int, file: UploadFile = File(...),
comment_id: int | None = Form(None),
) -> JSONResponse:
@@ -1317,7 +1429,9 @@ async def api_upload_attachment(
if comment is None or comment["task_id"] != task_id:
raise HTTPException(status_code=400, detail="잘못된 댓글입니다.")
data = await file.read()
# 한도+1 바이트까지만 읽는다 — 20MB 를 넘는 파일을 끝까지 메모리에 올린 뒤에야
# 거절하던 것을 막는다(핸들러가 sync def 라 스레드풀에서 동기 읽기).
data = file.file.read(_MAX_ATTACH_BYTES + 1)
if len(data) > _MAX_ATTACH_BYTES:
raise HTTPException(status_code=413, detail="파일이 너무 큽니다(최대 20MB).")
if not data:
@@ -1338,7 +1452,7 @@ async def api_upload_attachment(
@router.get("/api/attachments/{attachment_id}/download")
async def api_download_attachment(request: Request, attachment_id: int):
def api_download_attachment(request: Request, attachment_id: int):
user = _require_user(request)
st = _db_or_503(request)
att = st.get_attachment(attachment_id=attachment_id)
@@ -1354,11 +1468,12 @@ async def api_download_attachment(request: Request, attachment_id: int):
return FileResponse(
str(path), filename=att["filename"],
media_type=att.get("content_type") or "application/octet-stream",
headers=_ATTACH_HEADERS,
)
@router.get("/api/attachments/{attachment_id}/inline")
async def api_inline_attachment(request: Request, attachment_id: int):
def api_inline_attachment(request: Request, attachment_id: int):
"""설명란에 붙여넣은/업로드한 이미지를 `<img src=...>` 로 바로 보여주기 위한
서빙. `/download` 는 `filename=` 을 줘서 강제 다운로드(Content-Disposition:
attachment)가 걸리므로 이미지 삽입에는 못 쓴다 — filename 을 안 주면 브라우저가
@@ -1375,11 +1490,20 @@ async def api_inline_attachment(request: Request, attachment_id: int):
path = _attach_dir(request, att["task_id"]) / att["stored_name"]
if not path.exists():
raise HTTPException(status_code=404, detail="파일이 디스크에 없습니다.")
return FileResponse(str(path), media_type=att.get("content_type") or "application/octet-stream")
content_type = att.get("content_type") or "application/octet-stream"
if not store.inline_safe_content_type(content_type):
# 형식은 업로드한 쪽이 정한 값이라 믿을 수 없다 — text/html·svg 등을 같은
# 도메인에서 그대로 띄우면 스크립트가 로그인 세션으로 돈다(저장형 XSS).
# 안전한 이미지가 아니면 항상 다운로드로 내려준다.
return FileResponse(
str(path), filename=att["filename"],
media_type="application/octet-stream", headers=_ATTACH_HEADERS,
)
return FileResponse(str(path), media_type=content_type, headers=_ATTACH_HEADERS)
@router.delete("/api/attachments/{attachment_id}")
async def api_delete_attachment(request: Request, attachment_id: int) -> JSONResponse:
def api_delete_attachment(request: Request, attachment_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
att = st.get_attachment(attachment_id=attachment_id)
@@ -1400,7 +1524,7 @@ async def api_delete_attachment(request: Request, attachment_id: int) -> JSONRes
# JSON API — 단계 이름/순서 편집
# ────────────────────────────────────────────────────────────
@router.put("/api/projects/{project_id}/stages/order")
async def api_reorder_stages(
def api_reorder_stages(
request: Request, project_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
user = _require_user(request)
@@ -1414,13 +1538,14 @@ async def api_reorder_stages(
@router.put("/api/projects/{project_id}/stages/{stage_id}/tasks/order")
async def api_reorder_tasks(
def api_reorder_tasks(
request: Request, project_id: int, stage_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
"""보드에서 카드를 같은 세션 안에서 드래그로 재정렬."""
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
_stage_of_project(st, stage_id, project_id)
ids = payload.get("ordered_ids") or []
if not isinstance(ids, list) or not ids:
raise HTTPException(status_code=400, detail="ordered_ids 가 필요합니다.")
@@ -1429,12 +1554,13 @@ async def api_reorder_tasks(
@router.put("/api/projects/{project_id}/stages/{stage_id}")
async def api_update_stage(
def api_update_stage(
request: Request, project_id: int, stage_id: int, payload: dict[str, Any] = Body(...)
) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
_require_manage(request, st, user, project_id)
_stage_of_project(st, stage_id, project_id)
try:
stage = st.update_stage(
stage_id=stage_id,
@@ -1453,7 +1579,7 @@ async def api_update_stage(
# 알림센터 (인앱)
# ────────────────────────────────────────────────────────────
@router.get("/api/notifications")
async def api_notifications(request: Request) -> JSONResponse:
def api_notifications(request: Request) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
unread_only = request.query_params.get("unread") in ("1", "true")
@@ -1464,14 +1590,14 @@ async def api_notifications(request: Request) -> JSONResponse:
@router.get("/api/notifications/unread-count")
async def api_notif_count(request: Request) -> JSONResponse:
def api_notif_count(request: Request) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
return JSONResponse({"unread": st.count_unread(recipient_email=user["email"])})
@router.post("/api/notifications/{notification_id}/read")
async def api_notif_read(request: Request, notification_id: int) -> JSONResponse:
def api_notif_read(request: Request, notification_id: int) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
st.mark_read(notification_id=notification_id, recipient_email=user["email"])
@@ -1479,7 +1605,7 @@ async def api_notif_read(request: Request, notification_id: int) -> JSONResponse
@router.post("/api/notifications/read-all")
async def api_notif_read_all(request: Request) -> JSONResponse:
def api_notif_read_all(request: Request) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
n = st.mark_all_read(recipient_email=user["email"])
@@ -1506,7 +1632,7 @@ def _safe_mention_unread(st: Any, email: str) -> int:
@router.get("/api/mentions")
async def api_mentions(request: Request) -> JSONResponse:
def api_mentions(request: Request) -> JSONResponse:
"""나를 태그한 업무 목록 + 미확인 개수."""
user = _require_user(request)
st = _db_or_503(request)
@@ -1518,14 +1644,14 @@ async def api_mentions(request: Request) -> JSONResponse:
@router.get("/api/mentions/unread-count")
async def api_mentions_unread(request: Request) -> JSONResponse:
def api_mentions_unread(request: Request) -> JSONResponse:
user = _require_user(request)
st = _db_or_503(request)
return JSONResponse({"unread": _safe_mention_unread(st, user["email"])})
@router.post("/api/mentions/read")
async def api_mentions_read(
def api_mentions_read(
request: Request, payload: dict[str, Any] = Body(default={})
) -> JSONResponse:
"""태그 확인 처리. task_id 를 주면 그 업무만, 없으면 전부."""
@@ -1543,7 +1669,7 @@ async def api_mentions_read(
@router.get("/inbox", response_class=HTMLResponse)
async def inbox_page(request: Request) -> HTMLResponse:
def inbox_page(request: Request) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
@@ -1558,10 +1684,7 @@ async def inbox_page(request: Request) -> HTMLResponse:
t["due_label"] = _fmt_date_kr(t.get("due_date"))
# 좌측 사이드바(project/_side.html)는 세 화면 공용 — 같은 데이터가 필요하다.
nav_projects = _nav_projects(st, user, admin)
my_open_total = sum(
1 for t in st.list_tasks(assignee_email=user["email"], limit=1000)
if not t.get("completed_at")
)
my_open_total = st.count_my_open(assignee_email=user["email"])
return render_template(
request,
"project/inbox.html",
+39 -5
View File
@@ -6,6 +6,7 @@ DB 없이 단위 테스트 가능한 순수 함수만 둔다(malaysia.store 패
from __future__ import annotations
import re
from html.parser import HTMLParser
from typing import Any
@@ -270,7 +271,24 @@ _DESC_ALLOWED_ATTRS: dict[str, frozenset[str]] = {
"img": frozenset({"src", "alt", "width", "height"}),
"span": frozenset({"class", "data-email"}),
}
_DESC_DANGEROUS_URL_PREFIXES: tuple[str, ...] = ("javascript:", "vbscript:", "data:text/html")
# 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"
# script/style 은 태그 자체는 물론 그 안의 텍스트(코드)도 통째로 버린다 —
@@ -287,9 +305,23 @@ def _desc_escape_attr(value: str) -> str:
return _desc_escape_text(value).replace('"', "&quot;")
def _desc_url_is_safe(value: str) -> bool:
v = value.strip().lower()
return not any(v.startswith(prefix) for prefix in _DESC_DANGEROUS_URL_PREFIXES)
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):
@@ -317,7 +349,9 @@ class _DescriptionSanitizer(HTMLParser):
if name not in allowed:
continue
value = value or ""
if name in ("href", "src") and not _desc_url_is_safe(value):
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 는 멘션 칩 하나만 허용한다(임의 클래스로 화면 스타일을
# 흔들 여지를 남기지 않는다).
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260923a" />
<link rel="stylesheet" href="/static/project.css?v=20260923b" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -93,5 +93,5 @@
</div>
</div>
<script src="/static/project.js?v=20260923a" defer></script>
<script src="/static/project.js?v=20260923b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260923a" />
<link rel="stylesheet" href="/static/project.css?v=20260923b" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -97,5 +97,5 @@
"today": {{ today | tojson }}
}
</script>
<script src="/static/project.js?v=20260923a" defer></script>
<script src="/static/project.js?v=20260923b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260923a" />
<link rel="stylesheet" href="/static/project.css?v=20260923b" />
<!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host -->
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<!-- 타임라인 vis-timeline — self-host -->
@@ -463,5 +463,5 @@
</script>
<script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script>
<script src="/static/project.js?v=20260923a" defer></script>
<script src="/static/project.js?v=20260923b" defer></script>
{% endblock %}
+70 -28
View File
@@ -1202,8 +1202,8 @@
const badge = el("pj-myopen-badge");
if (!badge) return;
try {
const res = await api("GET", "/project/api/my-tasks");
const n = (res.tasks || []).filter(function (t) { return !t.completed_at; }).length;
// 숫자만 받는다(예전엔 내 업무 목록 전체를 받아 세었다).
const n = (await api("GET", "/project/api/my-tasks/open-count")).open || 0;
badge.textContent = n;
badge.hidden = n === 0;
} catch (_) {}
@@ -2620,10 +2620,34 @@
root.appendChild(charts);
}
function mergeTask(task) {
const i = tasks.findIndex(function (x) { return x.id === task.id; });
if (i >= 0) tasks[i] = Object.assign({}, tasks[i], task);
else tasks.push(task);
// 서버가 돌려준 업무를 로컬 목록에 반영. 멀티호밍된 업무는 목록에 여러 행
// (원래 소속 맥락 + 연결된 프로젝트 맥락)으로 들어 있으므로 같은 id 의 행을
// 전부 고친다. 단 "어느 맥락의 세션인지"에 해당하는 필드는 행마다 다르다 —
// 서버 응답(get_task)의 stage_id 는 항상 원래 소속 세션이라, 연결 맥락 행에
// 덮어쓰면 그 카드가 연결된 프로젝트 보드에서 사라졌다.
const CONTEXT_FIELDS = ["stage_id", "stage_name", "is_done_stage", "is_linked", "context_project_id"];
// opts.noInsert — 같은 id 행만 고치고 없으면 추가하지 않는다(동기화용).
function mergeTask(task, opts) {
const base = Object.assign({}, task);
if (task.home_stage_id === undefined && task.stage_id !== undefined) base.home_stage_id = task.stage_id;
// 들어온 값 자체가 연결 맥락 행이면(스냅샷) 그 세션 값은 다른 행에 못 쓴다.
const srcLinked = task.context_project_id != null && task.context_project_id !== task.project_id;
let found = false;
tasks.forEach(function (x, i) {
if (x.id !== task.id) return;
found = true;
const patch = Object.assign({}, base);
const linkedRow = x.context_project_id != null && x.context_project_id !== x.project_id;
if (linkedRow || srcLinked) CONTEXT_FIELDS.forEach(function (k) { delete patch[k]; });
delete patch.context_project_id; // 행의 맥락은 그대로
tasks[i] = Object.assign({}, x, patch);
});
if (!found && !(opts && opts.noInsert)) {
// 방금 만든 업무 — 맥락이 없으면 visibleTasks() 필터에 걸려 다음
// 동기화 때까지 화면에 안 나왔다. 원래 소속 맥락으로 넣는다.
if (base.context_project_id == null) base.context_project_id = base.project_id;
tasks.push(base);
}
}
// 같은 세션 안 카드 드래그 재정렬 — tasks 배열은 여러 세션이 뒤섞인
@@ -2820,7 +2844,13 @@
if (descEditor) { descEditor.setTaskId(task ? task.id : null); descEditor.setHtml(task ? (task.description || "") : ""); }
fillAssigneeSelect(task ? task.project_id : projectId, task ? (task.assignee_email || "") : "");
fillStageSelect(task ? task.project_id : projectId);
el("pj-t-stage").value = task && task.stage_id ? task.stage_id
// "세션" 선택칸은 원래 소속 프로젝트의 세션 목록이다. 다른 프로젝트에서
// 연결돼 온 행은 stage_id 가 연결된 쪽 세션이라 목록에 없다 — 그대로 넣으면
// 선택이 비고, 저장 시 원래 세션이 지워졌다. 그래서 home_stage_id 를 쓴다.
const homeStage = task
? (task.home_stage_id !== undefined ? task.home_stage_id : task.stage_id)
: null;
el("pj-t-stage").value = task ? (homeStage || "")
: (presetStageId != null ? presetStageId : (stages[0] ? stages[0].id : ""));
el("pj-t-priority").value = task ? (task.priority || "normal") : "normal";
el("pj-t-due").value = task ? (task.due_date || "") : "";
@@ -3006,7 +3036,6 @@
description: descEditor ? descEditor.getHtml() : "",
assignee_email: assigneeSel.value,
assignee_name: assigneeName,
stage_id: parseInt(el("pj-t-stage").value, 10) || null,
priority: el("pj-t-priority").value,
due_date: el("pj-t-due").value || null,
// 시작일/시간은 이 폼에서 더 이상 편집하지 않는다 — 원래 값을
@@ -3015,6 +3044,10 @@
start_time: currentTaskData ? (currentTaskData.start_time || null) : null,
due_time: currentTaskData ? (currentTaskData.due_time || null) : null,
};
// 세션이 선택돼 있을 때만 보낸다 — 빈 값(세션 없는 업무 등)을 null 로
// 보내면 서버가 세션을 지우고 완료 상태까지 풀어버린다.
const stageVal = parseInt(el("pj-t-stage").value, 10);
if (stageVal) payload.stage_id = stageVal;
if (!payload.title) { alert("제목을 입력하세요."); return; }
try {
let res;
@@ -3505,28 +3538,23 @@
}
// 8초 주기 실시간 동기화(initLiveRefresh)가 전체 새로고침 대신 부를 함수 —
// 이 프로젝트의 업무·세션·멤버만 재조회해 로컬 상태에 patch(입력 중인
// 모달 폼은 건드리지 않는다). "전체 프로젝트" 스코프에 걸린 다른
// 프로젝트의 변경이나 세션 이름변경/재정렬/삭제·멤버 제외·댓글 수정/삭제는
// live-version 자체가 감지 못하는 기존 사각지대 — 다음 새로고침까지 반영 안 됨.
// 이 프로젝트의 업무·세션·멤버를 요청 한 번(/snapshot)으로 받아 로컬 상태를
// 고친다(입력 중인 모달 폼은 건드리지 않는다). 이 프로젝트 맥락의 행은
// 통째로 바꿔 끼워 삭제된 업무도 사라지게 한다(live-version 이 007
// 마이그레이션부터 삭제·세션 변경까지 감지한다). "전체 프로젝트" 스코프의
// 다른 프로젝트 행은 공통 필드(제목·담당자·완료 등)만 따라 고친다.
softSyncProjectRef = async function () {
try {
const [tRes, sRes, mRes] = await Promise.all([
api("GET", "/project/api/projects/" + projectId + "/tasks"),
api("GET", "/project/api/projects/" + projectId + "/stages"),
api("GET", "/project/api/projects/" + projectId + "/members"),
]);
// 서버 페이지 렌더 시엔 router.py 가 각 업무에 context_project_id(=지금
// 보는 프로젝트 id)를 붙여준다(멀티호밍 스코프 필터의 기준) — 이 API
// 응답엔 그 필드가 없으므로 직접 붙여야 visibleTasks() 필터에서
// 안 사라진다.
(tRes.tasks || []).forEach(function (t) {
t.context_project_id = projectId;
mergeTask(t);
const snap = await api("GET", "/project/api/projects/" + projectId + "/snapshot");
const fresh = snap.tasks || [];
tasks = tasks.filter(function (t) { return t.context_project_id !== projectId; });
fresh.forEach(function (t) {
mergeTask(t, { noInsert: true }); // 다른 맥락 행(같은 id)의 공통 필드 갱신
tasks.push(t); // 이 맥락 행은 서버 값 그대로(context_project_id 포함)
});
stages = sRes.stages || [];
stages = snap.stages || [];
stagesByProject[projectId] = stages;
members = mRes.members || [];
members = snap.members || [];
renderMemberList();
refreshActiveView();
refreshMyOpenBadge();
@@ -4133,8 +4161,13 @@
let softSyncProjectRef = null;
function initLiveRefresh() {
if (!document.querySelector(".pj-wrap, .pj-project-view")) return;
// 탭이 안 보이는 동안(다른 탭/최소화)은 묻지 않는다 — 열어둔 탭 수만큼
// 서버에 헛요청이 쌓였다. 다시 보이면 바로 한 번 확인한다.
let baseline = null;
let timer = null;
async function poll() {
timer = null;
if (document.hidden) return;
try {
const res = await fetch("/project/api/live-version");
if (res.ok) {
@@ -4149,9 +4182,18 @@
}
}
} catch (_) {}
setTimeout(poll, 8000);
if (!timer && !document.hidden) timer = setTimeout(poll, 8000);
}
setTimeout(poll, 8000);
document.addEventListener("visibilitychange", function () {
if (document.hidden) {
if (timer) { clearTimeout(timer); timer = null; }
} else if (!timer) {
poll();
}
});
// 기준값은 바로 잡는다 — 예전엔 첫 확인이 8초 뒤라, 화면을 연 직후 8초
// 사이에 생긴 변경은 기준값에 묻혀 반영되지 않았다.
poll();
}
// ── 항상 보이는 스크롤 막대 ──
+28 -3
View File
@@ -14,6 +14,8 @@
| 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) |
| 생성 권한 | **프로젝트·세션·업무(하위 업무 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. |
| 수정/이동 권한 | 서브프로젝트·업무·세션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 admin(`_require_manage`) |
| 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/세션/업무/활동/스냅샷 API 도 멤버·owner·admin 만(`_require_manage`). 비멤버는 403. `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 업무만 돌려준다 |
| 입력 검증 | URL 의 세션이 URL 의 프로젝트 것인지(`_stage_of_project`), 업무 생성/수정·연결 시 세션이 그 프로젝트 것인지(`stage_in_project`), 하위 업무의 부모가 같은 프로젝트인지 확인 — 권한은 URL 의 project_id 로 보므로 이걸 안 보면 남의 프로젝트를 건드릴 수 있다 |
| 삭제 권한 | **프로젝트·세션·업무 모두 "만든 사람만"**(슈퍼관리자 예외, 생성자 정보 없는 과거 데이터는 admin 허용) — `_can_delete` 하나로 통일 |
| 멤버 배정 | 여전히 관리자(`is_admin`) 전용. 비관리자가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) |
| 메일 알림 | `app/mail.py` (stdlib smtplib). 업무 배정/완료 시 관리자에게 발송 |
@@ -138,20 +140,21 @@ docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" \
# PROJECT_DB_URL=postgresql://project_app:<APP_PWD>@postgres-db:5432/project_db
# (메일 쓰려면 SMTP_* 추가)
# 3) 마이그레이션 002~006 적용 (첨부/알림, 세션 생성자·하위업무·멀티호밍,
# 3) 마이그레이션 002~007 적용 (첨부/알림, 세션 생성자·하위업무·멀티호밍,
# 업무 시간, 세션 색상, 댓글 첨부, @태그)
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_002_attachments_notifications.sql
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_003_sections_subtasks_links.sql
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_003_task_times.sql
< scripts/sql/project_db_003b_task_times.sql
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_004_stage_color.sql
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_005_comment_attachments.sql
docker exec -i postgres-db psql -U postgres -d project_db \
< scripts/sql/project_db_006_mentions.sql
docker exec -i postgres-db psql -U postgres -d project_db < scripts/sql/project_db_007_live_version.sql
# 4) 재배포 (git pull 후 반드시 --build)
cd /opt/www/main && docker compose up -d --build web
@@ -203,7 +206,7 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
- **댓글** `task_comments` — 업무 모달 하단. 등록/삭제(본인·관리자). 새 댓글 시 관련자 인앱 알림.
- **업무 편집 팝업** — 버튼 줄(공유·완료·삭제·취소·저장)은 **팝업 맨 위에 고정**
(`.pj-modal-actions-top`, sticky) — 설명/하위업무가 길어도 스크롤 없이 저장·취소한다.
(`.pj-modal-actions-top`) — 카드가 flex column 이고 `.pj-modal-body` 만 스크롤하므로 sticky 없이 고정된다(sticky 는 카드 padding 안쪽에 붙어 바가 밀려 내려오고 제목을 덮었다). 설명/하위업무가 길어도 스크롤 없이 저장·취소한다.
그 아래 윗줄은 메타(좌) + 첨부/연결/댓글(우) 2단, 다시 그 아래 **설명란**과
**하위 업무**가 각각 팝업 너비 전체를 쓰는 별도 행(`.pj-desc-block` / `.pj-subtask-full`,
그리드 `1 / -1`). 하위 업무는 제목 왼쪽 체크박스로 완료를 토글하고, 완료된 줄은
@@ -213,6 +216,28 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
- **알림센터(인앱)** `project_notifications` — 배정/완료/댓글 시 수신자별 알림 생성. 우측 상단 벨(미읽음 배지) → `/project/inbox`. 항목 클릭=읽음, "모두 읽음". 본인 행동은 알림 제외.
- 마이그레이션: `scripts/sql/project_db_002_attachments_notifications.sql` (첨부·알림 테이블 + 권한), `scripts/sql/project_db_003_sections_subtasks_links.sql` (세션 생성자·하위업무·멀티호밍).
## 6-1. 실시간 반영 · 성능
- **live-version** — `GET /api/live-version` 이 돌려주는 값이 바뀌면 화면이 조용히 다시 받는다.
007 마이그레이션의 문장 단위 트리거가 projects·members·stages·tasks·comments·attachments·
links(+ mentions INSERT) 변경 때마다 `project_live_version.version` 을 1 올린다 — 삭제·세션
이름변경·첨부 추가까지 감지되고, 서버는 PK 한 줄만 읽는다. 007 미적용이면 예전 MAX() 방식
(삭제 감지 못함)으로 자동 폴백하고 5분마다 다시 확인한다.
- 화면은 열자마자 기준값을 잡고, 탭이 안 보이는 동안(`document.hidden`)은 묻지 않는다.
바뀌면 `GET /api/projects/{id}/snapshot`(업무+세션+멤버 한 번에)으로 이 프로젝트 맥락의
행을 통째로 바꿔 끼운다(삭제된 업무도 사라짐).
- 프로젝트 화면은 접근 가능한 모든 프로젝트의 업무/세션을 각각 **쿼리 한 번**으로 읽는다
(`list_tasks_for_projects`, `list_stages_for_projects`). 행마다 `context_project_id`·
`is_linked`·`home_stage_id` 가 붙는다 — 연결 업무 행의 `stage_id` 는 연결된 쪽 세션이고,
업무 편집 팝업의 "세션" 선택은 항상 `home_stage_id`(원래 소속)를 쓴다.
- 라우터 핸들러는 전부 `def`(sync) — DB 드라이버가 동기라 `async def` 면 쿼리 동안 이벤트
루프 전체가 멈춘다. 첨부 업로드는 한도+1 바이트까지만 읽는다.
- 첨부 `/inline` 은 png/jpeg/gif/webp/bmp 만 화면에 띄우고 나머지(html·svg 등)는 다운로드로
내려준다(`X-Content-Type-Options: nosniff` + CSP sandbox). 업무/프로젝트/댓글 삭제 시
디스크 첨부도 같이 지운다.
- 설명란 sanitizer 는 URL 을 허용 목록(http/https/mailto/tel/상대경로, img 는 png·jpeg 등
data: 이미지)으로 검사한다 — 금지 목록은 `jav&#x09;ascript:` 로 우회됐다.
## 7. 추후 단계
검색/필터 · 업무 라벨(태그 분류) · 하위 업무의 하위 업무(다단계 중첩,
@@ -1,11 +1,13 @@
-- =====================================================================
-- project_db 마이그레이션 003 — 업무 시작/마감 시간(TIME) 추가
-- project_db 마이그레이션 003b — 업무 시작/마감 시간(TIME) 추가
-- =====================================================================
-- 멱등. NULL = 시간 미지정(종일). DROP 없음.
-- (예전 파일명 project_db_003_task_times.sql — 같은 003 번호가 둘이라 003b 로 바꿨다.
-- 이미 적용한 서버는 다시 돌릴 필요 없다. 여러 번 돌려도 안전.)
--
-- 실행:
-- docker exec -i postgres-db psql -U postgres -d project_db \
-- < scripts/sql/project_db_003_task_times.sql
-- < scripts/sql/project_db_003b_task_times.sql
-- =====================================================================
\set ON_ERROR_STOP on
@@ -0,0 +1,58 @@
-- project_db 007 — 실시간 새로고침용 변경 카운터
--
-- 예전 /project/api/live-version 은 6개 테이블의 MAX(updated_at/created_at) 을
-- 매번 구했다. 인덱스가 없어 열어둔 화면마다 8초에 한 번씩 풀스캔했고,
-- 삭제·세션 이름변경·첨부 추가처럼 "최근 시각"이 안 바뀌는 변경은 감지하지 못했다.
--
-- 이제 관련 테이블에 문장(statement) 단위 트리거를 걸어, 무엇이든 바뀌면 한 줄짜리
-- 카운터(project_live_version.version)를 1 올린다. 앱은 PK 한 줄만 읽는다.
-- 알림 읽음 처리처럼 개인 상태만 바뀌는 project_notifications 는 제외하고,
-- task_mentions 는 새로 태그될 때(INSERT)만 올린다(읽음 처리 UPDATE 제외).
--
-- 적용 (superuser, 1회 — 여러 번 돌려도 안전):
-- docker exec -i postgres-db psql -U postgres -d project_db \
-- < scripts/sql/project_db_007_live_version.sql
--
-- 미적용 환경에서는 앱이 예전 MAX() 방식으로 자동 폴백한다.
\set ON_ERROR_STOP on
\connect project_db
CREATE TABLE IF NOT EXISTS project_live_version (
id SMALLINT PRIMARY KEY DEFAULT 1 CHECK (id = 1),
version BIGINT NOT NULL DEFAULT 0,
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
INSERT INTO project_live_version (id) VALUES (1) ON CONFLICT (id) DO NOTHING;
CREATE OR REPLACE FUNCTION project_bump_live_version() RETURNS trigger AS $$
BEGIN
UPDATE project_live_version SET version = version + 1, updated_at = now() WHERE id = 1;
RETURN NULL;
END;
$$ LANGUAGE plpgsql;
DO $$
DECLARE
tbl TEXT;
BEGIN
FOREACH tbl IN ARRAY ARRAY[
'projects', 'project_members', 'project_stages', 'tasks',
'task_comments', 'task_attachments', 'task_project_links'
] LOOP
EXECUTE format('DROP TRIGGER IF EXISTS trg_%s_live_version ON %I', tbl, tbl);
EXECUTE format(
'CREATE TRIGGER trg_%s_live_version AFTER INSERT OR UPDATE OR DELETE ON %I '
'FOR EACH STATEMENT EXECUTE FUNCTION project_bump_live_version()', tbl, tbl);
END LOOP;
END $$;
DROP TRIGGER IF EXISTS trg_task_mentions_live_version ON task_mentions;
CREATE TRIGGER trg_task_mentions_live_version
AFTER INSERT ON task_mentions
FOR EACH STATEMENT EXECUTE FUNCTION project_bump_live_version();
-- 트리거는 실행한 계정(project_app) 권한으로 돈다 → UPDATE 권한 필요.
GRANT SELECT, UPDATE ON project_live_version TO project_app;
SELECT 'project_db 007 live_version ready' AS status;