3 Commits

Author SHA1 Message Date
king 81b1204693 fix(project): 권한 우회·작업 혼선·저장 유실 등 16개 항목 수정 — 지금 권한 기준·읽기 전용 연결 작업·원자적 파일 댓글
권한(서버)
- 공통 권한 모듈 access.py: 모든 판단을 "지금" 권한으로 — 내 작업·수신함·알림·멘션·검색·상세·공유 링크·
  댓글·첨부·알림/메일 수신자에서 권한을 잃은 사람 제외(기록은 이력으로 보존)
- 소유자 변경·남을 소유자로 지정한 생성은 관리자만, 새 소유자는 권한 있는 등록 사용자
- 삭제는 생성자 규칙 + 지금 권한(멤버에서 빠진 생성자 거절), 댓글 수정·삭제도 지금 권한
- @태그는 볼 수 있는 사람만(mention_skipped), 태그 후보 all-users?task_id=, 새 담당자 권한 검사
- 연결(멀티호밍) 작업은 연결된 프로젝트 멤버에게 읽기 전용(task_link_scope), 볼 수 없는 연결 프로젝트 숨김

저장·동기화(화면)
- 작업 창 세대(taskGen)·블록 ctxSeq 로 늦은 A 응답이 B 를 덮지 않게(A→B, A→B→A, 이미지 업로드 중 전환)
- 자동 저장 성공/실패 반환, 실패 칸 재시도, 닫기·전환 전 저장 확인(버리기/계속 편집), 미저장 이탈 경고
- 실시간 동기화 observed/applied 분리·실패 재시도·겹침 방지, snapshot?scope=all 로 전체 범위 반영·권한 회수 안내
- 한국시간 기준 오늘(kstTodayIso), 한글 조합 중 Enter 는 제출하지 않음, 댓글 연타·재전송 중복 방지(client_token)

기타
- 파일 댓글은 본문+파일 한 트랜잭션(POST /comments/files), 실패 파일 표시·유지, 작업 창 댓글에 첨부 표시
- 날짜 범위 검증(부분 수정은 최종 상태), 완료 섹션에 바로 만든 작업 완료 처리·알림
- 마감 알림 발송 기록+수신함 알림 원자적(실패 시 재시도), 권한 없는 수신자 제외
- 테스트: tests/test_project_module.py(로컬 PostgreSQL 11개), tests/js/project_ui.test.js(jsdom 51개)
- 문서(PROJECT_MODULE 6-10·도움말·CLAUDE.md), project.js/css 캐시 버전 20260930g, 새 마이그레이션·환경변수 없음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 16:46:11 +09:00
king ae2e3eb943 Merge branch 'feat/performance' into feat/project — 매출 업데이트 취소 2026-09-30 15:06:47 +09:00
king da63b93302 feat(performance): 매출 업데이트 취소 버튼
- 진행 창 [업데이트 취소](시작한 사람·관리자) → POST /api/sync/jobs/{id}/cancel
- 어댑터가 API 호출 직전마다 ctx.progress.check() — 취소면 Cancelled 로 멈추고 저장하지 않음(기존 매출 그대로),
  차례가 안 온 쇼핑몰은 취소됨으로 건너뜀, 이미 끝난 쇼핑몰 결과는 유지
- 취소 실행은 perf_sync_runs failed + 업데이트 취소, 연결 상태는 바꾸지 않음
- 테스트 1개 추가(30개 통과), performance.js/css 캐시 버전, 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 15:06:25 +09:00
32 changed files with 2746 additions and 371 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/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` - 말레이시아 배송 (`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/{no}/images` 에 base64 data URI + `image_upload_type=A` — NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페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` - 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력. 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널). 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지(`POST /admin/products/{no}/images` 에 base64 data URI + `image_upload_type=A` — NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페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)·프로젝트 색상(32색 — 아사나 16색 + 진한 16색)·아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011)·작업(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed, 섹션 기본 담당자 `default_assignee_email` — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정, 마이그레이션 009)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글. 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다. 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 작업(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 작업이 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/작업/단계 CRUD — URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터). 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만. 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, 관리자만 보기·복구(`/project/trash`). 연간 목표(마이그레이션 013, `goal_*` 테이블) — 사이드바 "목표" → 연도 펼침 → `/project/goals/{연도}` 에 매출(목표·실적·달성)·로아스 월별 숫자 + 업무 영역(상품·마케팅·컨텐츠·유통 등)별 연간·월별 글, 조회는 전원·입력은 `is_admin` 만. 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008. 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성). 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503), 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외), 댓글 `@아이디` 는 아이콘+이름 칩. 수신함 "확인"은 페이지 이동 없이 오른쪽 iframe 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`). 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남). 상세는 `docs/PROJECT_MODULE.md` - 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·프로젝트 색상(32색 — 아사나 16색 + 진한 16색)·아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011)·작업(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed, 섹션 기본 담당자 `default_assignee_email` — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정, 마이그레이션 009)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글. 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다. 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 작업(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 작업이 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/작업/단계 CRUD — URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터). 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만. 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, 관리자만 보기·복구(`/project/trash`). 권한은 **지금 기준 공통 모듈 `access.py`**(목록·배지·알림·멘션·메일 수신자·삭제·댓글 수정까지 — 멤버에서 빠지면 기록이 있어도 안 보이고 알림도 없음), 소유자 변경은 관리자만, 연결(멀티호밍)된 작업은 연결된 프로젝트 멤버에게 읽기 전용(docs/PROJECT_MODULE.md 6-10). 연간 목표(마이그레이션 013, `goal_*` 테이블) — 사이드바 "목표" → 연도 펼침 → `/project/goals/{연도}` 에 매출(목표·실적·달성)·로아스 월별 숫자 + 업무 영역(상품·마케팅·컨텐츠·유통 등)별 연간·월별 글, 조회는 전원·입력은 `is_admin` 만. 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008. 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성). 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503), 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외), 댓글 `@아이디` 는 아이콘+이름 칩. 수신함 "확인"은 페이지 이동 없이 오른쪽 iframe 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`). 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남). 상세는 `docs/PROJECT_MODULE.md`
- 실적 (`app/modules/performance/`, `performance_db`) — 쇼핑몰 통합 매출. 네 영역 분리: ① 수집 `adapters/`(쇼핑몰 하나 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄) + `sync.py`(공통 동기화, 같은 쇼핑몰 동시 실행 차단, 쇼핑몰별 실패 격리) ② 보안 `security/`(AES-256-GCM, 키 버전, 비밀값 가리기) + `credentials.py` ③ 계산 `calc.py`(주=월~일, 수수료 반올림은 `commission()` 한 곳, 요율 이력) + `db.py` ④ 화면 `dashboard.py`/`router.py`/템플릿. 쇼핑몰 API 인증정보는 `.env` 가 아니라 **설정 화면에서 입력 → 마스터 키 `APP_ENCRYPTION_KEY` 로 암호화해 DB 저장**, secret 원문은 화면으로 다시 보내지 않는다. 쇼핑몰 API 는 백엔드에서만 호출, 오류·로그·raw 는 `redact` 후 저장. 매출 기준일: 결제=결제일, 취소·반품=발생일(`sync.sales_date_for`). 금액은 원 단위 정수. 권한키 `performance`, 설정 화면·API 는 `is_admin`. 카페24 어댑터는 기존 `app/integrations/cafe24` 토큰 재사용. 1단계는 모의 데이터(`is_sample`)·구조까지, 실제 수집은 쇼핑몰별로 공식 문서 확인 후 순차 구현. 상세는 `docs/PERFORMANCE_MODULE.md` - 실적 (`app/modules/performance/`, `performance_db`) — 쇼핑몰 통합 매출. 네 영역 분리: ① 수집 `adapters/`(쇼핑몰 하나 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄) + `sync.py`(공통 동기화, 같은 쇼핑몰 동시 실행 차단, 쇼핑몰별 실패 격리) ② 보안 `security/`(AES-256-GCM, 키 버전, 비밀값 가리기) + `credentials.py` ③ 계산 `calc.py`(주=월~일, 수수료 반올림은 `commission()` 한 곳, 요율 이력) + `db.py` ④ 화면 `dashboard.py`/`router.py`/템플릿. 쇼핑몰 API 인증정보는 `.env` 가 아니라 **설정 화면에서 입력 → 마스터 키 `APP_ENCRYPTION_KEY` 로 암호화해 DB 저장**, secret 원문은 화면으로 다시 보내지 않는다. 쇼핑몰 API 는 백엔드에서만 호출, 오류·로그·raw 는 `redact` 후 저장. 매출 기준일: 결제=결제일, 취소·반품=발생일(`sync.sales_date_for`). 금액은 원 단위 정수. 권한키 `performance`, 설정 화면·API 는 `is_admin`. 카페24 어댑터는 기존 `app/integrations/cafe24` 토큰 재사용. 1단계는 모의 데이터(`is_sample`)·구조까지, 실제 수집은 쇼핑몰별로 공식 문서 확인 후 순차 구현. 상세는 `docs/PERFORMANCE_MODULE.md`
+11 -1
View File
@@ -32,6 +32,7 @@ STATUS_LABELS: dict[str, str] = {
"not_implemented": "연동 준비 중", "not_implemented": "연동 준비 중",
"unknown": "확인 전", "unknown": "확인 전",
"disabled": "사용 중지", # DB 에는 저장하지 않는 화면 전용 상태(쇼핑몰 사용 OFF) "disabled": "사용 중지", # DB 에는 저장하지 않는 화면 전용 상태(쇼핑몰 사용 OFF)
"cancelled": "취소됨", # 화면 전용 — 매출 업데이트 창에서 [업데이트 취소](연결 상태는 바꾸지 않음)
} }
EVENT_TYPES = ("SALE", "CANCEL", "RETURN", "ADJUST") EVENT_TYPES = ("SALE", "CANCEL", "RETURN", "ADJUST")
@@ -68,6 +69,11 @@ class NotImplementedYet(AdapterError):
status = "not_implemented" status = "not_implemented"
class Cancelled(AdapterError):
"""사용자가 매출 업데이트를 취소함 — 어댑터가 ctx.progress.check() 에서 받는다. 연결 오류가 아니다."""
status = "cancelled"
# ════════════════════════════════════════════════════════════ # ════════════════════════════════════════════════════════════
# 설정 입력칸 · 공통 매출 사건 # 설정 입력칸 · 공통 매출 사건
# ════════════════════════════════════════════════════════════ # ════════════════════════════════════════════════════════════
@@ -135,7 +141,8 @@ class Progress:
객체(jobs.ShopProgress)로 바꿔 넣는다. 객체(jobs.ShopProgress)로 바꿔 넣는다.
어댑터: 조회를 시작하기 전에 plan(전체 단계 수, 단위) → 단계 하나(하루·조회 구간)를 끝낼 때마다 어댑터: 조회를 시작하기 전에 plan(전체 단계 수, 단위) → 단계 하나(하루·조회 구간)를 끝낼 때마다
step(items=그 단계에서 받은 건수). 하다가 할 일이 늘면 add(늘어난 단계 수).""" step(items=그 단계에서 받은 건수). 하다가 할 일이 늘면 add(늘어난 단계 수).
API 를 부르기 직전마다 check() — 사용자가 [업데이트 취소]를 눌렀으면 Cancelled 를 던져 거기서 멈춘다."""
def plan(self, total: int, unit: str = "단계") -> None: def plan(self, total: int, unit: str = "단계") -> None:
return None return None
@@ -146,6 +153,9 @@ class Progress:
def step(self, n: int = 1, *, items: int = 0) -> None: def step(self, n: int = 1, *, items: int = 0) -> None:
return None return None
def check(self) -> None:
return None
@dataclass @dataclass
class AdapterContext: class AdapterContext:
@@ -291,6 +291,7 @@ class Cafe24Adapter(MarketplaceAdapter):
if offset > MAX_OFFSET: if offset > MAX_OFFSET:
raise ApiError(f"카페24 조회 건수가 너무 많습니다({params.get('start_date')}~{params.get('end_date')}). " raise ApiError(f"카페24 조회 건수가 너무 많습니다({params.get('start_date')}~{params.get('end_date')}). "
"기간을 줄여 다시 시도하세요.") "기간을 줄여 다시 시도하세요.")
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
rows = self._get(ctx, path, {**params, "limit": limit, "offset": offset}).get(key) or [] rows = self._get(ctx, path, {**params, "limit": limit, "offset": offset}).get(key) or []
yield from rows yield from rows
if len(rows) < limit: if len(rows) < limit:
@@ -270,6 +270,7 @@ class ElevenstAdapter(MarketplaceAdapter):
def _get(self, ctx: AdapterContext, path: str) -> bytes: def _get(self, ctx: AdapterContext, path: str) -> bytes:
import httpx # 지연 import import httpx # 지연 import
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
headers = {"openapikey": ctx.credentials.get("api_key").strip(), "Accept": "application/xml"} headers = {"openapikey": ctx.credentials.get("api_key").strip(), "Accept": "application/xml"}
try: try:
res = httpx.get(f"{HOST}{path}", headers=headers, timeout=ctx.timeout_sec) res = httpx.get(f"{HOST}{path}", headers=headers, timeout=ctx.timeout_sec)
@@ -166,6 +166,7 @@ class GsshopAdapter(MarketplaceAdapter):
from app.timezone import now_kst # noqa: WPS433 from app.timezone import now_kst # noqa: WPS433
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
sup, key = self._creds(ctx) sup, key = self._creds(ctx)
key_bytes = dict(key_variants(key))[how[0]] key_bytes = dict(key_variants(key))[how[0]]
headers = {"supCd": sup, "token": make_token(key_bytes, sup, now_kst(), how[1]), "Accept": "application/json"} headers = {"supCd": sup, "token": make_token(key_bytes, sup, now_kst(), how[1]), "Accept": "application/json"}
@@ -298,6 +298,7 @@ class NaverAdapter(MarketplaceAdapter):
retried_auth = False retried_auth = False
for attempt in range(RETRY_429 + 1): for attempt in range(RETRY_429 + 1):
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
wait = CALL_INTERVAL_SEC - (time.monotonic() - self._last_call) wait = CALL_INTERVAL_SEC - (time.monotonic() - self._last_call)
if wait > 0: if wait > 0:
time.sleep(wait) time.sleep(wait)
+35 -8
View File
@@ -6,6 +6,9 @@
네이버 "일", 11번가·카페24 "구간"). 네이버 "일", 11번가·카페24 "구간").
- 웹 프로세스 하나(uvicorn 단일 워커) 기준 — 워커를 여러 개로 늘리면 진행 상황을 DB 로 옮겨야 한다. - 웹 프로세스 하나(uvicorn 단일 워커) 기준 — 워커를 여러 개로 늘리면 진행 상황을 DB 로 옮겨야 한다.
서버를 다시 켜면 진행 중 작업 정보는 사라진다(수집 결과는 DB 에 이미 저장된 만큼 남음). 서버를 다시 켜면 진행 중 작업 정보는 사라진다(수집 결과는 DB 에 이미 저장된 만큼 남음).
- [업데이트 취소]: SyncJob.cancel() → 각 쇼핑몰이 다음 API 호출 직전(ShopProgress.check)에 Cancelled 로 멈춘다.
수집 중에 멈춘 쇼핑몰은 DB 에 아무것도 쓰지 않는다(저장은 수집이 끝난 뒤 한 트랜잭션). 저장 중이면 그 저장은 끝낸다.
아직 차례가 안 온 쇼핑몰은 "취소됨"으로 건너뛴다.
""" """
from __future__ import annotations from __future__ import annotations
@@ -16,7 +19,7 @@ import uuid
from datetime import date from datetime import date
from typing import Any from typing import Any
from .adapters.base import Progress from .adapters.base import Cancelled, Progress
MAX_JOBS = 20 MAX_JOBS = 20
_LOCK = threading.Lock() _LOCK = threading.Lock()
@@ -27,10 +30,10 @@ PASSIVE_STATUS = frozenset({"not_implemented", "not_configured"})
class ShopProgress(Progress): class ShopProgress(Progress):
"""쇼핑몰 하나의 진행 상황. state: waiting → running → saving → done | error | skipped.""" """쇼핑몰 하나의 진행 상황. state: waiting → running → saving → done | error | skipped | cancelled."""
def __init__(self, code: str, name: str, *, active: bool = True) -> None: def __init__(self, code: str, name: str, *, active: bool = True, job: "SyncJob | None" = None) -> None:
self.code, self.name, self.active = code, name, active self.code, self.name, self.active, self.job = code, name, active, job
self.state = "waiting" self.state = "waiting"
self.done = self.total = self.items = self.upserted = 0 self.done = self.total = self.items = self.upserted = 0
self.unit = "단계" self.unit = "단계"
@@ -47,7 +50,16 @@ class ShopProgress(Progress):
with self._lock: with self._lock:
self.total += max(0, int(n)) self.total += max(0, int(n))
def check(self) -> None:
if self.cancel_requested and self.state == "running":
raise Cancelled("사용자가 업데이트를 취소했습니다.")
@property
def cancel_requested(self) -> bool:
return bool(self.job is not None and self.job.cancel_requested)
def step(self, n: int = 1, *, items: int = 0) -> None: def step(self, n: int = 1, *, items: int = 0) -> None:
self.check()
with self._lock: with self._lock:
self.done += max(0, int(n)) self.done += max(0, int(n))
self.items += max(0, int(items)) self.items += max(0, int(items))
@@ -77,6 +89,11 @@ class ShopProgress(Progress):
self.active = False self.active = False
self.finished_at = time.time() self.finished_at = time.time()
def cancelled(self) -> None:
with self._lock:
self.state, self.status, self.message = "cancelled", "cancelled", "취소됨"
self.finished_at = time.time()
def skip(self, message: str) -> None: def skip(self, message: str) -> None:
with self._lock: with self._lock:
self.state, self.status, self.message = "skipped", "running", message self.state, self.status, self.message = "skipped", "running", message
@@ -84,7 +101,7 @@ class ShopProgress(Progress):
@property @property
def finished(self) -> bool: def finished(self) -> bool:
return self.state in ("done", "error", "skipped") return self.state in ("done", "error", "skipped", "cancelled")
def fraction(self) -> float: def fraction(self) -> float:
if self.finished: if self.finished:
@@ -115,14 +132,22 @@ class SyncJob:
self.shops: list[ShopProgress] = [] self.shops: list[ShopProgress] = []
self.error = "" self.error = ""
self.last_update_at: str | None = None self.last_update_at: str | None = None
self.cancel_requested = False
self.cancelled_by = ""
self._lock = threading.Lock() self._lock = threading.Lock()
def set_targets(self, targets: list[tuple[str, str, bool]], start: date, end: date) -> dict[str, ShopProgress]: def set_targets(self, targets: list[tuple[str, str, bool]], start: date, end: date) -> dict[str, ShopProgress]:
with self._lock: with self._lock:
self.start, self.end = start, end self.start, self.end = start, end
self.shops = [ShopProgress(code, name, active=active) for code, name, active in targets] self.shops = [ShopProgress(code, name, active=active, job=self) for code, name, active in targets]
return {s.code: s for s in self.shops} return {s.code: s for s in self.shops}
def cancel(self, user: str = "") -> None:
"""[업데이트 취소] — 돌고 있는 쇼핑몰은 다음 API 호출 직전에, 기다리는 쇼핑몰은 차례가 오면 멈춘다."""
with self._lock:
if not self.finished_at and not self.cancel_requested:
self.cancel_requested, self.cancelled_by = True, user
def finish(self, *, error: str = "", last_update_at: str | None = None) -> None: def finish(self, *, error: str = "", last_update_at: str | None = None) -> None:
with self._lock: with self._lock:
self.error, self.last_update_at, self.finished_at = error, last_update_at, time.time() self.error, self.last_update_at, self.finished_at = error, last_update_at, time.time()
@@ -136,12 +161,14 @@ class SyncJob:
shops = [s.snapshot() for s in self.shops] shops = [s.snapshot() for s in self.shops]
active = [s for s in shops if s["active"]] active = [s for s in shops if s["active"]]
return { return {
"id": self.id, "finished": self.finished, "error": self.error, "id": self.id, "finished": self.finished, "error": self.error, "user": self.user,
"cancel_requested": self.cancel_requested,
"from": self.start.isoformat() if self.start else None, "to": self.end.isoformat() if self.end else None, "from": self.start.isoformat() if self.start else None, "to": self.end.isoformat() if self.end else None,
"elapsed": round((self.finished_at or time.time()) - self.created_at, 1), "elapsed": round((self.finished_at or time.time()) - self.created_at, 1),
"last_update_at": self.last_update_at, "shops": shops, "last_update_at": self.last_update_at, "shops": shops,
"overall": { "overall": {
"shops": len(active), "finished": sum(1 for s in active if s["state"] in ("done", "error", "skipped")), "shops": len(active),
"finished": sum(1 for s in active if s["state"] in ("done", "error", "skipped", "cancelled")),
"fraction": round(sum(s["fraction"] for s in active) / len(active), 4) if active else "fraction": round(sum(s["fraction"] for s in active) / len(active), 4) if active else
(1.0 if self.finished else 0.0), (1.0 if self.finished else 0.0),
"items": sum(s["items"] for s in shops), "upserted": sum(s["upserted"] for s in shops), "items": sum(s["items"] for s in shops), "upserted": sum(s["upserted"] for s in shops),
+19
View File
@@ -8,6 +8,7 @@ JSON API — 모듈 권한
background=true 면 백그라운드로 돌리고 작업 번호를 바로 돌려줌 background=true 면 백그라운드로 돌리고 작업 번호를 바로 돌려줌
GET /performance/api/sync/jobs/{id} 매출 업데이트 진행 상황(쇼핑몰별·전체 진행 막대) GET /performance/api/sync/jobs/{id} 매출 업데이트 진행 상황(쇼핑몰별·전체 진행 막대)
GET /performance/api/sync/current 지금 돌고 있는 업데이트(없으면 null) GET /performance/api/sync/current 지금 돌고 있는 업데이트(없으면 null)
POST /performance/api/sync/jobs/{id}/cancel 업데이트 취소(시작한 사람 또는 관리자)
GET /performance/api/events 금액 클릭 상세(쇼핑몰+기간) GET /performance/api/events 금액 클릭 상세(쇼핑몰+기간)
JSON API — 관리자 JSON API — 관리자
PUT /performance/api/marketplaces/{code} 사용/매출 집계 여부 PUT /performance/api/marketplaces/{code} 사용/매출 집계 여부
@@ -208,6 +209,24 @@ def api_sync_job(request: Request, job_id: str) -> JSONResponse:
return JSONResponse({"job": job.snapshot()}) return JSONResponse({"job": job.snapshot()})
@router.post("/api/sync/jobs/{job_id}/cancel")
def api_sync_cancel(request: Request, job_id: str) -> JSONResponse:
"""[업데이트 취소] — 시작한 사람 또는 관리자. 돌고 있는 쇼핑몰은 다음 API 호출 직전에 멈추고(저장 전이면 DB 그대로),
기다리는 쇼핑몰은 건너뛴다. 이미 저장이 끝난 쇼핑몰 결과는 그대로 남는다."""
from app.store import is_admin # noqa: WPS433
from . import jobs # noqa: WPS433
_, user = common.require_store(request)
job = jobs.get_job(job_id)
if job is None:
raise HTTPException(status_code=404, detail="진행 상황을 찾을 수 없습니다(서버가 다시 시작됐을 수 있습니다).")
if job.user and job.user != user["email"] and not is_admin(user):
raise HTTPException(status_code=403, detail="업데이트를 시작한 사람이나 관리자만 취소할 수 있습니다.")
job.cancel(user["email"])
return JSONResponse({"job": job.snapshot()})
@router.get("/api/sync/current") @router.get("/api/sync/current")
def api_sync_current(request: Request) -> JSONResponse: def api_sync_current(request: Request) -> JSONResponse:
common.require_store(request) common.require_store(request)
+10 -1
View File
@@ -20,7 +20,7 @@ from typing import Any, Iterable
from app.timezone import today_kst from app.timezone import today_kst
from .adapters.base import STATUS_LABELS, AdapterContext, AdapterError, MarketplaceAdapter, SaleEvent from .adapters.base import STATUS_LABELS, AdapterContext, AdapterError, Cancelled, MarketplaceAdapter, SaleEvent
from .adapters.registry import all_adapters, get_adapter from .adapters.registry import all_adapters, get_adapter
from .credentials import CredentialService from .credentials import CredentialService
from .security.crypto import CryptoConfigError, DecryptError from .security.crypto import CryptoConfigError, DecryptError
@@ -102,6 +102,9 @@ class SyncService:
if progress is not None: if progress is not None:
progress.fail(status="api_error", label=STATUS_LABELS["api_error"], message="알 수 없는 쇼핑몰입니다.") progress.fail(status="api_error", label=STATUS_LABELS["api_error"], message="알 수 없는 쇼핑몰입니다.")
return {**result, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."} return {**result, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."}
if progress is not None and progress.cancel_requested: # [업데이트 취소] 뒤 차례가 온 쇼핑몰
progress.cancelled()
return {**result, "cancelled": True, "status": "cancelled", "message": "취소됨"}
run_id = self._store.start_run(code, trigger=trigger, range_from=start, range_to=end, user=user) run_id = self._store.start_run(code, trigger=trigger, range_from=start, range_to=end, user=user)
if run_id is None: if run_id is None:
if progress is not None: if progress is not None:
@@ -136,6 +139,12 @@ class SyncService:
progress.finish(upserted=upserted, message=f"{upserted}건 반영") progress.finish(upserted=upserted, message=f"{upserted}건 반영")
return {**result, "ok": True, "status": "ok", "fetched": fetched, "upserted": upserted, return {**result, "ok": True, "status": "ok", "fetched": fetched, "upserted": upserted,
"message": f"{upserted}건 반영"} "message": f"{upserted}건 반영"}
except Cancelled:
# 수집 중 취소 — 아직 아무것도 저장하지 않았다. 연결 상태(오류 표시)는 바꾸지 않는다.
self._store.finish_run(run_id, ok=False, error="업데이트 취소")
if progress is not None:
progress.cancelled()
return {**result, "cancelled": True, "status": "cancelled", "message": "취소됨"}
except Exception as exc: # noqa: BLE001 — 한 쇼핑몰 실패가 전체를 멈추지 않게 except Exception as exc: # noqa: BLE001 — 한 쇼핑몰 실패가 전체를 멈추지 않게
status, message = self._failure(exc, ctx) status, message = self._failure(exc, ctx)
logger.warning("performance sync %s failed: %s %s", code, status, message) logger.warning("performance sync %s failed: %s %s", code, status, message)
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930f" />{% endblock %} {% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930g" />{% endblock %}
{%- macro won(v) -%} {%- macro won(v) -%}
{%- if v is none -%}<span class="perf-na"></span> {%- if v is none -%}<span class="perf-na"></span>
@@ -239,4 +239,4 @@
} | tojson }}</script> } | tojson }}</script>
{% endblock %} {% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20260930za" defer></script>{% endblock %} {% block scripts %}<script src="/static/performance.js?v=20260930zb" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930f" />{% endblock %} {% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930g" />{% endblock %}
{%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%}
@@ -177,4 +177,4 @@
</section> </section>
{% endblock %} {% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20260930za" defer></script>{% endblock %} {% block scripts %}<script src="/static/performance.js?v=20260930zb" defer></script>{% endblock %}
@@ -1340,6 +1340,51 @@ def test_gsshop_collect_sales():
assert rec["days"][1]["amount"] == -17000 and rec["days"][1]["claimed"] == 17000 assert rec["days"][1]["amount"] == -17000 and rec["days"][1]["claimed"] == 17000
def test_sync_job_cancel():
"""[업데이트 취소]: 수집 중인 쇼핑몰은 다음 API 호출 직전에 멈추고 저장하지 않는다(기존 매출 그대로),
차례가 안 온 쇼핑몰은 취소됨으로 건너뛴다. 연결 상태(오류)는 기록하지 않는다."""
import bcrypt
import httpx
from app.modules.performance import jobs
from app.modules.performance.adapters import naver as nv
job = jobs.create_job(user="king@x", start=None, end=None)
days = []
def get(url, params=None, headers=None, timeout=None):
days.append(params["from"][:10])
if len(days) == 2:
job.cancel("king@x") # 둘째 날을 받는 도중 취소
rows = [_naver_item("A" + days[-1], "P" + days[-1], days[-1], 10000)]
return httpx.Response(200, json={"data": {"contents": rows, "pagination": {"hasNext": False}}})
st = FakeStore()
st.markets = [m for m in st.markets if m["code"] in ("naver", "gsshop")]
creds = CredentialService(st, lambda: ring())
creds.save(next(a for a in all_adapters() if a.code == "naver"),
{"client_id": "app-id", "client_secret": bcrypt.gensalt(rounds=4).decode()})
creds.save(next(a for a in all_adapters() if a.code == "gsshop"),
{"vendor_code": "1047142", "api_key": "0123456789abcdef0123456789ABCDEF"})
st.events[("naver", "SALE", "naver:OLD")] = {"amount": 5000, "is_sample": False, "sales_date": date(2026, 9, 10)}
orig = (httpx.post, httpx.get, nv.CALL_INTERVAL_SEC)
httpx.post = lambda url, data=None, timeout=None, headers=None: httpx.Response(200, json={"access_token": "T", "expires_in": 10799})
httpx.get, nv.CALL_INTERVAL_SEC = get, 0
try:
res = SyncService(st, creds).sync_all(start=date(2026, 9, 9), end=date(2026, 9, 12), user="king@x", job=job)
finally:
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
job.finish()
assert days == ["2026-09-09", "2026-09-10"] # 셋째 날은 부르지 않음
assert [r.get("cancelled") for r in res] == [True, True]
snap = {s["code"]: s for s in job.snapshot()["shops"]}
assert snap["naver"]["state"] == "cancelled" and snap["gsshop"]["state"] == "cancelled"
assert list(st.events) == [("naver", "SALE", "naver:OLD")] # 저장 안 함 — 기존 매출 그대로
assert "naver" not in st.status and "gsshop" not in st.status # 연결 상태 안 바뀜
snapshot = job.snapshot()
assert snapshot["cancel_requested"] and snapshot["overall"]["finished"] == 2 and snapshot["overall"]["fraction"] == 1.0
if __name__ == "__main__": if __name__ == "__main__":
os.environ.pop("APP_ENCRYPTION_KEY", None) os.environ.pop("APP_ENCRYPTION_KEY", None)
n = 0 n = 0
+151
View File
@@ -0,0 +1,151 @@
"""프로젝트 관리 — 현재 접근 권한의 공통 기준(서버).
라우터·마감 알림이 같은 규칙을 쓰도록 한 곳에 모은다. 모든 판단은 "지금" 기준이다 —
예전에 멤버였거나 담당자·멘션·협업자로 기록돼 있어도, 지금 권한이 없으면 보이지도
바꾸지도 알림을 받지도 않는다(기록 자체는 업무 이력으로 남긴다).
프로젝트
관리(=보기·작업 CRUD) : 관리자(is_admin) · 프로젝트 owner · 배정 멤버. 모두 `project` 모듈 권한이 있어야 한다.
작업
FULL : 원 소속 프로젝트를 관리할 수 있음 → 보기·수정·댓글·첨부·삭제(삭제는 추가로 생성자 규칙)
READ : 원 소속 권한은 없지만, 이 작업(또는 상위 작업)이 연결된(멀티호밍) 프로젝트를 관리할 수 있음
→ 그 작업의 상세·하위 작업 목록·댓글·첨부 보기만. 원 소속의 다른 작업·멤버는 보이지 않는다.
연결된 프로젝트 안에서의 섹션 이동(POST /links, 이미 연결된 경우)은 예전처럼 허용.
None : 권한 없음 → 403/목록에서 제외/알림·메일 대상 제외
"""
from __future__ import annotations
from typing import Any, Callable, Iterable
from . import store
FULL = "full"
READ = "read"
UserLookup = Callable[[str], "dict[str, Any] | None"]
def default_user_lookup(email: str) -> dict[str, Any] | None:
"""등록 사용자 레코드(app.main.user_store). 지연 import — 테스트는 lookup 을 직접 넘긴다."""
from app.main import user_store # noqa: WPS433
return user_store.get(store.norm_str(email, lower=True))
def _is_admin(user: dict[str, Any] | None) -> bool:
from app.store import is_admin # noqa: WPS433
return is_admin(user)
def can_use_module(user: dict[str, Any] | None) -> bool:
from app.store import has_module # noqa: WPS433
return bool(user) and has_module(user, "project")
def email_of(user: dict[str, Any] | None) -> str:
return store.norm_str((user or {}).get("email", ""), lower=True)
def can_manage_project(st: Any, user: dict[str, Any] | None, project_id: Any) -> bool:
"""프로젝트 관리(=보기·작업 CRUD) — 관리자 또는 owner/멤버. 모듈 권한이 없으면 False."""
if not can_use_module(user):
return False
if _is_admin(user):
return True
try:
pid = int(project_id)
except (TypeError, ValueError):
return False
return bool(st.is_member(project_id=pid, user_email=email_of(user)))
def visible_project_ids(st: Any, user: dict[str, Any]) -> set[int] | None:
"""관리할 수 있는 프로젝트 id 집합. 관리자는 None(=전체)."""
if _is_admin(user):
return None
if not can_use_module(user):
return set()
return {
int(p["id"]) for p in st.list_projects(include_archived=True, member_email=email_of(user))
}
def task_access(st: Any, user: dict[str, Any] | None, task: dict[str, Any] | None) -> str | None:
"""작업 하나에 대한 지금 권한: FULL / READ / None."""
if not task or not can_use_module(user):
return None
if can_manage_project(st, user, task.get("project_id")):
return FULL
for pid in link_scope(st, [int(task["id"])]).get(int(task["id"]), set()):
if can_manage_project(st, user, pid):
return READ
return None
def link_scope(st: Any, task_ids: Iterable[int]) -> dict[int, set[int]]:
"""작업 id → 이 작업 또는 상위 작업이 연결된 프로젝트 id 들. 연결 표가 없으면 빈 값."""
ids = [int(i) for i in task_ids]
if not ids:
return {}
try:
return st.task_link_scope(task_ids=ids)
except Exception: # noqa: BLE001 - 003 미적용(연결 기능 없음) → 연결로 보이는 작업 없음
return {}
def filter_visible_tasks(st: Any, user: dict[str, Any], tasks: list[dict[str, Any]],
*, key: str = "id") -> list[dict[str, Any]]:
"""목록에서 지금 볼 수 있는(FULL 또는 READ) 작업만 남긴다 — 내 작업·수신함·알림 공용."""
allowed = visible_project_ids(st, user)
if allowed is None:
return list(tasks)
ids = [int(t[key]) for t in tasks if t.get(key) is not None]
scope = link_scope(st, ids)
out = []
for t in tasks:
tid = t.get(key)
pid = t.get("project_id")
if pid is not None and int(pid) in allowed:
out.append(t)
elif tid is not None and scope.get(int(tid), set()) & allowed:
out.append(t)
return out
def email_task_access(st: Any, email: str, task: dict[str, Any],
lookup: UserLookup | None = None) -> str | None:
"""이메일(알림·멘션 대상)이 지금 이 작업을 볼 수 있는지. 등록 안 된 사람·모듈 권한 없는 사람은 None."""
rec = (lookup or default_user_lookup)(email)
if not rec:
return None
rec = {**rec, "email": rec.get("email") or email}
return task_access(st, rec, task)
def filter_recipients(st: Any, task: dict[str, Any], emails: Iterable[str],
lookup: UserLookup | None = None) -> list[str]:
"""알림·메일·멘션 대상 중 지금 이 작업을 볼 수 있는 사람만(순서 유지, 중복 제거)."""
out: list[str] = []
seen: set[str] = set()
for e in emails:
em = store.norm_str(e, lower=True)
if not em or em in seen:
continue
seen.add(em)
if email_task_access(st, em, task, lookup) is not None:
out.append(em)
return out
def can_assign(st: Any, email: str, project_id: Any, lookup: UserLookup | None = None) -> bool:
"""담당자·소유자 후보 — 등록된 사용자이고 project 모듈 권한이 있으며, 그 프로젝트를
관리할 수 있어야 한다(관리자 포함). 권한 없는 사람에게 작업 정보가 담긴 알림이 가지 않게."""
rec = (lookup or default_user_lookup)(email)
if not rec:
return False
rec = {**rec, "email": rec.get("email") or email}
return can_manage_project(st, rec, project_id)
+137 -5
View File
@@ -100,6 +100,7 @@ class ProjectStore:
ic = store.validate_project_icon(icon) ic = store.validate_project_icon(icon)
sd = store.validate_date(start_date) sd = store.validate_date(start_date)
dd = store.validate_date(due_date) dd = store.validate_date(due_date)
store.validate_date_range(sd, dd)
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
if parent_id is not None: if parent_id is not None:
@@ -158,15 +159,26 @@ class ProjectStore:
} }
sets: list[str] = [] sets: list[str] = []
params: list[Any] = [] params: list[Any] = []
clean: dict[str, Any] = {}
for key, fn in allowed.items(): for key, fn in allowed.items():
if key in fields: if key in fields:
clean[key] = fn(fields[key])
sets.append(f"{key} = %s") sets.append(f"{key} = %s")
params.append(fn(fields[key])) params.append(clean[key])
if not sets: if not sets:
existing = self.get_project(project_id=project_id) existing = self.get_project(project_id=project_id)
if existing is None: if existing is None:
raise KeyError(project_id) raise KeyError(project_id)
return existing return existing
if "start_date" in clean or "due_date" in clean:
# 한쪽만 바꿔도 기존 값과 합친 최종 상태로 검사한다.
existing = self.get_project(project_id=project_id)
if existing is None:
raise KeyError(project_id)
store.validate_date_range(
clean["start_date"] if "start_date" in clean else existing.get("start_date"),
clean["due_date"] if "due_date" in clean else existing.get("due_date"),
)
params.append(project_id) params.append(project_id)
with self._pool.connection() as conn: with self._pool.connection() as conn:
row = conn.execute( row = conn.execute(
@@ -605,7 +617,9 @@ class ProjectStore:
dd = store.validate_date(due_date) dd = store.validate_date(due_date)
sti = store.validate_time(start_time) sti = store.validate_time(start_time)
dti = store.validate_time(due_time) dti = store.validate_time(due_time)
store.validate_date_range(sd, dd, sti, dti)
assignee = store.norm_str(assignee_email, lower=True) assignee = store.norm_str(assignee_email, lower=True)
done_at = None
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
if parent_task_id is not None: if parent_task_id is not None:
@@ -636,6 +650,13 @@ class ProjectStore:
# 세션이 없어 해당 없음). # 세션이 없어 해당 없음).
if not assignee and stage_id is not None: if not assignee and stage_id is not None:
assignee, assignee_name = self._stage_default_assignee(conn, stage_id, project_id) assignee, assignee_name = self._stage_default_assignee(conn, stage_id, project_id)
# 완료 섹션에 바로 만든 작업은 완료 섹션으로 옮긴 것과 같이 완료 처리(완료 시각·이력).
if stage_id is not None:
done_row = conn.execute(
"SELECT is_done_stage FROM project_stages WHERE id = %s", (stage_id,)
).fetchone()
if done_row and done_row["is_done_stage"]:
done_at = now_kst()
nxt = conn.execute( nxt = conn.execute(
"SELECT COALESCE(MAX(sort_order), -1) + 1 AS n FROM tasks " "SELECT COALESCE(MAX(sort_order), -1) + 1 AS n FROM tasks "
"WHERE project_id = %s", "WHERE project_id = %s",
@@ -646,21 +667,26 @@ class ProjectStore:
INSERT INTO tasks INSERT INTO tasks
(project_id, stage_id, parent_task_id, title, description, (project_id, stage_id, parent_task_id, title, description,
assignee_email, assignee_name, priority, start_date, due_date, assignee_email, assignee_name, priority, start_date, due_date,
start_time, due_time, sort_order, created_by) start_time, due_time, sort_order, created_by, completed_at)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
RETURNING * RETURNING *
""", """,
( (
project_id, stage_id, parent_task_id, ttl, store.norm_str(description), project_id, stage_id, parent_task_id, ttl, store.norm_str(description),
assignee, store.norm_str(assignee_name), pr, sd, dd, assignee, store.norm_str(assignee_name), pr, sd, dd,
sti, dti, int(nxt["n"]), store.norm_str(created_by, lower=True), sti, dti, int(nxt["n"]), store.norm_str(created_by, lower=True), done_at,
), ),
).fetchone() ).fetchone()
if assignee: if assignee:
self._log(conn, project_id=project_id, task_id=row["id"], self._log(conn, project_id=project_id, task_id=row["id"],
actor=created_by, action=store.ACTION_ASSIGNED, actor=created_by, action=store.ACTION_ASSIGNED,
detail=f"{ttl} → {assignee}") detail=f"{ttl} → {assignee}")
return self.get_task(task_id=row["id"]) if done_at is not None:
self._log(conn, project_id=project_id, task_id=row["id"],
actor=created_by, action=store.ACTION_COMPLETED, detail=ttl)
out = self.get_task(task_id=row["id"])
out["_newly_completed"] = done_at is not None
return out
def move_subtask( def move_subtask(
self, *, task_id: int, parent_task_id: int, actor: str = "" self, *, task_id: int, parent_task_id: int, actor: str = ""
@@ -806,6 +832,15 @@ class ProjectStore:
if not sets: if not sets:
return {**prev, "_newly_assigned": None, "_newly_completed": False} return {**prev, "_newly_assigned": None, "_newly_completed": False}
# 날짜 범위 — 한쪽만 바꾸거나 지워도 기존 값과 합친 최종 상태로 검사.
if any(k in fields for k in ("start_date", "due_date", "start_time", "due_time")):
def final(key: str, fn: Any) -> Any:
return fn(fields[key]) if key in fields else prev.get(key)
store.validate_date_range(
final("start_date", store.validate_date), final("due_date", store.validate_date),
final("start_time", store.validate_time), final("due_time", store.validate_time),
)
params.append(task_id) params.append(task_id)
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
@@ -1217,6 +1252,51 @@ class ProjectStore:
).fetchone() ).fetchone()
return self._serialize(row) return self._serialize(row)
def add_comment_with_attachments(
self, *, task_id: int, author_email: str, author_name: str, body: str,
files: list[dict[str, Any]], parent_id: int | None = None,
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
"""댓글과 첨부를 한 트랜잭션에 — 둘 중 하나라도 실패하면 아무것도 남지 않는다
(첨부 없이 빈 댓글만 남던 문제). files = [{filename, stored_name, content_type, size_bytes}].
본문이 비어도 되지만 첨부가 한 개 이상 있어야 한다."""
text = store.norm_str(body)
if not files and not text:
raise ValueError("댓글 내용이 비었습니다.")
author = store.norm_str(author_email, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
root = None
if parent_id:
p = conn.execute(
"SELECT id, task_id, parent_id FROM task_comments WHERE id = %s", (parent_id,)
).fetchone()
if not p or int(p["task_id"]) != int(task_id):
raise ValueError("답글을 달 댓글을 찾을 수 없습니다.")
root = int(p["parent_id"] or p["id"])
if root is not None:
row = conn.execute(
"INSERT INTO task_comments (task_id, author_email, author_name, body, parent_id) "
"VALUES (%s,%s,%s,%s,%s) RETURNING *",
(task_id, author, store.norm_str(author_name), text, root),
).fetchone()
else:
row = conn.execute(
"INSERT INTO task_comments (task_id, author_email, author_name, body) "
"VALUES (%s,%s,%s,%s) RETURNING *",
(task_id, author, store.norm_str(author_name), text),
).fetchone()
atts = []
for f in files:
atts.append(conn.execute(
"INSERT INTO task_attachments "
"(task_id, filename, stored_name, content_type, size_bytes, uploaded_by, comment_id) "
"VALUES (%s,%s,%s,%s,%s,%s,%s) RETURNING *",
(task_id, store.norm_str(f["filename"]), f["stored_name"],
store.norm_str(f.get("content_type") or "application/octet-stream"),
int(f["size_bytes"]), author, row["id"]),
).fetchone())
return self._serialize(row), [self._serialize(a) for a in atts]
def update_comment( def update_comment(
self, *, comment_id: int, requester: str, is_admin: bool, body: str self, *, comment_id: int, requester: str, is_admin: bool, body: str
) -> dict[str, Any]: ) -> dict[str, Any]:
@@ -1655,6 +1735,58 @@ class ProjectStore:
).fetchall() ).fetchall()
return [self._serialize(r) for r in rows] return [self._serialize(r) for r in rows]
def add_reminder_notification(
self, *, task_id: int, kind: str, due_date: str, recipient_email: str,
project_id: int | None, title: str, body: str,
) -> bool:
"""마감 알림 발송 기록 + 수신함 알림을 한 트랜잭션에. 처음이면 둘 다 넣고 True,
이미 보냈으면(UNIQUE) False. 알림 생성이 실패하면 발송 기록도 되돌려져 다음 실행에서
다시 시도된다(예전엔 기록만 남아 영영 안 갔다). 동시에 두 번 돌아도 UNIQUE 로 한 번만."""
rcpt = store.norm_str(recipient_email, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
row = conn.execute(
"INSERT INTO task_reminders (task_id, kind, due_date, recipient_email) "
"VALUES (%s,%s,%s,%s) ON CONFLICT DO NOTHING RETURNING id",
(task_id, kind, due_date, rcpt),
).fetchone()
if row is None:
return False
conn.execute(
"INSERT INTO project_notifications "
"(recipient_email, actor_email, project_id, task_id, type, title, body) "
"VALUES (%s,'',%s,%s,%s,%s,%s)",
(rcpt, project_id, task_id, kind, store.norm_str(title), store.norm_str(body)),
)
return True
def task_link_scope(self, *, task_ids: list[int]) -> dict[int, set[int]]:
"""작업 id → 이 작업 또는 그 상위 작업들이 연결(멀티호밍)된 프로젝트 id 집합.
연결된 프로젝트 멤버가 그 작업(과 하위 작업)을 읽기 전용으로 볼 수 있는지 판단한다."""
ids = sorted({int(i) for i in task_ids})
if not ids:
return {}
with self._pool.connection() as conn:
rows = conn.execute(
"""
WITH RECURSIVE chain AS (
SELECT id AS task_id, id AS anc_id, parent_task_id, 0 AS depth
FROM tasks WHERE id = ANY(%s)
UNION ALL
SELECT c.task_id, t.id, t.parent_task_id, c.depth + 1
FROM chain c JOIN tasks t ON t.id = c.parent_task_id
WHERE c.depth < 20
)
SELECT c.task_id, l.project_id
FROM chain c JOIN task_project_links l ON l.task_id = c.anc_id
""",
(ids,),
).fetchall()
out: dict[int, set[int]] = {}
for r in rows:
out.setdefault(int(r["task_id"]), set()).add(int(r["project_id"]))
return out
def record_reminder( def record_reminder(
self, *, task_id: int, kind: str, due_date: str, recipient_email: str, self, *, task_id: int, kind: str, due_date: str, recipient_email: str,
) -> bool: ) -> bool:
+28 -14
View File
@@ -5,10 +5,11 @@
· due_today — 오늘 마감 · due_today — 오늘 마감
· overdue — 마감이 지남(최근 7일 이내 마감분만 — 첫 적용 때 오래된 업무가 · overdue — 마감이 지남(최근 7일 이내 마감분만 — 첫 적용 때 오래된 업무가
한꺼번에 쏟아지지 않게, 연휴로 며칠 건너뛰어도 놓치지 않게) 한꺼번에 쏟아지지 않게, 연휴로 며칠 건너뛰어도 놓치지 않게)
수신자는 담당자. 담당자가 없으면 팔로워 전원. 수신자는 담당자. 담당자가 없으면 팔로워 전원. 단, 지금 그 작업을 볼 수 있는 사람만.
중복 방지: task_reminders(업무, 종류, 마감일, 수신자) UNIQUE — 같은 알림은 한 번만 중복 방지: task_reminders(업무, 종류, 마감일, 수신자) UNIQUE — 같은 알림은 한 번만
간다(재기동·여러 번 실행해도 안전). 마감일을 바꾸면 새 마감일 기준으로 다시 알린다. 간다(재기동·여러 번 실행해도 안전). 마감일을 바꾸면 새 마감일 기준으로 다시 알린다.
발송 기록과 수신함 알림은 한 트랜잭션이라, 알림 생성이 실패하면 다음 실행에 다시 시도된다.
실행 방식: 웹 프로세스 안의 데몬 스레드(start_reminder_thread). 5분마다 깨어나 실행 방식: 웹 프로세스 안의 데몬 스레드(start_reminder_thread). 5분마다 깨어나
"오늘 아직 안 돌았고, 설정 시각이 지났고, 영업일이면" 한 번 돈다. 여러 프로세스가 "오늘 아직 안 돌았고, 설정 시각이 지났고, 영업일이면" 한 번 돈다. 여러 프로세스가
@@ -33,7 +34,7 @@ from typing import Any
from app.timezone import now_kst from app.timezone import now_kst
from . import store from . import access, store
logger = logging.getLogger("project.reminders") logger = logging.getLogger("project.reminders")
@@ -87,8 +88,18 @@ def _title_for(kind: str, task: dict[str, Any], today: date) -> str:
return f"마감 지남({(today - due).days}일): {task['title']}" return f"마감 지남({(today - due).days}일): {task['title']}"
def run_due_reminders(st: Any, *, today: date | None = None) -> dict[str, int]: def run_due_reminders(
"""한 번 실행. 새로 만든 알림 수를 종류별로 돌려준다.""" st: Any, *, today: date | None = None, lookup: access.UserLookup | None = None,
) -> dict[str, int]:
"""한 번 실행. 새로 만든 알림 수를 종류별로 돌려준다.
- 수신자는 지금 그 작업을 볼 수 있는 사람만(access.filter_recipients) — 멤버에서 빠진 담당자·
협업자, 모듈 권한이 없어진 직원에게는 수신함 알림도 메일도 가지 않는다.
- 발송 기록(task_reminders)과 수신함 알림은 한 트랜잭션(add_reminder_notification) — 알림 생성이
실패하면 기록도 되돌려져 다음 실행에서 다시 시도된다. 같은 알림은 UNIQUE 로 한 번만(동시 실행 포함).
- 보장 범위: 수신함 알림까지. 메일(PROJECT_REMINDER_EMAIL)은 알림이 새로 만들어진 것만 요약해 한 번
보내며, 메일 발송 실패는 재시도하지 않는다(수신함 알림은 이미 남아 있다).
"""
today = today or now_kst().date() today = today or now_kst().date()
start = today - timedelta(days=OVERDUE_WINDOW_DAYS) start = today - timedelta(days=OVERDUE_WINDOW_DAYS)
end = next_workday(today) end = next_workday(today)
@@ -101,22 +112,25 @@ def run_due_reminders(st: Any, *, today: date | None = None) -> dict[str, int]:
if kind is None: if kind is None:
continue continue
assignee = store.norm_str(t.get("assignee_email"), lower=True) assignee = store.norm_str(t.get("assignee_email"), lower=True)
recipients = [assignee] if assignee else store.normalize_emails(t.get("followers") or []) wanted = [assignee] if assignee else store.normalize_emails(t.get("followers") or [])
try:
recipients = access.filter_recipients(st, t, wanted, lookup)
except Exception: # noqa: BLE001 - 권한 확인이 안 되면 이번엔 보내지 않는다(다음 실행에 재시도)
logger.warning("마감 알림 수신자 확인 실패: task=%s", t["id"])
continue
for rcpt in recipients: for rcpt in recipients:
if not st.record_reminder(
task_id=t["id"], kind=kind, due_date=t["due_date"][:10], recipient_email=rcpt,
):
continue # 이미 보냄
title = _title_for(kind, t, today) title = _title_for(kind, t, today)
try: try:
st.add_notification( created = st.add_reminder_notification(
recipient_email=rcpt, actor_email="", project_id=t["project_id"], task_id=t["id"], kind=kind, due_date=t["due_date"][:10], recipient_email=rcpt,
task_id=t["id"], type=kind, title=title, project_id=t["project_id"], title=title,
body=f"{t.get('project_name') or ''} · 마감 {t['due_date'][:10]}", body=f"{t.get('project_name') or ''} · 마감 {t['due_date'][:10]}",
) )
except Exception: # noqa: BLE001 except Exception: # noqa: BLE001 - 기록도 되돌려졌으니 다음 실행에서 다시 시도
logger.warning("마감 알림 생성 실패: task=%s", t["id"]) logger.warning("마감 알림 생성 실패(다음 실행에 재시도): task=%s", t["id"])
continue continue
if not created:
continue # 이미 보냄
counts[kind] += 1 counts[kind] += 1
digest.setdefault(rcpt, []).append((title, t)) digest.setdefault(rcpt, []).append((title, t))
File diff suppressed because it is too large Load Diff
+24
View File
@@ -313,6 +313,30 @@ def validate_date(d: Any) -> str | None:
return v[:10] 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: def validate_time(t: Any) -> str | None:
"""'HH:MM' 형식만 통과(초는 버림). 빈값/None 은 None(=종일).""" """'HH:MM' 형식만 통과(초는 버림). 빈값/None 은 None(=종일)."""
v = norm_str(t) v = norm_str(t)
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -169,5 +169,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930f" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/project-help.css?v=20260926v" /> <link rel="stylesheet" href="/static/project-help.css?v=20260926v" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -119,7 +119,9 @@
<tr><td>작업·섹션·프로젝트 삭제</td><td><b>만든 사람만</b> 지울 수 있습니다(최고 관리자는 예외).</td></tr> <tr><td>작업·섹션·프로젝트 삭제</td><td><b>만든 사람만</b> 지울 수 있습니다(최고 관리자는 예외).</td></tr>
<tr><td>댓글 고치기·지우기</td><td>댓글을 쓴 사람(또는 관리자)만.</td></tr> <tr><td>댓글 고치기·지우기</td><td>댓글을 쓴 사람(또는 관리자)만.</td></tr>
<tr><td>새 프로젝트, 프로젝트 수정·순서 바꾸기</td><td>관리자 (<span class="pjh-ui">+</span> · <span class="pjh-ui">✎</span> · <span class="pjh-ui">⣿</span> 버튼이 관리자에게만 보입니다)</td></tr> <tr><td>새 프로젝트, 프로젝트 수정·순서 바꾸기</td><td>관리자 (<span class="pjh-ui">+</span> · <span class="pjh-ui">✎</span> · <span class="pjh-ui">⣿</span> 버튼이 관리자에게만 보입니다)</td></tr>
<tr><td>멤버 배정·제외</td><td>관리자</td></tr> <tr><td>멤버 배정·제외, 프로젝트 소유자 바꾸기</td><td>관리자</td></tr>
<tr><td>다른 프로젝트에서 연결돼 온 작업</td><td>원래 프로젝트 멤버가 아니면 <b>읽기만</b> — 내용·댓글·첨부는 보이지만 고치거나 댓글을 달 수 없습니다(연결된 보드 안에서 섹션 옮기기는 됩니다).</td></tr>
<tr><td>멤버에서 빠졌을 때</td><td>그 프로젝트의 작업은 내 작업·수신함·알림·검색에서 사라지고, 예전 링크로도 열리지 않습니다. 새 알림도 오지 않습니다.</td></tr>
<tr><td>휴지통 보기·복구, 전체 멤버, 대시보드의 담당자별 차트</td><td>관리자</td></tr> <tr><td>휴지통 보기·복구, 전체 멤버, 대시보드의 담당자별 차트</td><td>관리자</td></tr>
<tr><td>목표 보기</td><td>누구나 · <b>목표 입력·연도 추가·업무 영역 편집</b>은 관리자</td></tr> <tr><td>목표 보기</td><td>누구나 · <b>목표 입력·연도 추가·업무 영역 편집</b>은 관리자</td></tr>
</table> </table>
@@ -263,7 +265,7 @@
<tr><td><span class="pjh-ui"><span class="material-symbols-outlined">link</span>공유</span></td><td>이 작업의 주소를 복사합니다. 메신저로 보내면 받은 멤버가 바로 이 작업을 엽니다.</td></tr> <tr><td><span class="pjh-ui"><span class="material-symbols-outlined">link</span>공유</span></td><td>이 작업의 주소를 복사합니다. 메신저로 보내면 받은 멤버가 바로 이 작업을 엽니다.</td></tr>
<tr><td><span class="pjh-ui">✓ 완료로 표시</span></td><td>작업을 완료합니다. 다시 누르면 <span class="pjh-ui">↩ 완료 취소</span>.</td></tr> <tr><td><span class="pjh-ui">✓ 완료로 표시</span></td><td>작업을 완료합니다. 다시 누르면 <span class="pjh-ui">↩ 완료 취소</span>.</td></tr>
<tr><td><span class="pjh-ui">삭제</span></td><td>작업을 지웁니다(만든 사람만). 하위 작업이 있으면 함께 지울지 한 번 더 묻습니다. 지운 작업은 휴지통에 3개월 보관됩니다.</td></tr> <tr><td><span class="pjh-ui">삭제</span></td><td>작업을 지웁니다(만든 사람만). 하위 작업이 있으면 함께 지울지 한 번 더 묻습니다. 지운 작업은 휴지통에 3개월 보관됩니다.</td></tr>
<tr><td><span class="pjh-ui">저장됨</span></td><td>저장 버튼이 없습니다 — 고치는 즉시 저장되고, 버튼 줄 오른쪽에 <span class="pjh-ui">저장 중…</span> → <span class="pjh-ui">✓ 저장됨</span>이 잠깐 보입니다.</td></tr> <tr><td><span class="pjh-ui">저장됨</span></td><td>저장 버튼이 없습니다 — 고치는 즉시 저장되고, 버튼 줄 오른쪽에 <span class="pjh-ui">저장 중…</span> → <span class="pjh-ui">✓ 저장됨</span>이 잠깐 보입니다. 저장이 안 되면 <span class="pjh-ui">저장 실패 · 다시 시도</span>(눌러서 다시 저장)가 뜨고, 이 상태로 창을 닫거나 다른 작업을 열면 한 번 더 저장해 본 뒤 <b>버리고 넘어갈지 / 계속 편집할지</b> 묻습니다 — 모른 채 내용이 사라지지 않습니다. 이미지를 올리는 중이면 다 올라갈 때까지 기다렸다가 넘어갑니다.</td></tr>
</table> </table>
<div class="pjh-note"><span class="material-symbols-outlined">info</span> <div class="pjh-note"><span class="material-symbols-outlined">info</span>
<div><b>실시간 저장</b> — 제목은 칸을 벗어나거나 <kbd>Enter</kbd>, 설명은 입력을 멈추고 1초쯤 뒤(또는 칸을 벗어날 때), 담당자·섹션·우선순위·마감일은 바꾸는 즉시 저장됩니다. 새 작업은 <b>제목을 쓰는 순간</b> 만들어집니다(제목 없이 닫으면 만들어지지 않습니다). 협업자 · 하위 작업 · 첨부 파일 · 다른 프로젝트 추가 · 댓글도 누르는 즉시 저장됩니다.</div></div> <div><b>실시간 저장</b> — 제목은 칸을 벗어나거나 <kbd>Enter</kbd>, 설명은 입력을 멈추고 1초쯤 뒤(또는 칸을 벗어날 때), 담당자·섹션·우선순위·마감일은 바꾸는 즉시 저장됩니다. 새 작업은 <b>제목을 쓰는 순간</b> 만들어집니다(제목 없이 닫으면 만들어지지 않습니다). 협업자 · 하위 작업 · 첨부 파일 · 다른 프로젝트 추가 · 댓글도 누르는 즉시 저장됩니다.</div></div>
@@ -301,7 +303,8 @@
</ol> </ol>
<p>작업은 하나라서 어느 보드에서 고쳐도 모두 같이 바뀝니다.</p> <p>작업은 하나라서 어느 보드에서 고쳐도 모두 같이 바뀝니다.</p>
<h3>댓글</h3> <h3>댓글</h3>
<p>작업 창 맨 아래에 항상 고정된 댓글 칸에 쓰고 <kbd>Enter</kbd>(스크롤해도 그 자리에 있습니다). 칸 오른쪽 <span class="pjh-ui">☺</span>는 이모티콘, <span class="pjh-ui">@</span>는 멤버 태그입니다. 답글은 원 댓글 아래 들여 쓰여 <span class="pjh-ui">↳</span> 표시와 함께 보입니다. 내가 쓴 댓글은 <span class="pjh-ui">✎</span>로 고치고 <span class="pjh-ui">×</span>로 지웁니다. 댓글 속 웹 주소는 링크가 됩니다.</p> <p>작업 창 맨 아래에 항상 고정된 댓글 칸에 쓰고 <kbd>Enter</kbd>(스크롤해도 그 자리에 있습니다). 칸 오른쪽 <span class="pjh-ui">☺</span>는 이모티콘, <span class="pjh-ui">@</span>는 멤버 태그입니다. 답글은 원 댓글 아래 들여 쓰여 <span class="pjh-ui">↳</span> 표시와 함께 보입니다. 내가 쓴 댓글은 <span class="pjh-ui">✎</span>로 고치고 <span class="pjh-ui">×</span>로 지웁니다. 댓글 속 웹 주소는 링크가 됩니다. 댓글에 붙인 파일은 그 댓글 아래에 보이고(파일만 보낸 댓글도), 첨부 파일 목록에는 <span class="pjh-ui">댓글</span> 표시가 붙습니다.</p>
<p>댓글 대화창에서 파일을 보낼 때 보낼 수 없는 파일(빈 파일, 20MB 초과)이 있으면 댓글을 만들지 않고 그 파일만 빨갛게 표시합니다 — 빼고 다시 보내세요. 인터넷이 끊겨도 쓴 내용과 파일은 그대로 남아 다시 보낼 수 있고, 같은 댓글이 두 번 올라가지 않습니다. @태그는 이 작업을 볼 수 있는 사람만 고를 수 있습니다. 한글을 입력하는 중(조합 중)의 <kbd>Enter</kbd>는 글자 확정만 하고 보내지 않습니다.</p>
</section> </section>
<!-- 9. 작업 창의 하위 작업 --> <!-- 9. 작업 창의 하위 작업 -->
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -104,5 +104,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930f" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -100,5 +100,5 @@
"today": {{ today | tojson }} "today": {{ today | tojson }}
} }
</script> </script>
<script src="/static/project.js?v=20260930f" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host --> <!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host -->
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<!-- 타임라인 vis-timeline — self-host --> <!-- 타임라인 vis-timeline — self-host -->
@@ -265,6 +265,11 @@
<span class="pj-t-parent-title" id="pj-t-parent-title"></span> <span class="pj-t-parent-title" id="pj-t-parent-title"></span>
</button> </button>
<textarea id="pj-t-title" class="pj-t-title-input" rows="1" placeholder="작업 제목"></textarea> <textarea id="pj-t-title" class="pj-t-title-input" rows="1" placeholder="작업 제목"></textarea>
<!-- 다른 프로젝트에서 연결돼 온 작업을 원 소속 권한 없이 열었을 때 — 보기만 된다(서버도 변경 거절). -->
<div class="pj-readonly-note" id="pj-t-readonly" hidden>
<span class="material-symbols-outlined">visibility</span>
<span>다른 프로젝트(<b id="pj-t-readonly-home"></b>)에서 연결된 작업이라 읽기만 할 수 있습니다. 변경은 원 소속 프로젝트 멤버만 할 수 있습니다.</span>
</div>
<div class="pj-modal-body"> <div class="pj-modal-body">
<div class="pj-modal-col-main"> <div class="pj-modal-col-main">
@@ -491,5 +496,5 @@
</script> </script>
<script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script> <script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script>
<script src="/static/project.js?v=20260930f" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930f" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -70,5 +70,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930f" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
+5
View File
@@ -260,3 +260,8 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; }
.perf-prog-row.is-total .perf-prog-bar { height: 14px; } .perf-prog-row.is-total .perf-prog-bar { height: 14px; }
.perf-prog-row.is-total .perf-prog-pct { font-weight: 700; color: inherit; } .perf-prog-row.is-total .perf-prog-pct { font-weight: 700; color: inherit; }
@media (max-width: 560px) { .perf-prog-row { grid-template-columns: 1fr 44px; } .perf-prog-name { grid-column: 1 / -1; } .perf-prog-text { grid-column: 1 / -1; } } @media (max-width: 560px) { .perf-prog-row { grid-template-columns: 1fr 44px; } .perf-prog-name { grid-column: 1 / -1; } .perf-prog-text { grid-column: 1 / -1; } }
/* [업데이트 취소] — 창 아래 왼쪽, 빨간 글자. 끝나면 숨김 */
.perf-prog-cancel { margin-right: auto; color: var(--perf-down); border-color: currentColor; }
.perf-prog-cancel[hidden] { display: none; }
.perf-prog-cancel:disabled { opacity: .6; cursor: default; }
+41 -7
View File
@@ -79,7 +79,8 @@
// ── 매출 업데이트 진행 창 — 서버가 백그라운드로 수집(POST /api/sync background)하는 동안 // ── 매출 업데이트 진행 창 — 서버가 백그라운드로 수집(POST /api/sync background)하는 동안
// GET /api/sync/jobs/{id} 를 0.8초마다 불러 쇼핑몰별·전체 진행 막대를 그린다. // GET /api/sync/jobs/{id} 를 0.8초마다 불러 쇼핑몰별·전체 진행 막대를 그린다.
// 창을 닫아도 수집은 서버에서 계속된다. 끝나면 resolve(마지막 상태), 호출 자체가 실패하면 reject. // 창을 닫아도 수집은 서버에서 계속된다. 끝나면 resolve(마지막 상태), 호출 자체가 실패하면 reject.
const SHOP_STATE = { waiting: "대기", running: "수집 중", saving: "저장 중", done: "완료", error: "실패", skipped: "건너뜀" }; const SHOP_STATE = { waiting: "대기", running: "수집 중", saving: "저장 중", done: "완료", error: "실패", skipped: "건너뜀",
cancelled: "취소됨" };
function fmtSec(sec) { function fmtSec(sec) {
sec = Math.max(0, Math.round(sec || 0)); sec = Math.max(0, Math.round(sec || 0));
return Math.floor(sec / 60) + ":" + String(sec % 60).padStart(2, "0"); return Math.floor(sec / 60) + ":" + String(sec % 60).padStart(2, "0");
@@ -100,6 +101,8 @@
if (s.state === "done") t += " · " + fmt(s.upserted) + "건 반영"; if (s.state === "done") t += " · " + fmt(s.upserted) + "건 반영";
if (s.state === "error") t += " · " + (s.label ? s.label + " — " : "") + (s.message || ""); if (s.state === "error") t += " · " + (s.label ? s.label + " — " : "") + (s.message || "");
if (s.state === "skipped") t += " · " + (s.message || ""); if (s.state === "skipped") t += " · " + (s.message || "");
if (s.state === "cancelled") t += " · 저장하지 않음(기존 매출 그대로)";
if (s.state === "running" && s.cancel_pending) t += " · 취소하는 중…";
let html = esc(t); let html = esc(t);
if (s.elapsed && s.state !== "waiting") html += ' <span class="perf-muted">(' + fmtSec(s.elapsed) + ")</span>"; if (s.elapsed && s.state !== "waiting") html += ' <span class="perf-muted">(' + fmtSec(s.elapsed) + ")</span>";
return html; return html;
@@ -112,13 +115,16 @@
html += '<p class="perf-muted" style="margin:0 0 10px">기간 ' + esc(job.from || "") + " ~ " + esc(job.to || "") + html += '<p class="perf-muted" style="margin:0 0 10px">기간 ' + esc(job.from || "") + " ~ " + esc(job.to || "") +
" · 경과 " + fmtSec(job.elapsed) + (job.finished ? "" : " · 창을 닫아도 서버에서 계속 진행됩니다") + "</p>"; " · 경과 " + fmtSec(job.elapsed) + (job.finished ? "" : " · 창을 닫아도 서버에서 계속 진행됩니다") + "</p>";
html += active.map(function (s) { html += active.map(function (s) {
const cls = s.state === "error" ? "is-error" : s.state === "done" ? "is-done" : s.state === "skipped" ? "is-skip" : ""; const cls = s.state === "error" ? "is-error" : s.state === "done" ? "is-done" :
(s.state === "skipped" || s.state === "cancelled") ? "is-skip" : "";
if (job.cancel_requested) s.cancel_pending = true;
return progressRow(s.name, s.fraction, shopText(s), cls); return progressRow(s.name, s.fraction, shopText(s), cls);
}).join(""); }).join("");
html += progressRow("전체", o.fraction, html += progressRow("전체", o.fraction,
esc(fmt(o.finished) + "/" + fmt(o.shops) + " 쇼핑몰 완료" + esc((job.cancel_requested ? (job.finished ? "업데이트 취소됨 · " : "취소하는 중 · ") : "") +
fmt(o.finished) + "/" + fmt(o.shops) + " 쇼핑몰 완료" +
(o.items ? " · 받은 자료 " + fmt(o.items) + "건" : "") + (job.finished ? " · " + fmt(o.upserted) + "건 반영" : "")), (o.items ? " · 받은 자료 " + fmt(o.items) + "건" : "") + (job.finished ? " · " + fmt(o.upserted) + "건 반영" : "")),
"is-total" + (job.finished ? " is-done" : "")); "is-total" + (job.finished ? (job.cancel_requested ? " is-skip" : " is-done") : ""));
if (passive.length) { if (passive.length) {
html += '<p class="perf-muted" style="margin:10px 0 0">건너뜀: ' + esc(passive.map(function (s) { html += '<p class="perf-muted" style="margin:10px 0 0">건너뜀: ' + esc(passive.map(function (s) {
return s.name + (s.label ? "(" + s.label + ")" : ""); return s.name + (s.label ? "(" + s.label + ")" : "");
@@ -133,13 +139,36 @@
const m = openModal(title || "매출 업데이트", { narrow: true, onClose: function () { closed = true; clearTimeout(timer); if (last) resolve(last); } }); const m = openModal(title || "매출 업데이트", { narrow: true, onClose: function () { closed = true; clearTimeout(timer); if (last) resolve(last); } });
m.card.classList.add("perf-prog-card"); m.card.classList.add("perf-prog-card");
m.body.innerHTML = '<p class="perf-muted">업데이트를 시작하는 중…</p>'; m.body.innerHTML = '<p class="perf-muted">업데이트를 시작하는 중…</p>';
// [업데이트 취소] — 돌고 있는 쇼핑몰은 다음 API 호출 직전에 멈추고(저장 전이면 DB 그대로),
// 이미 저장이 끝난 쇼핑몰 결과는 남는다. 끝나면 숨긴다.
const cancelBtn = el("button", { type: "button", class: "erp-btn erp-btn-outline perf-prog-cancel", hidden: "hidden" }, "업데이트 취소");
const closeBtn = el("button", { type: "button", class: "erp-btn erp-btn-outline" }, "닫기"); const closeBtn = el("button", { type: "button", class: "erp-btn erp-btn-outline" }, "닫기");
closeBtn.addEventListener("click", m.close); closeBtn.addEventListener("click", m.close);
m.foot.appendChild(cancelBtn);
m.foot.appendChild(closeBtn); m.foot.appendChild(closeBtn);
let jobId = null;
cancelBtn.addEventListener("click", async function () {
if (!jobId) return;
if (!(await confirmMsg("매출 업데이트를 취소할까요?\n수집 중인 쇼핑몰은 저장하지 않고 멈추고, 이미 끝난 쇼핑몰 결과는 그대로 남습니다."))) return;
cancelBtn.disabled = true;
cancelBtn.textContent = "취소하는 중…";
try {
const r = await api("POST", "/performance/api/sync/jobs/" + encodeURIComponent(jobId) + "/cancel");
last = r.job;
renderSyncJob(m.body, r.job, false);
} catch (err) {
cancelBtn.disabled = false;
cancelBtn.textContent = "업데이트 취소";
alertMsg("취소 실패: " + err.message);
}
});
api("POST", "/performance/api/sync", Object.assign({ background: true }, payload)).then(function (res) { api("POST", "/performance/api/sync", Object.assign({ background: true }, payload)).then(function (res) {
last = res.job; last = res.job;
jobId = res.job.id;
const joined = res.joined; const joined = res.joined;
renderSyncJob(m.body, res.job, joined); renderSyncJob(m.body, res.job, joined);
if (!res.job.finished) cancelBtn.hidden = false;
if (res.job.cancel_requested) { cancelBtn.disabled = true; cancelBtn.textContent = "취소하는 중…"; }
async function poll() { async function poll() {
if (closed) return; if (closed) return;
try { try {
@@ -147,6 +176,7 @@
last = r.job; last = r.job;
renderSyncJob(m.body, r.job, joined); renderSyncJob(m.body, r.job, joined);
if (r.job.finished) { if (r.job.finished) {
cancelBtn.hidden = true;
closeBtn.textContent = "확인"; closeBtn.textContent = "확인";
closeBtn.className = "erp-btn erp-btn-primary"; closeBtn.className = "erp-btn erp-btn-primary";
return; return;
@@ -169,6 +199,7 @@
function jobResults(job) { function jobResults(job) {
return (job && job.shops || []).map(function (s) { return (job && job.shops || []).map(function (s) {
return { code: s.code, name: s.name, ok: s.state === "done", skipped: s.state === "skipped", return { code: s.code, name: s.name, ok: s.state === "done", skipped: s.state === "skipped",
cancelled: s.state === "cancelled",
upserted: s.upserted, status: s.status, label: s.label, message: s.message, finished: s.state !== "waiting" && s.state !== "running" && s.state !== "saving" }; upserted: s.upserted, status: s.status, label: s.label, message: s.message, finished: s.state !== "waiting" && s.state !== "running" && s.state !== "saving" };
}); });
} }
@@ -232,11 +263,12 @@
const running = job && !job.finished; const running = job && !job.finished;
// 실패(빨강)는 인증 실패·API 오류처럼 손봐야 하는 것만. 인증정보를 아직 안 넣은 쇼핑몰(미설정)과 // 실패(빨강)는 인증 실패·API 오류처럼 손봐야 하는 것만. 인증정보를 아직 안 넣은 쇼핑몰(미설정)과
// 수집을 아직 만들지 않은 쇼핑몰(연동 준비 중)은 회색 한 줄로 이름만. // 수집을 아직 만들지 않은 쇼핑몰(연동 준비 중)은 회색 한 줄로 이름만.
const ok = [], bad = [], pending = [], unset = [], busy = []; const ok = [], bad = [], pending = [], unset = [], busy = [], cancelled = [];
let changed = 0; let changed = 0;
(res.results || []).forEach(function (r) { (res.results || []).forEach(function (r) {
const name = (data.names || {})[r.code] || r.name || r.code; const name = (data.names || {})[r.code] || r.name || r.code;
if (r.skipped) busy.push(name); if (r.cancelled) cancelled.push(name);
else if (r.skipped) busy.push(name);
else if (r.ok) { ok.push(name + " " + fmt(r.upserted) + "건"); changed += r.upserted; } else if (r.ok) { ok.push(name + " " + fmt(r.upserted) + "건"); changed += r.upserted; }
else if (r.status === "not_implemented") pending.push(name); else if (r.status === "not_implemented") pending.push(name);
else if (r.status === "not_configured") unset.push(name); else if (r.status === "not_configured") unset.push(name);
@@ -246,6 +278,7 @@
if (ok.length) parts.push("<b>반영</b> " + esc(ok.join(", "))); if (ok.length) parts.push("<b>반영</b> " + esc(ok.join(", ")));
if (bad.length) parts.push("<b>실패</b> " + esc(bad.join(", "))); if (bad.length) parts.push("<b>실패</b> " + esc(bad.join(", ")));
if (busy.length) parts.push("<b>이미 진행 중</b> " + esc(busy.join(", "))); if (busy.length) parts.push("<b>이미 진행 중</b> " + esc(busy.join(", ")));
if (cancelled.length) parts.push("<b>취소됨</b>(기존 매출 그대로) " + esc(cancelled.join(", ")));
if (pending.length) parts.push('<span class="perf-muted">연동 준비 중: ' + esc(pending.join(", ")) + "</span>"); if (pending.length) parts.push('<span class="perf-muted">연동 준비 중: ' + esc(pending.join(", ")) + "</span>");
if (unset.length) parts.push('<span class="perf-muted">인증정보 미설정: ' + esc(unset.join(", ")) + "</span>"); if (unset.length) parts.push('<span class="perf-muted">인증정보 미설정: ' + esc(unset.join(", ")) + "</span>");
if (running) parts.unshift("<b>업데이트가 아직 진행 중입니다</b> — 끝나면 다시 [매출 업데이트]를 눌러 결과를 보세요"); if (running) parts.unshift("<b>업데이트가 아직 진행 중입니다</b> — 끝나면 다시 [매출 업데이트]를 눌러 결과를 보세요");
@@ -1000,7 +1033,8 @@
if (job && !job.finished) rest.push("(아직 진행 중 — 창을 닫았습니다. 끝나면 대시보드에 반영됩니다)"); if (job && !job.finished) rest.push("(아직 진행 중 — 창을 닫았습니다. 끝나면 대시보드에 반영됩니다)");
(res.results || []).forEach(function (r) { (res.results || []).forEach(function (r) {
const name = names[r.code] || r.name || r.code; const name = names[r.code] || r.name || r.code;
if (r.ok) ok.push(name + " " + fmt(r.upserted) + "건"); if (r.cancelled) rest.push(name + "(취소됨)");
else if (r.ok) ok.push(name + " " + fmt(r.upserted) + "건");
else if (r.skipped) rest.push(name + "(이미 진행 중)"); else if (r.skipped) rest.push(name + "(이미 진행 중)");
else if (r.status === "not_implemented" || r.status === "not_configured") rest.push(name); else if (r.status === "not_implemented" || r.status === "not_configured") rest.push(name);
else bad.push(name + "(" + (r.label || r.status) + ": " + (r.message || "") + ")"); else bad.push(name + "(" + (r.label || r.status) + ": " + (r.message || "") + ")");
+41
View File
@@ -2116,3 +2116,44 @@ textarea.pj-goal-text::placeholder { color: rgba(0, 0, 0, .3); }
width: 16px; height: 16px; border: 1px solid rgba(0, 0, 0, .2); border-radius: 4px; background: width: 16px; height: 16px; border: 1px solid rgba(0, 0, 0, .2); border-radius: 4px; background:
linear-gradient(to top right, transparent calc(50% - 1px), #e5484d calc(50% - 1px), #e5484d calc(50% + 1px), transparent calc(50% + 1px)); linear-gradient(to top right, transparent calc(50% - 1px), #e5484d calc(50% - 1px), #e5484d calc(50% + 1px), transparent calc(50% + 1px));
} }
/* ════════════════════════════════════════════════════════════
권한·저장 안전장치(2026-09-30)
════════════════════════════════════════════════════════════ */
/* 읽기 전용 안내줄 — 다른 프로젝트에서 연결돼 온 작업(원 소속 권한 없음) */
.pj-readonly-note {
display: flex; align-items: center; gap: 6px; margin: 4px 0 8px; padding: 7px 10px;
border-radius: 8px; background: #f1f5fb; color: #34507a; font-size: 12.5px; line-height: 1.4;
}
.pj-readonly-note[hidden] { display: none; }
.pj-readonly-note .material-symbols-outlined { font-size: 17px; }
.pj-modal.is-readonly .pj-t-title-input { cursor: default; }
.pj-modal.is-readonly .pj-desc-editor { background: #fafbfc; }
.pj-subtask-row.is-readonly .pj-subtask-check,
.pj-subtask-row.is-readonly .pj-subtask-due,
.pj-subtask-row.is-readonly .pj-subtask-av { cursor: default; opacity: .7; }
/* 이 프로젝트 권한을 잃었을 때 화면 위 안내 */
.pj-access-lost {
margin: 0 0 10px; padding: 10px 14px; border-radius: 8px; background: #fdecea; color: #a1261b;
font-size: 13px; font-weight: 600;
}
.pj-access-lost a { color: inherit; text-decoration: underline; margin-left: 6px; }
/* 저장 실패 — 눌러서 다시 시도 */
.pj-autosave-state.is-retry { cursor: pointer; text-decoration: underline dotted; }
/* 작업 창 댓글의 첨부(파일만 있는 댓글도 보이게) */
.pj-comment-atts { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 4px; }
.pj-comment-att { display: inline-flex; align-items: center; gap: 5px; text-decoration: none; color: var(--pj-ink); }
.pj-comment-att-file {
padding: 4px 8px; border: 1px solid var(--pj-border); border-radius: 6px; background: #fff; font-size: 12.5px;
}
.pj-comment-att-file:hover { background: #f6f7f8; }
.pj-comment-att-img img {
display: block; max-width: 160px; max-height: 120px; border-radius: 6px; border: 1px solid var(--pj-border);
object-fit: cover;
}
/* 첨부 파일 목록에서 댓글에 붙은 파일 표시 */
.pj-attach-from-comment {
margin-left: 6px; padding: 0 6px; border-radius: 999px; background: #eef0f2; color: #525860; font-size: 11px;
}
/* 댓글 대화창 — 보낼 수 없었던 파일(빈 파일·20MB 초과) */
.pj-chat-pending-chip.is-failed { border-color: #e5484d; background: #fdecea; color: #a1261b; }
+634 -139
View File
File diff suppressed because it is too large Load Diff
+4
View File
@@ -216,6 +216,10 @@
상태: 대기 → 수집 중 n/전체 · 받은 자료 → 저장 중 → 완료 n건 반영 | 실패 | 건너뜀. 수집이 없거나 인증정보가 없는 쇼핑몰은 상태: 대기 → 수집 중 n/전체 · 받은 자료 → 저장 중 → 완료 n건 반영 | 실패 | 건너뜀. 수집이 없거나 인증정보가 없는 쇼핑몰은
막대에서 빼고 "건너뜀" 한 줄(전체 진행률에 안 넣음). 전체 = 막대 쇼핑몰 진행률 평균. 이미 돌고 있는 업데이트가 있으면 새로 시작하지 막대에서 빼고 "건너뜀" 한 줄(전체 진행률에 안 넣음). 전체 = 막대 쇼핑몰 진행률 평균. 이미 돌고 있는 업데이트가 있으면 새로 시작하지
않고 그 진행 상황을 보여 준다(`GET /api/sync/current`). 창을 닫아도 수집은 계속된다. 않고 그 진행 상황을 보여 준다(`GET /api/sync/current`). 창을 닫아도 수집은 계속된다.
- **[업데이트 취소]**(진행 창 왼쪽 아래, 시작한 사람·관리자, `POST /api/sync/jobs/{id}/cancel`): 돌고 있는 쇼핑몰은 다음 API 호출
직전(`ctx.progress.check()` → `Cancelled`)에 멈추고 **저장하지 않는다**(저장은 수집이 끝난 뒤 한 트랜잭션이라 기존 매출 그대로),
차례가 안 온 쇼핑몰은 "취소됨"으로 건너뛴다. 이미 저장이 끝난 쇼핑몰 결과는 남고, 저장 중이던 쇼핑몰은 그 저장을 끝낸다.
취소된 실행은 `perf_sync_runs` 에 failed + "업데이트 취소", 연결 상태(`perf_connection_status`)는 바꾸지 않는다.
- 카페24 **환불합계 규칙(확정, 2026-09-29 실데이터)**: 카페24 "일별 매출내역" 환불합계 = 환불 목록의 (실제 환불액 + 적립금·예치금 환불) - 카페24 **환불합계 규칙(확정, 2026-09-29 실데이터)**: 카페24 "일별 매출내역" 환불합계 = 환불 목록의 (실제 환불액 + 적립금·예치금 환불)
+ 환불 목록에 없는 취소·반품(네이버페이 등, 취소일 기준). 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800, + 환불 목록에 없는 취소·반품(네이버페이 등, 취소일 기준). 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800,
9/27 = 145,000 + 네이버페이 55,800 = 200,800 으로 일치. 대조 도구에 환불합계 후보(값 입력 시 일치 줄 강조)·환불 건별· 9/27 = 145,000 + 네이버페이 55,800 = 200,800 으로 일치. 대조 도구에 환불합계 후보(값 입력 시 일치 줄 강조)·환불 건별·
+77 -5
View File
@@ -33,11 +33,13 @@
| 연결 env | `PROJECT_DB_URL` (미설정 시 "설정 필요" 안내, 앱은 죽지 않음) | | 연결 env | `PROJECT_DB_URL` (미설정 시 "설정 필요" 안내, 앱은 죽지 않음) |
| 진입 권한 | 권한키 `project` (관리자 페이지 토글로 직원별 부여, admin 자동) | | 진입 권한 | 권한키 `project` (관리자 페이지 토글로 직원별 부여, admin 자동) |
| 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) | | 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) |
| 생성 권한 | **프로젝트·섹션·작업(하위 작업 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. | | 생성 권한 | **프로젝트·섹션·작업(하위 작업 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. 다른 사람을 owner 로 지정해 만드는 건 관리자만(비관리자가 `owner_email` 을 남으로 보내면 403) |
| 수정/이동 권한 | 서브프로젝트·작업·섹션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 admin(`_require_manage`) | | 소유자 변경 | **관리자만**(2026-09-30). owner 는 멤버에서 빠져도 관리 권한이 남으므로, 일반 멤버가 스스로를 owner 로 바꿔 권한 회수를 피할 수 없게 `PUT /api/projects/{id}` 의 `owner_email` 변경은 비관리자 403(같은 값은 무시). 새 owner 는 `project` 권한이 있는 등록 사용자여야 한다(아니면 400) |
| 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/섹션/작업/활동/스냅샷 API 도 멤버·owner·admin 만(`_require_manage`). 비멤버는 403. `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 작업만 돌려준다 | | 수정/이동 권한 | 서브프로젝트·작업·섹션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 admin(`_require_manage`). 작업 API 는 `_require_task(write=True)` = 원 소속 프로젝트 권한(FULL) |
| 입력 검증 | URL 의 섹션이 URL 의 프로젝트 것인지(`_stage_of_project`), 작업 생성/수정·연결 시 섹션이 그 프로젝트 것인지(`stage_in_project`), 하위 작업의 부모가 같은 프로젝트인지 확인 — 권한은 URL 의 project_id 로 보므로 이걸 안 보면 남의 프로젝트를 건드릴 수 있다 | | 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/섹션/작업/활동/스냅샷 API 도 멤버·owner·admin 만(`_require_manage`). 비멤버는 403. `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 작업만 돌려준다. 연결된(멀티호밍) 작업은 연결된 프로젝트 멤버에게 **읽기 전용**(6-10) |
| 삭제 권한 | **프로젝트·섹션·작업 모두 "만든 사람만"**(슈퍼관리자 예외, 생성자 정보 없는 과거 데이터는 admin 허용) — `_can_delete` 하나로 통일 | | 지금 권한 기준 | 모든 판단은 **지금** 권한(`app/modules/project/access.py`) — 멤버에서 빠진 사람은 예전 담당자·멘션·협업자 기록이 있어도 내 작업·수신함·알림·검색·상세·공유 링크·댓글·첨부에서 그 작업이 보이지 않고, 새 알림·메일도 받지 않는다(기록은 이력으로 남김) |
| 입력 검증 | URL 의 섹션이 URL 의 프로젝트 것인지(`_stage_of_project`), 작업 생성/수정·연결 시 섹션이 그 프로젝트 것인지(`stage_in_project`), 하위 작업의 부모가 같은 프로젝트인지 확인 — 권한은 URL 의 project_id 로 보므로 이걸 안 보면 남의 프로젝트를 건드릴 수 있다. 새 담당자는 그 프로젝트를 볼 수 있는 사람만(400). 날짜 범위(시작 ≤ 마감, 같은 날이면 시작 시각 ≤ 마감 시각)는 부분 수정도 기존 값과 합친 최종 상태로 검사(400) |
| 삭제 권한 | **프로젝트·섹션·작업 모두 "만든 사람만"**(슈퍼관리자 예외, 생성자 정보 없는 과거 데이터는 admin 허용) — `_can_delete` 하나로 통일. **그리고 지금 그 프로젝트 권한이 있어야 한다**(멤버에서 빠진 생성자는 403, DB·휴지통 변화 없음) |
| 멤버 배정 | 여전히 관리자(`is_admin`) 전용. 비관리자가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) | | 멤버 배정 | 여전히 관리자(`is_admin`) 전용. 비관리자가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) |
| 메일 알림 | `app/mail.py` (stdlib smtplib). 작업 배정/완료 시 관리자에게 발송 | | 메일 알림 | `app/mail.py` (stdlib smtplib). 작업 배정/완료 시 관리자에게 발송 |
@@ -507,6 +509,76 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
영역 색은 팝업(body 에 붙임)에서 바로 바뀜. 목표 테이블은 live-version 트리거에 넣지 않았다(입력 중 새로고침 방지). 영역 색은 팝업(body 에 붙임)에서 바로 바뀜. 목표 테이블은 live-version 트리거에 넣지 않았다(입력 중 새로고침 방지).
- 추후: 매출 실적을 실적 모듈(`performance_db`)에서 월별로 자동으로 채우기. - 추후: 매출 실적을 실적 모듈(`performance_db`)에서 월별로 자동으로 채우기.
## 6-10. 권한·저장 안전장치 (2026-09-30 점검 반영, 새 마이그레이션·환경변수 없음)
**권한 공통 기준 — `access.py`** (라우터·마감 알림이 같은 규칙)
- 프로젝트 관리 = 관리자 · owner · 배정 멤버, 모두 `project` 모듈 권한이 있어야 한다(`can_manage_project`).
- 작업 권한 `task_access`: **FULL** = 원 소속 프로젝트 관리 가능 / **READ** = 원 소속 권한은 없지만 이 작업(또는 상위 작업)이
연결된 프로젝트를 관리 가능(`task_link_scope`, 재귀 CTE) / 없음. 라우터 `_require_task(write=)` 가 FULL/READ 를 검사.
- READ 로 되는 것: 작업 상세(`access:"read"`)·하위 작업 목록·댓글 목록·첨부 목록/다운로드/미리보기·공유 링크(연결된 프로젝트
화면으로 이동). 안 되는 것: 제목·설명·담당자·완료·섹션(원 소속)·댓글/답글/반응·첨부 추가/삭제·협업자·삭제·하위 작업 변경.
이미 연결된 작업을 연결된 프로젝트 안에서 섹션 이동(`POST /links`)은 예전처럼 허용, 새 연결은 양쪽 권한. 상세의 `links` 는
내가 볼 수 있는 프로젝트만(다른 연결 프로젝트 이름도 숨김), `followers` 는 READ 면 null. 원 소속의 다른 작업·멤버는 계속 403.
- 목록·배지·알림: 내 작업(`_my_visible_tasks`/`_my_open_count`)·수신함 태그(`_safe_mentions`)·알림(`_visible_notifications`)을
지금 권한으로 거른다(FULL 또는 READ). 기존 기록은 지우지 않는다.
- 알림·메일·멘션 수신자: `filter_recipients` — 지금 그 작업을 볼 수 있는 등록 사용자만(담당자·협업자여도 권한을 잃었으면 제외).
@태그는 볼 수 없는 사람(비멤버·권한 회수·미등록 이메일)을 기록·알림·자동 협업자 등록 없이 건너뛰고 응답 `mention_skipped` 로
알려 준다(payload 에 이메일을 직접 넣어도 같음). 멘션이 권한을 만들지 않는다. 태그 후보 `GET /api/all-users?task_id=`.
- 새 담당자는 그 프로젝트를 볼 수 있는 사람만(`_check_assignee`, 400). 비우거나 예전 값 유지는 허용.
- 댓글 수정·삭제도 지금 원 소속 권한이 있어야 한다(작성자라도 멤버에서 빠지면 403). 첨부는 본인 댓글에만 붙일 수 있다.
**저장·동기화**
- 작업 창 세대(`taskGen`): 창을 열 때마다 +1. 상세·하위 작업·연결·첨부·댓글·담당자 후보·저장 결과는 요청 때 세대를 잡고, 돌아왔을
때 다르면 반영하지 않는다(A→B, A→B→A). 하위 작업·연결 블록도 자체 `ctxSeq` 로 늦은 응답을 버리고, 추가·연결은 누른 순간의
작업 id 로 보낸다. 설명 이미지 업로드는 시작한 작업·세대가 바뀌었으면 설명에 넣지 않는다(파일은 원래 작업 첨부로 남음).
- 자동 저장(`saveField`)은 성공/실패를 돌려준다. 실패한 칸은 `failedFields` 에 남고 "저장 실패 · 다시 시도"(눌러 재시도).
닫기·Esc·다른 작업 열기(`openTaskModal` → `settleBeforeLeave`)는 이미지 업로드·만들기·저장 큐가 끝나길 기다리고 실패한 칸을
한 번 더 보낸 뒤, 그래도 실패하면 "버리고 넘어가기 / 계속 편집"을 묻는다. 버리기를 고를 때만 초안을 버린다(`discardTaskEdits`).
저장 성공 뒤 화면 다시 그리기 오류는 저장 실패로 표시하지 않는다. 미저장(실패·대기·업로드 중)일 때만 페이지 이탈 경고.
- 읽기 전용 작업 창: 제목·설명·담당자·섹션·우선순위·마감일 잠금, 완료·삭제·댓글 입력·첨부 추가·서식 도구·하위 작업 추가·
연결 추가/해제 숨김, 안내줄 `#pj-t-readonly`. 댓글 대화창도 `GET /comments` 의 `access` 로 입력칸을 숨긴다.
- 실시간 동기화(`initLiveRefresh`): `observed`(서버에서 본 버전)와 `applied`(화면에 반영 성공한 버전)를 나눈다. 반영이
성공해야 applied 를 올리고, 실패하면 다음 주기(8→16→32→60초)에 같은 버전을 다시 받는다. 동기화 중엔 겹쳐 돌지 않고, 늦게 온
응답은 버린다(`syncSeq`). 프로젝트 화면은 `GET /api/projects/{id}/snapshot?scope=all` — 화면이 들고 있는 범위(볼 수 있는 모든
최상위 프로젝트의 작업·섹션·프로젝트 목록)를 통째로 바꿔 끼운다(다른 프로젝트의 생성·삭제·섹션 변경·권한 회수 반영, 멀티호밍은
`context_project_id` 별 한 행). 이 프로젝트 권한을 잃으면(403) 작업을 비우고 창을 닫고 안내줄 `.pj-access-lost`.
- 날짜: 업무 기준 "오늘" = 한국시간(`kstTodayIso`, UTC+9 고정) — 대시보드 지연 수·마감 색·오늘/내일·내 작업 필터가 브라우저
시간대와 무관하게 서버(`today_kst`)·마감 알림과 같다.
**댓글 파일** — 파일이 있는 댓글은 `POST /api/tasks/{id}/comments/files`(multipart: `files[]`·`body`·`parent_id`·`mentions`(JSON)·
`client_token`) 한 요청으로, 댓글+첨부를 한 트랜잭션(`add_comment_with_attachments`)에 만든다. 빈 파일·20MB 초과가 하나라도
있으면 아무것도 만들지 않고 400 `detail.failed=[{index,name,reason}]` → 화면은 그 파일만 빨갛게 표시하고 입력·파일을 유지.
DB 실패면 방금 쓴 파일도 지운다. 글 댓글(`POST /comments`)은 본문 필수 — 예전 `has_attachment` 플래그는 받지 않는다.
`client_token` 으로 같은 댓글의 재전송(응답 유실·연타·동시 요청)은 10분간 첫 결과를 돌려준다(웹 프로세스 메모리, 단일 워커 기준).
작업 창 댓글 목록도 댓글별 첨부(이미지 미리보기·파일명 다운로드, 이스케이프)를 보여 주고, 첨부 파일 목록엔 "댓글" 표시.
**마감 알림** — `add_reminder_notification`: 발송 기록(`task_reminders`)과 수신함 알림을 한 트랜잭션에. 알림 생성이 실패하면
기록도 되돌려져 다음 실행에서 다시 시도, 동시 실행도 UNIQUE 로 한 번만. 수신자는 지금 볼 수 있는 사람만. 보장 범위는 수신함
알림까지 — 메일(`PROJECT_REMINDER_EMAIL`)은 새로 만든 알림만 요약해 보내고 메일 실패는 재시도하지 않는다.
**완료 섹션에 바로 만든 작업** — `create_task` 가 완료 섹션이면 `completed_at`·완료 이력(1건)을 넣고, 라우터가 완료 섹션 이동과
같은 완료 알림(`_notify_completed`)을 보낸다. 섹션 없는 하위 작업·수동 완료/취소는 그대로.
**테스트** — `tests/test_project_module.py`(로컬 테스트용 PostgreSQL + FastAPI TestClient, `PROJECT_TEST_DB_URL` 가
localhost 일 때만), `tests/js/project_ui.test.js`(jsdom, `python tests/js/render_project.py` 후 실행, `PJ_TEST_TZ` 로 해외 시간대).
프런트 테스트 훅은 `window.__PJ_TEST__` 가 있을 때만 열린다.
**기존 데이터 점검(조회만 — 운영 교정은 따로 승인 후)**
```sql
-- 시작일 > 마감일(프로젝트·작업), 같은 날 시각 역전
SELECT id, name, start_date, due_date FROM projects WHERE start_date > due_date;
SELECT id, project_id, title, start_date, due_date, start_time, due_time FROM tasks
WHERE start_date > due_date OR (start_date = due_date AND start_time > due_time);
-- 본문도 첨부도 없는 빈 댓글(예전 파일 업로드 실패 흔적)
SELECT c.id, c.task_id, c.author_email, c.created_at FROM task_comments c
WHERE btrim(c.body) = '' AND NOT EXISTS (SELECT 1 FROM task_attachments a WHERE a.comment_id = c.id);
-- 완료 섹션에 있는데 미완료인 작업(예전 완료 섹션 직접 생성)
SELECT t.id, t.title FROM tasks t JOIN project_stages s ON s.id = t.stage_id
WHERE s.is_done_stage AND t.completed_at IS NULL;
```
교정안: 날짜 역전은 담당자와 확인해 한쪽을 고치고, 빈 댓글은 작성자 확인 후 삭제, 완료 섹션 미완료는 완료로 표시하거나 섹션을 옮긴다.
권한을 잃은 사람의 담당자·멘션·협업자 기록은 지우지 않아도 된다(화면·알림은 이미 지금 권한으로 거른다).
## 7. 추후 단계 ## 7. 추후 단계
작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성 · 하위 작업의 하위 작업(다단계 중첩, 작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성 · 하위 작업의 하위 작업(다단계 중첩,
+425
View File
@@ -0,0 +1,425 @@
// 프로젝트 관리 화면(project/project.html + static/project.js) UI 회귀 테스트 — jsdom.
// 서버 응답은 가짜(fetch 대체)로, 지연·실패·순서 역전을 직접 만든다. 실제 브라우저 레이아웃·입력기는 아니다.
//
// python tests/js/render_project.py # 템플릿 렌더 → tests/js/.out/project_render.html
// npm install jsdom # (최초 1회)
// TZ=America/Los_Angeles node tests/js/project_ui.test.js # 해외 시간대 브라우저 흉내
//
// 성공하면 마지막 줄 ALL PASS, 실패하면 항목명과 종료코드 1.
// Git Bash 는 윈도우 프로그램에 TZ 를 넘기지 않아 PJ_TEST_TZ 로도 받는다(날짜 객체를 만들기 전에 설정).
if (process.env.PJ_TEST_TZ) process.env.TZ = process.env.PJ_TEST_TZ;
const fs = require("fs");
const path = require("path");
const { JSDOM } = require("jsdom");
const WATCHDOG = setTimeout(function () { console.log("TIMEOUT — 어딘가에서 멈춤"); process.exit(2); }, 90000);
const ROOT = path.join(__dirname, "..", "..");
const html = fs.readFileSync(path.join(__dirname, ".out", "project_render.html"), "utf8");
const JS = fs.readFileSync(path.join(ROOT, "app", "static", "project.js"), "utf8");
const fails = [];
function check(name, cond, extra) {
if (cond) console.log("PASS " + name);
else { console.log("FAIL " + name + (extra !== undefined ? " → " + JSON.stringify(extra) : "")); fails.push(name); }
}
function deferred() {
let resolve, reject;
const p = new Promise(function (a, b) { resolve = a; reject = b; });
return { promise: p, resolve: resolve, reject: reject };
}
function makeEnv() {
const dom = new JSDOM(html, { runScripts: "dangerously", pretendToBeVisual: true, url: "http://localhost/project/p/1" });
const w = dom.window, d = w.document;
w.__PJ_TEST__ = true;
w.HTMLCanvasElement.prototype.getContext = function () { return null; };
w.URL.createObjectURL = function () { return "blob:x"; };
w.URL.revokeObjectURL = function () {};
w.Image = function () { const self = this; Object.defineProperty(self, "src", { set: function () { setTimeout(function () { if (self.onerror) self.onerror(); }, 0); } }); };
w.console.error = function () {};
let confirmAnswer = false;
w.erpConfirm = function () { env.confirms++; return Promise.resolve(confirmAnswer); };
w.erpAlert = function (m) { env.alerts.push(m); };
w.alert = function (m) { env.alerts.push(m); };
// 8초 이상 타이머(실시간 새로고침)는 붙잡아 두고 테스트가 직접 돌린다.
const realSetTimeout = w.setTimeout.bind(w);
const slow = [];
w.setTimeout = function (fn, ms) {
if (ms >= 8000) { slow.push({ fn: fn, ms: ms }); return 999000 + slow.length; }
return realSetTimeout(fn, ms);
};
const env = {
w: w, d: d, calls: [], routes: [], slow: slow, confirms: 0, alerts: [],
setConfirm: function (v) { confirmAnswer = v; },
route: function (method, re, fn) { env.routes.unshift({ method: method, re: re, fn: fn }); },
runSlow: async function () { const t = slow.shift(); if (t) { t.fn(); await settle(); } return t; },
};
w.fetch = async function (url, opts) {
const method = (opts && opts.method) || "GET";
let body = opts && opts.body;
if (typeof body === "string") { try { body = JSON.parse(body); } catch (_) {} }
env.calls.push({ method: method, url: String(url), body: body });
if (process.env.PJ_TEST_TRACE && method === "PUT") console.log(" TRACE PUT", url, new Error().stack.split("\n").slice(2, 7).join(" | "));
for (const r of env.routes) {
if (r.method === method && r.re.test(String(url))) {
const out = await r.fn(String(url), body);
if (out === "NETWORK") throw new TypeError("Failed to fetch");
const status = out.status || 200;
return { ok: status < 400, status: status, statusText: "x", json: async function () { return out.body; } };
}
}
return { ok: true, status: 200, statusText: "OK", json: async function () { return {}; } };
};
return env;
}
function settle(n) {
return new Promise(function (r) { let i = 0; (function spin() { if (i++ >= (n || 30)) return r(); setImmediate(spin); })(); });
}
function detail(id, title, extra) {
return Object.assign({ id: id, title: title, project_id: 1, stage_id: 11, description: "", priority: "normal",
assignee_email: "", subtasks: [], links: [], followers: [], access: "full", completed_at: null }, extra || {});
}
function baseRoutes(env) {
env.route("GET", /\/project\/api\/tasks\/\d+\/attachments/, function () { return { body: { attachments: [] } }; });
env.route("GET", /\/project\/api\/tasks\/\d+\/comments/, function () { return { body: { comments: [], events: [], features: {} } }; });
env.route("GET", /\/project\/api\/projects\/\d+\/members/, function () { return { body: { members: [{ user_email: "me@test.local" }] } }; });
env.route("GET", /\/project\/api\/projects$/, function () { return { body: { projects: [] } }; });
env.route("GET", /\/project\/api\/all-users/, function () { return { body: { users: [] } }; });
env.route("GET", /\/project\/api\/live-version/, function () { return { body: { ts: "v1" } }; });
env.route("GET", /\/project\/api\/tasks\/101$/, function () { return { body: { task: detail(101, "작업 A") } }; });
env.route("GET", /\/project\/api\/tasks\/102$/, function () { return { body: { task: detail(102, "작업 B") } }; });
}
async function boot(env) {
// jsdom 이 문서를 다 읽고 DOMContentLoaded 를 보낸 뒤에 넣는다 — 먼저 넣으면 초기화가 두 번 돈다.
if (env.d.readyState === "loading") {
await new Promise(function (r) { env.d.addEventListener("DOMContentLoaded", r); });
}
// jsdom 의 <select>·일부 입력은 내부 Proxy 라 value 를 재정의(enhance*)하면 쓰기가 막힌다(실제 브라우저는
// 문제없음, 기존 코드 그대로). 테스트에서는 버튼 보강을 건너뛰고 원래 입력칸으로 시험한다.
env.d.querySelectorAll("select").forEach(function (s) { s.dataset.pjEnhanced = "1"; });
env.d.querySelectorAll("input[type=date]").forEach(function (i) { i.dataset.pjDate = "1"; });
env.w.eval(JS);
env.d.dispatchEvent(new env.w.Event("DOMContentLoaded"));
await settle();
return env.w.__pjProject;
}
function taskOf(P, id) { return P.state().tasks.find(function (t) { return t.id === id && t.context_project_id === 1; }); }
function subsText(d) { // 하위 작업 제목은 입력칸 값이다
return Array.from(d.querySelectorAll("#pj-subtask-list .pj-subtask-title")).map(function (i) { return i.value; }).join("|") ||
d.getElementById("pj-subtask-list").textContent;
}
function wait(ms) { return new Promise(function (r) { setTimeout(r, ms); }); } // 창 닫기 애니메이션(0.32초) 대기
function titleVal(d) { return d.getElementById("pj-t-title").value; }
(async function () {
// ── [05] 한국시간 기준 오늘 ─────────────────────────────
{
const env = makeEnv(); baseRoutes(env); await boot(env);
const H = env.w.__pjHelpers;
const kst = function (y, m, d, hh, mm) { return Date.UTC(y, m - 1, d, hh - 9, mm); };
check("[05] KST 00:00 → 그날", H.kstTodayIso(kst(2026, 9, 30, 0, 0)) === "2026-09-30");
check("[05] KST 08:59(UTC 전날) → 그날", H.kstTodayIso(kst(2026, 9, 30, 8, 59)) === "2026-09-30");
check("[05] KST 09:00 → 그날", H.kstTodayIso(kst(2026, 9, 30, 9, 0)) === "2026-09-30");
check("[05] KST 23:59 → 그날", H.kstTodayIso(kst(2026, 9, 30, 23, 59)) === "2026-09-30");
const realNow = env.w.Date.now;
env.w.Date.now = function () { return kst(2026, 9, 30, 8, 30); };
const y = H.dueInfo("2026-09-29", false), t = H.dueInfo("2026-09-30", false);
check("[05] 해외 시간대(" + (process.env.TZ || "기본") + ")·한국 오전에도 전날 마감=지남", y.cls === "is-overdue" && y.text === "어제", y);
check("[05] 오늘 마감은 지남이 아님", t.cls === "is-soon" && t.text === "오늘", t);
env.w.Date.now = realNow;
}
// ── [09] A→B 전환 중 늦은 A 응답이 B 를 덮지 않는다 ───────────
{
const env = makeEnv(); baseRoutes(env);
const dA = deferred();
env.route("GET", /\/project\/api\/tasks\/101$/, function () { return dA.promise; });
env.route("GET", /\/project\/api\/tasks\/102$/, function () { return { body: { task: detail(102, "작업 B", { subtasks: [{ id: 902, title: "B-sub", project_id: 1 }] }) } }; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await P.openTaskModal(taskOf(P, 102));
await settle();
dA.resolve({ body: { task: detail(101, "작업 A", { subtasks: [{ id: 901, title: "A-sub", project_id: 1 }] }) } });
await settle();
check("[09] 늦은 A 상세가 B 의 하위 작업 목록을 덮지 않음", subsText(d).includes("B-sub") && !subsText(d).includes("A-sub"), subsText(d));
env.route("POST", /\/project\/api\/projects\/1\/tasks$/, function (u, b) { return { status: 201, body: { task: detail(903, b.title, { parent_task_id: b.parent_task_id }) } }; });
d.getElementById("pj-subtask-input").value = "새 하위";
d.getElementById("pj-subtask-add").click();
await settle();
const post = env.calls.filter(function (c) { return c.method === "POST" && /projects\/1\/tasks$/.test(c.url); }).pop();
check("[09] B 화면에서 추가한 하위 작업은 B 에 붙음", post && post.body.parent_task_id === 102, post && post.body);
}
// A→B→A — 같은 작업을 다시 열어도 이전 요청은 버린다
{
const env = makeEnv(); baseRoutes(env);
const dOld = deferred(); let n = 0;
env.route("GET", /\/project\/api\/tasks\/101$/, function () {
n++;
if (n === 1) return dOld.promise;
return { body: { task: detail(101, "작업 A", { subtasks: [{ id: 911, title: "A-new", project_id: 1 }] }) } };
});
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await P.openTaskModal(taskOf(P, 102));
await P.openTaskModal(taskOf(P, 101));
await settle();
dOld.resolve({ body: { task: detail(101, "작업 A", { subtasks: [{ id: 910, title: "A-old", project_id: 1 }] }) } });
await settle();
check("[09] A→B→A 에서 첫 A 의 늦은 응답은 버림", subsText(d).includes("A-new") && !subsText(d).includes("A-old"), subsText(d));
}
// 이미지 업로드 중 A→B 전환 — 업로드가 끝나 A 설명에 들어가고 저장된 뒤에 B 가 열린다
{
const env = makeEnv(); baseRoutes(env);
const up = deferred();
env.route("POST", /\/project\/api\/tasks\/101\/attachments$/, function () { return up.promise; });
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) { return { body: { task: Object.assign(detail(101, "작업 A"), b) } }; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await settle();
const box = d.getElementById("pj-t-desc");
const file = new env.w.File(["x"], "a.png", { type: "image/png" });
const ev = new env.w.Event("paste", { bubbles: true, cancelable: true });
Object.defineProperty(ev, "clipboardData", { value: { items: [{ type: "image/png", getAsFile: function () { return file; } }], getData: function () { return ""; } } });
box.dispatchEvent(ev);
await settle();
const switching = P.openTaskModal(taskOf(P, 102));
await settle();
check("[09] 업로드 중에는 B 로 넘어가지 않고 기다림", d.getElementById("pj-t-id").value === "101");
up.resolve({ status: 201, body: { attachment: { id: 55 } } });
await switching; await settle();
const put = env.calls.filter(function (c) { return c.method === "PUT" && /tasks\/101$/.test(c.url) && c.body.description; }).pop();
check("[09] 업로드된 이미지는 A 설명에 넣어 A 에 저장", !!put && put.body.description.includes("/attachments/55/inline"), put && put.body);
check("[09] 그 다음 B 가 열리고 B 설명엔 이미지 없음", d.getElementById("pj-t-id").value === "102" && !box.innerHTML.includes("/attachments/55/"));
}
// ── [10] 저장 실패 후 닫기 — 유실 없이 재시도/버리기 선택 ─────────
{
const env = makeEnv(); baseRoutes(env);
let putStatus = 500; const puts = [];
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) {
puts.push(b);
return putStatus >= 400 ? { status: putStatus, body: { detail: "서버 오류" } } : { body: { task: Object.assign(detail(101, "작업 A"), b) } };
});
const P = await boot(env); const d = env.d; const modal = d.getElementById("pj-modal-task");
await P.openTaskModal(taskOf(P, 101)); await settle();
const ta = d.getElementById("pj-t-title");
ta.value = "작업 A2"; ta.dispatchEvent(new env.w.Event("blur")); await settle();
check("[10] 실패한 칸 기록 + '저장 실패 · 다시 시도' 표시", P.state().failed.includes("title") && d.getElementById("pj-autosave-state").textContent.includes("저장 실패"), P.state().failed);
check("[10] 저장 안 된 상태면 페이지 이탈 경고 대상", P.state().unsaved === true);
env.setConfirm(false); // 계속 편집
await P.attemptClose(); await settle();
check("[10] 닫기 때 재시도해도 실패 → 묻고, '계속 편집'이면 창·입력 유지", !modal.hidden && titleVal(d) === "작업 A2" && env.confirms === 1);
putStatus = 200;
await P.attemptClose(); await settle(); await wait(400);
check("[10] 다시 닫기 → 재시도 성공 후 닫힘", modal.hidden && puts[puts.length - 1].title === "작업 A2", { hidden: modal.hidden, last: puts[puts.length - 1] });
check("[10] 저장된 상태에서는 이탈 경고 없음", P.state().unsaved === false);
}
{
// 403·지연 + Escape + 버리기, A 실패가 B 상태를 오염시키지 않음
const env = makeEnv(); baseRoutes(env);
const dPut = deferred();
env.route("PUT", /\/project\/api\/tasks\/101$/, function () { return dPut.promise; });
const P = await boot(env); const d = env.d; const modal = d.getElementById("pj-modal-task");
await P.openTaskModal(taskOf(P, 101)); await settle();
d.getElementById("pj-t-priority").value = "high";
d.getElementById("pj-t-priority").dispatchEvent(new env.w.Event("change")); await settle();
d.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Escape", bubbles: true })); await settle();
check("[10] 저장 중 Esc → 저장이 끝날 때까지 창 유지", !modal.hidden);
env.setConfirm(true); // 버리고 넘어가기
const opening = P.openTaskModal(taskOf(P, 102)); await settle();
dPut.resolve({ status: 403, body: { detail: "권한 없음" } });
await opening; await settle();
check("[10] 403 실패 → 버리기 선택 후 B 열림", d.getElementById("pj-t-id").value === "102" && !modal.hidden);
check("[10] A 의 실패가 B 상태를 오염시키지 않음", P.state().failed.length === 0 && d.getElementById("pj-autosave-state").textContent === "", P.state().failed);
}
{
// 네트워크 단절 → 계속 편집, 복구 후 표시줄 클릭으로 재시도
const env = makeEnv(); baseRoutes(env);
let net = false; const puts = [];
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) { puts.push(b); return net ? { body: { task: Object.assign(detail(101, "작업 A"), b) } } : "NETWORK"; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
d.getElementById("pj-t-due").value = "2026-10-10";
d.getElementById("pj-t-due").dispatchEvent(new env.w.Event("change")); await settle();
check("[10] 네트워크 오류 → 마감일 칸 실패로 남음", P.state().failed.includes("due"));
net = true;
const stEl = d.getElementById("pj-autosave-state");
const stBefore = stEl.dataset.state;
stEl.click(); await settle();
check("[10] '다시 시도' → 같은 값으로 재전송 성공", P.state().failed.length === 0 && puts[puts.length - 1].due_date === "2026-10-10",
{ stBefore: stBefore, failed: P.state().failed, puts: puts });
}
// ── [16] 한글 조합 Enter ─────────────────────────────────
{
const env = makeEnv(); baseRoutes(env);
const dPost = deferred();
env.route("POST", /\/project\/api\/tasks\/101\/comments$/, function () { return dPost.promise; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
const inp = d.getElementById("pj-comment-input");
inp.value = "안녕하세요";
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true }));
const ev229 = new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true });
Object.defineProperty(ev229, "keyCode", { value: 229 });
inp.dispatchEvent(ev229);
await settle();
const posts = function () { return env.calls.filter(function (c) { return c.method === "POST" && /101\/comments$/.test(c.url); }); };
check("[16] 조합 중 Enter(isComposing·229)는 댓글 전송 안 함", posts().length === 0);
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
await settle();
check("[16] 조합이 끝난 Enter 연타 → 한 번만 전송", posts().length === 1 && posts()[0].body.client_token, posts().length);
dPost.resolve({ status: 201, body: { comment: { id: 1, body: "안녕하세요" }, mention_skipped: [] } }); await settle();
const sub = d.getElementById("pj-subtask-input");
await settle(); sub.value = "하위";
sub.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true })); await settle();
check("[16] 하위 작업 칸도 조합 중 Enter 는 추가 안 함", !env.calls.some(function (c) { return c.method === "POST" && /projects\/1\/tasks$/.test(c.url); }));
const cm = d.getElementById("pj-cm-input");
env.w.__pjChat.open(101); await settle();
cm.value = "채팅";
cm.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true })); await settle();
check("[16] 댓글 대화창도 조합 중 Enter 는 전송 안 함", posts().length === 1);
}
// ── [03] 파일 댓글 — 실패 파일 표시·유지, 성공 시 비움 ───────────
{
const env = makeEnv(); baseRoutes(env);
let mode = "fail";
env.route("POST", /\/project\/api\/tasks\/101\/comments\/files$/, function () {
if (mode === "fail") return { status: 400, body: { detail: { message: "보낼 수 없는 파일이 있어 댓글을 등록하지 않았습니다.", failed: [{ index: "1", name: "b.png", reason: "빈 파일" }] } } };
if (mode === "net") return "NETWORK";
return { status: 201, body: { comment: { id: 5, body: "" }, attachments: [], mention_skipped: [] } };
});
const P = await boot(env); const d = env.d;
env.w.__pjChat.open(101); await settle();
const cm = d.getElementById("pj-cm-input");
function pasteImg(name, content) {
const f = new env.w.File(content, name, { type: "image/png" });
const ev = new env.w.Event("paste", { bubbles: true, cancelable: true });
Object.defineProperty(ev, "clipboardData", { value: { items: [{ type: "image/png", getAsFile: function () { return f; } }], getData: function () { return ""; } } });
cm.dispatchEvent(ev);
}
pasteImg("a.png", ["aaa"]); pasteImg("b.png", []);
await settle();
d.getElementById("pj-cm-send").click(); await settle();
const chips = function () { return Array.from(d.querySelectorAll("#pj-cm-pending .pj-chat-pending-chip")); };
check("[03] 서버가 거절한 파일만 빨간 표시, 두 파일 모두 남음", chips().length === 2 && chips()[1].classList.contains("is-failed") && !chips()[0].classList.contains("is-failed"));
const sent = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); });
check("[03] 파일은 본문과 한 요청으로(빈 댓글을 먼저 만들지 않음)", sent.length === 1 && !env.calls.some(function (c) { return c.method === "POST" && /101\/comments$/.test(c.url); }));
mode = "net";
d.getElementById("pj-cm-send").click(); await settle();
check("[03] 네트워크 오류 → 파일·입력 유지", chips().length === 2);
const tok1 = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); }).pop().body.get("client_token");
mode = "ok";
d.getElementById("pj-cm-send").click(); await settle();
const tok2 = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); }).pop().body.get("client_token");
check("[03] 응답을 못 받은 재전송은 같은 client_token(서버가 한 번만 만듦)", tok1 && tok1 === tok2);
check("[03] 성공하면 대기 파일 비움", chips().length === 0);
}
// ── [14] 작업 창 댓글에 파일 표시 ─────────────────────────
{
const env = makeEnv(); baseRoutes(env);
env.route("GET", /\/project\/api\/tasks\/101\/comments/, function () {
return { body: { comments: [{ id: 7, body: "", author_email: "me@test.local", created_at: "2026-09-30T10:00" },
{ id: 8, body: "답글", parent_id: 7, author_email: "me@test.local", created_at: "2026-09-30T10:01" }],
events: [], features: { replies: true } } };
});
env.route("GET", /\/project\/api\/tasks\/101\/attachments/, function () {
return { body: { attachments: [{ id: 70, comment_id: 7, filename: "<b>x</b>.pdf", content_type: "application/pdf", size_bytes: 10 },
{ id: 71, comment_id: 8, filename: "r.png", content_type: "image/png", size_bytes: 10 },
{ id: 72, comment_id: null, filename: "plain.txt", content_type: "text/plain", size_bytes: 10 }] } };
});
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
const list = d.getElementById("pj-comment-list");
check("[14] 파일만 있는 댓글에 파일 표시", list.querySelector('a[href="/project/api/attachments/70/download"]') !== null);
check("[14] 파일명은 이스케이프(태그로 해석 안 됨)", !list.querySelector(".pj-comment-atts b") && list.textContent.includes("<b>x</b>.pdf"));
check("[14] 답글의 파일은 답글에", !!list.querySelector(".pj-comment-item.is-reply img[src='/project/api/attachments/71/inline']"));
check("[14] 댓글 아닌 첨부는 댓글에 안 섞임", !list.innerHTML.includes("attachments/72/"));
check("[14] 첨부 목록에 '댓글' 표시", d.getElementById("pj-attach-list").textContent.includes("댓글"));
}
// ── [12] 연결된 작업은 읽기 전용 ─────────────────────────
{
const env = makeEnv(); baseRoutes(env);
env.route("GET", /\/project\/api\/tasks\/301$/, function () {
return { body: { task: detail(301, "연결된 작업", { project_id: 3, project_name: "비밀", access: "read", followers: null, subtasks: [{ id: 3011, title: "읽기 하위", project_id: 3 }] }) } };
});
const P = await boot(env); const d = env.d;
const linked = P.state().tasks.find(function (t) { return t.id === 301; });
await P.openTaskModal(linked); await settle();
check("[12] 제목·담당자 편집 불가", d.getElementById("pj-t-title").readOnly && d.getElementById("pj-t-assignee").disabled);
check("[12] 읽기 전용 안내 표시", !d.getElementById("pj-t-readonly").hidden);
check("[12] 댓글 입력·완료·삭제 숨김", d.getElementById("pj-comment-dock").hidden && d.getElementById("pj-toggle-complete").hidden && d.getElementById("pj-delete-task").hidden);
check("[12] 하위 작업 추가 칸 숨김, 목록은 보임", d.querySelector(".pj-subtask-form").hidden && subsText(d).includes("읽기 하위"));
d.getElementById("pj-t-title").value = "바꿈";
d.getElementById("pj-t-title").dispatchEvent(new env.w.Event("blur")); await settle();
const puts12 = env.calls.filter(function (c) { return c.method === "PUT"; });
check("[12] 읽기 전용이면 저장 요청을 보내지 않음(뒤늦은 403 없음)", puts12.length === 0, puts12);
}
// ── [13][01] 실시간 동기화 — 실패 후 같은 버전 재시도, 전체 범위 반영, 권한 회수 ──
{
const env = makeEnv(); baseRoutes(env);
let ver = "v1", snapMode = "fail";
const dSnap = deferred();
env.route("GET", /\/project\/api\/live-version/, function () { return { body: { ts: ver } }; });
env.route("GET", /\/snapshot\?scope=all/, function () {
if (snapMode === "fail") return { status: 500, body: { detail: "잠시 오류" } };
if (snapMode === "slow") return dSnap.promise;
if (snapMode === "gone") return { status: 403, body: { detail: "권한 없음" } };
return { body: { scope: "all", project: { id: 1, name: "P1" },
projects: [{ id: 1, name: "P1", color: "#4573d2", status: "active" }],
tasks: [{ id: 101, title: "작업 A(새 제목)", project_id: 1, context_project_id: 1, stage_id: 11, stage_name: "할 일" },
{ id: 150, title: "다른 사람이 만든 작업", project_id: 1, context_project_id: 1, stage_id: 13, stage_name: "검토" }],
stages_by_project: { "1": [{ id: 11, project_id: 1, name: "할 일" }, { id: 13, project_id: 1, name: "검토" }] },
stages: [{ id: 11, project_id: 1, name: "할 일" }, { id: 13, project_id: 1, name: "검토" }],
members: [{ user_email: "me@test.local" }] } };
});
const P = await boot(env); const d = env.d;
const st = function () { return env.w.pjLiveRefreshState(); };
const poll = function () { return env.w.__pjLivePoll(); };
const nextDelay = function () { const t = env.slow.filter(function (s) { return s.fn === env.w.__pjLivePoll; }).pop(); return t && t.ms; };
check("[13] 처음 본 버전 = 반영된 버전", st().observed === "v1" && st().applied === "v1");
ver = "v2";
await poll(); await settle();
check("[13] 스냅샷 실패 → 반영 버전은 그대로(v1), 실패 1", st().observed === "v2" && st().applied === "v1" && st().failures === 1, st());
check("[13] 실패 뒤 다음 확인은 늘어난 간격(16초)", nextDelay() === 16000, nextDelay());
snapMode = "ok";
await poll(); await settle();
check("[13] 같은 버전 다음 요청 성공 → v2 반영", st().applied === "v2" && st().failures === 0, st());
const s = P.state();
check("[01] 다른 프로젝트(P2) 작업·사이드바 항목 제거(권한 회수)", !s.tasks.some(function (t) { return t.project_id === 2; }) && !s.projectsMeta.some(function (p) { return p.id === 2; }));
check("[01] 새 작업·새 섹션 반영", s.tasks.some(function (t) { return t.id === 150; }) && s.boardStages.includes("검토"));
check("[01] 제목 변경 반영", s.tasks.find(function (t) { return t.id === 101; }).title === "작업 A(새 제목)");
// 동기화 중 버전이 또 바뀌면 끝난 뒤 한 번 더
snapMode = "slow"; ver = "v3";
const firstPoll = poll();
await settle();
ver = "v4";
const snapsBefore = env.calls.filter(function (c) { return /snapshot/.test(c.url); }).length;
await poll(); // 동기화가 도는 중에 또 확인 — 겹쳐 받지 않는다
const snapsDuring = env.calls.filter(function (c) { return /snapshot/.test(c.url); }).length;
dSnap.resolve({ body: { tasks: [], projects: [{ id: 1, name: "P1", status: "active" }], stages_by_project: {}, stages: [], members: [] } });
await firstPoll; await settle();
check("[13] 동기화 중 새 버전(v4) — 겹쳐 돌지 않고 반영 버전은 v3", st().applied === "v3" && st().observed === "v4" && snapsDuring === snapsBefore, { st: st(), snapsBefore: snapsBefore, snapsDuring: snapsDuring });
snapMode = "ok";
await poll(); await settle();
check("[13] 다음 주기에 v4 반영", st().applied === "v4", st());
snapMode = "gone"; ver = "v5";
await poll(); await settle();
check("[01][02] 이 프로젝트 권한 회수 → 작업 비우고 안내", !!d.querySelector(".pj-access-lost") && P.state().tasks.length === 0);
}
clearTimeout(WATCHDOG);
console.log(fails.length ? "\nFAILED: " + fails.join(", ") : "\nALL PASS");
process.exit(fails.length ? 1 : 0);
})().catch(function (e) { console.error(e); process.exit(1); });
+71
View File
@@ -0,0 +1,71 @@
"""project/project.html 을 테스트용 HTML 로 렌더한다(erp_base.html 은 최소 스텁, 가상의 데이터).
python tests/js/render_project.py # → tests/js/.out/project_render.html
"""
from __future__ import annotations
import io
import os
import jinja2
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
OUT_DIR = os.path.join(ROOT, "tests", "js", ".out")
BASE_STUB = ("{% block head_extra %}{% endblock %}<body>{% block topbar_actions %}{% endblock %}"
"<main class='erp-page'>{% block content %}{% endblock %}</main></body>")
ME = "me@test.local"
STAGES = {
1: [{"id": 11, "project_id": 1, "name": "할 일", "is_done_stage": False, "sort_order": 0, "color": None,
"created_by": ME, "default_assignee_email": ""},
{"id": 12, "project_id": 1, "name": "완료", "is_done_stage": True, "sort_order": 1, "color": None,
"created_by": ME, "default_assignee_email": ""}],
2: [{"id": 21, "project_id": 2, "name": "할 일", "is_done_stage": False, "sort_order": 0, "color": None,
"created_by": ME, "default_assignee_email": ""}],
}
def task(tid: int, title: str, pid: int, stage: int, *, ctx: int | None = None, linked: bool = False) -> dict:
return {"id": tid, "title": title, "project_id": pid, "context_project_id": ctx or pid, "is_linked": linked,
"stage_id": stage, "home_stage_id": stage, "stage_name": "할 일", "is_done_stage": False,
"description": "", "assignee_email": "", "assignee_name": "", "priority": "normal",
"start_date": None, "due_date": None, "completed_at": None, "created_by": ME,
"parent_task_id": None, "comment_count": 0, "subtask_count": 0, "subtask_done": 0,
"project_name": {1: "P1", 2: "P2", 3: "비밀"}[pid], "project_color": "#4573d2", "sort_order": tid}
TASKS = [task(101, "작업 A", 1, 11), task(102, "작업 B", 1, 11), task(103, "작업 C", 2, 21),
task(301, "연결된 작업", 3, 99, ctx=1, linked=True)]
PROJECTS = [{"id": 1, "name": "P1", "color": "#4573d2", "icon": "", "start_date": None, "due_date": None,
"created_by": ME, "description": "", "status": "active"},
{"id": 2, "name": "P2", "color": "#f06a6a", "icon": "", "start_date": None, "due_date": None,
"created_by": ME, "description": "", "status": "active"}]
def main() -> None:
env = jinja2.Environment(loader=jinja2.ChoiceLoader([
jinja2.DictLoader({"erp_base.html": BASE_STUB}),
jinja2.FileSystemLoader(os.path.join(ROOT, "app", "modules", "project", "templates")),
]))
env.globals["pj_kr_holidays"] = {}
html = env.get_template("project/project.html").render(
user={"email": ME, "is_super_admin": False}, is_admin=False, can_manage=True,
project=PROJECTS[0], current_project_id=1, stages=STAGES[1], tasks=TASKS,
members=[{"user_email": ME, "role": "member"}, {"user_email": "bob@test.local", "role": "member"}],
projects_meta=PROJECTS, nav_projects=PROJECTS, stages_by_project=STAGES, board_stage_names=["할 일", "완료"],
avatars={}, priority_labels={"low": "낮음", "normal": "보통", "high": "높음"},
color_palette=["#4573d2"], project_icons=["folder"], stage_color_palette=["#c7c4c4"],
today="2026-09-30", holidays={}, year=2026, month=9, prev_y=2026, prev_m=8, next_y=2026, next_m=10,
weekdays=["일", "월", "화", "수", "목", "금", "토"], weeks=[], goal_years=[2026],
my_open_total=0, mention_unread=0,
)
os.makedirs(OUT_DIR, exist_ok=True)
path = os.path.join(OUT_DIR, "project_render.html")
io.open(path, "w", encoding="utf-8", newline="\n").write(html)
print("rendered:", path)
if __name__ == "__main__":
main()
+471
View File
@@ -0,0 +1,471 @@
"""프로젝트 관리 모듈 — 권한·저장·댓글 첨부·알림 회귀 테스트 (실제 PostgreSQL + FastAPI TestClient).
운영 DB 와 분리된 **로컬 테스트용 PostgreSQL** 에서만 돈다. 가상의 사용자·프로젝트만 만든다.
# 1) 로컬 테스트 DB 에 스키마 적용(최초 1회): project_db_init.sql + project_db_0*.sql
# 2) 실행
PROJECT_TEST_DB_URL=postgresql://postgres@localhost:55432/project_db \
python tests/test_project_module.py
PROJECT_TEST_DB_URL 이 없거나 localhost/127.0.0.1 이 아니면 전부 건너뛴다(운영 DB 보호).
메일은 app.mail.send_email 을 가짜로 바꿔 기록만 한다(실제 발송 없음).
"""
from __future__ import annotations
import io
import os
import sys
import tempfile
import threading
import types
import uuid
from datetime import timedelta
from urllib.parse import urlparse
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
DSN = os.getenv("PROJECT_TEST_DB_URL", "")
_host = urlparse(DSN).hostname if DSN else None
ENABLED = bool(DSN) and _host in ("localhost", "127.0.0.1")
# ── app.main 대역(전체 앱을 띄우지 않고 프로젝트 라우터만 시험) ──────────────
class _Users:
def __init__(self) -> None:
self.d: dict[str, dict] = {}
def add(self, email: str, *, role: str = "user", project: bool = True, super_: bool = False) -> str:
email = email.lower()
self.d[email] = {"email": email, "name": email.split("@")[0], "role": role,
"modules": {"project": project}, "is_super_admin": super_}
return email
def get(self, email: str):
return self.d.get((email or "").lower())
def list_all(self):
return list(self.d.values())
USERS = _Users()
SENT_MAIL: list[dict] = []
if ENABLED:
from fastapi.responses import HTMLResponse
fake_main = types.ModuleType("app.main")
fake_main.user_store = USERS
def _current(request):
return USERS.get(request.headers.get("x-test-user", ""))
fake_main.get_current_user_record = _current
fake_main.build_erp_nav = lambda user, active="": []
fake_main.render_template = lambda request, name, ctx, status_code=200: HTMLResponse(
f"{name}|{ctx.get('reason', '')}", status_code=status_code)
sys.modules["app.main"] = fake_main
for k in list(os.environ):
if k.startswith("SMTP_") or k == "PROJECT_NOTIFY_EMAIL":
os.environ.pop(k)
import app.mail as _mail # noqa: E402
_mail.send_email = lambda **kw: SENT_MAIL.append(kw)
from fastapi import FastAPI # noqa: E402
from fastapi.testclient import TestClient # noqa: E402
from app.modules.project import reminders # noqa: E402
from app.modules.project import router as project_api_router # noqa: E402 - 패키지가 APIRouter 를 내보낸다
from app.modules.project.db import ProjectStore # noqa: E402
from app.timezone import today_kst # noqa: E402
ST = ProjectStore(DSN)
DATA_DIR = tempfile.mkdtemp(prefix="pj-test-")
APP = FastAPI()
APP.include_router(project_api_router)
APP.state.project_store = ST
APP.state.data_dir = DATA_DIR
CLIENT = TestClient(APP)
RUN = uuid.uuid4().hex[:6]
ADMIN = USERS.add(f"admin-{RUN}@test.local", role="admin")
SUPER = USERS.add("king@dbxcorp.co.kr", role="admin", super_=True)
ALICE = USERS.add(f"alice-{RUN}@test.local")
BOB = USERS.add(f"bob-{RUN}@test.local")
CAROL = USERS.add(f"carol-{RUN}@test.local")
DAVE = USERS.add(f"dave-{RUN}@test.local") # 프로젝트 권한은 있으나 어디에도 멤버 아님
EVE = USERS.add(f"eve-{RUN}@test.local", project=False) # 프로젝트 모듈 권한 없음
def req(method: str, url: str, who: str, **kw):
return CLIENT.request(method, url, headers={"x-test-user": who}, **kw)
def _project(name: str, owner: str, members: tuple[str, ...] = ()) -> dict:
p = ST.create_project(name=f"{name}-{uuid.uuid4().hex[:4]}", owner_email=owner, created_by=owner)
for m in members:
ST.add_member(project_id=p["id"], user_email=m)
return p
def _stage(pid: int, name: str = "할 일", done: bool = False, by: str = "") -> dict:
return ST.add_stage(project_id=pid, name=name, is_done_stage=done, created_by=by)
def _count(sql: str, *args) -> int:
with ST._pool.connection() as conn: # noqa: SLF001 - 테스트 전용 확인 쿼리
return int(conn.execute(sql, args).fetchone()["n"])
# ════════════════════════════════════════════════════════════
# [07] 소유자 변경은 관리자만
# ════════════════════════════════════════════════════════════
def test_owner_change_admin_only():
p = _project("P-owner", ADMIN, (BOB,))
r = req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": BOB})
assert r.status_code == 403, r.text
assert ST.get_project(project_id=p["id"])["owner_email"] == ADMIN
r = req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": CAROL, "name": "x"})
assert r.status_code == 403 and ST.get_project(project_id=p["id"])["name"] != "x"
# 같은 값을 같이 보내는 건(화면 저장) 통과
assert req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": ADMIN, "name": "ok"}).status_code == 200
# 관리자: 모듈 권한 없는 사람은 소유자 불가, 정상 사용자는 가능
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": EVE}).status_code == 400
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": CAROL}).status_code == 200
assert ST.get_project(project_id=p["id"])["owner_email"] == CAROL
# 소유자에서 빠지면(관리자가 다시 바꿈) 멤버가 아닌 CAROL 은 관리 권한을 잃는다
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": ADMIN}).status_code == 200
assert req("GET", f"/project/api/projects/{p['id']}/snapshot", CAROL).status_code == 403
# 생성: 비관리자가 남을 소유자로 지정 → 거절, 본인·미지정 → 본인이 소유자
assert req("POST", "/project/api/projects", BOB, json={"name": "n1", "owner_email": CAROL}).status_code == 403
r = req("POST", "/project/api/projects", BOB, json={"name": "n2"})
assert r.status_code == 201 and r.json()["project"]["owner_email"] == BOB
# ════════════════════════════════════════════════════════════
# [06] 삭제 — 생성자 규칙 + 지금 권한
# ════════════════════════════════════════════════════════════
def test_delete_requires_current_access():
p = _project("P-del", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
t = req("POST", f"/project/api/projects/{p['id']}/tasks", ALICE, json={"title": "alice task", "stage_id": s["id"]}).json()["task"]
ST.add_comment(task_id=t["id"], author_email=ALICE, author_name="a", body="hi")
trash_before = _count("SELECT COUNT(*) AS n FROM project_trash")
# 현재 멤버인 타인 → 생성자 규칙으로 거절
assert req("DELETE", f"/project/api/tasks/{t['id']}", BOB).status_code == 403
# 멤버에서 빠진 생성자 → 거절, 행·댓글·휴지통 변화 없음
ST.remove_member(project_id=p["id"], user_email=ALICE)
assert req("DELETE", f"/project/api/tasks/{t['id']}", ALICE).status_code == 403
assert ST.get_task(task_id=t["id"]) is not None
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id = %s", t["id"]) == 1
assert _count("SELECT COUNT(*) AS n FROM project_trash") == trash_before
# 다시 멤버가 된 생성자 → 삭제(휴지통)
ST.add_member(project_id=p["id"], user_email=ALICE)
r = req("DELETE", f"/project/api/tasks/{t['id']}", ALICE)
assert r.status_code == 200 and ST.get_task(task_id=t["id"]) is None
# 프로젝트 삭제: 만든 사람이어도 지금 권한이 없으면 거절, 슈퍼관리자는 예외
p2 = _project("P-del2", ALICE)
ST.update_project(project_id=p2["id"], fields={"owner_email": ADMIN}) # 관리자가 소유자를 바꿈
assert req("DELETE", f"/project/api/projects/{p2['id']}", ALICE).status_code == 403
assert ST.get_project(project_id=p2["id"]) is not None
assert req("DELETE", f"/project/api/projects/{p2['id']}", SUPER).status_code == 200
# ════════════════════════════════════════════════════════════
# [02] 권한 회수 후 조회·변경·알림
# ════════════════════════════════════════════════════════════
def test_revoked_member_loses_everything():
p = _project("P-rev", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
t = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB,
json={"title": "shared", "stage_id": s["id"], "assignee_email": ALICE,
"description": f'<span class="pj-mention" data-email="{ALICE}">@a</span>'}).json()["task"]
c = req("POST", f"/project/api/tasks/{t['id']}/comments", ALICE, json={"body": "mine"}).json()["comment"]
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/my-tasks", ALICE).json()["tasks"])
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", ALICE).json()["tasks"])
assert any(n["task_id"] == t["id"] for n in req("GET", "/project/api/notifications", ALICE).json()["notifications"])
ST.remove_member(project_id=p["id"], user_email=ALICE)
assert not any(x["id"] == t["id"] for x in req("GET", "/project/api/my-tasks", ALICE).json()["tasks"])
assert not any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", ALICE).json()["tasks"])
assert not any(n.get("task_id") == t["id"] for n in req("GET", "/project/api/notifications", ALICE).json()["notifications"])
for m, u, body in (("GET", f"/project/api/tasks/{t['id']}", None),
("GET", f"/project/api/tasks/{t['id']}/comments", None),
("GET", f"/project/api/tasks/{t['id']}/attachments", None),
("PUT", f"/project/api/tasks/{t['id']}", {"title": "x"}),
("PUT", f"/project/api/comments/{c['id']}", {"body": "edited"}),
("DELETE", f"/project/api/comments/{c['id']}", None),
("POST", f"/project/api/tasks/{t['id']}/followers", {})):
r = req(m, u, ALICE, json=body) if body is not None else req(m, u, ALICE)
assert r.status_code == 403, (m, u, r.status_code)
assert ST.get_comment(comment_id=c["id"])["body"] == "mine"
assert req("GET", f"/project/t/{t['id']}", ALICE, follow_redirects=False).status_code == 403 # 옛 공유 링크
# 완료 알림은 권한 잃은 담당자에게 가지 않는다(담당자 기록은 남음)
before = _count("SELECT COUNT(*) AS n FROM project_notifications WHERE recipient_email=%s AND task_id=%s", ALICE, t["id"])
assert req("PUT", f"/project/api/tasks/{t['id']}", BOB, json={"completed": True}).status_code == 200
assert _count("SELECT COUNT(*) AS n FROM project_notifications WHERE recipient_email=%s AND task_id=%s", ALICE, t["id"]) == before
assert ST.get_task(task_id=t["id"])["assignee_email"] == ALICE
# 권한 없는 사람을 새 담당자로 지정할 수 없다
assert req("PUT", f"/project/api/tasks/{t['id']}", BOB, json={"assignee_email": DAVE}).status_code == 400
# 관리자·owner·멤버는 그대로
assert req("GET", f"/project/api/tasks/{t['id']}", ADMIN).status_code == 200
assert req("GET", f"/project/api/tasks/{t['id']}", BOB).status_code == 200
# ════════════════════════════════════════════════════════════
# [08] 비멤버 @태그
# ════════════════════════════════════════════════════════════
def test_mentions_only_for_people_who_can_see():
p = _project("P-men", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
desc = "".join(f'<span class="pj-mention" data-email="{e}">@x</span>' for e in (DAVE, EVE, "ghost@nowhere.test"))
r = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "m", "stage_id": s["id"], "description": desc})
t = r.json()["task"]
assert set(r.json()["mention_skipped"]) == {DAVE, EVE, "ghost@nowhere.test"}
assert _count("SELECT COUNT(*) AS n FROM task_mentions WHERE task_id=%s", t["id"]) == 0
r = req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "@dave hi", "mentions": [DAVE]})
assert r.status_code == 201 and r.json()["mention_skipped"] == [DAVE]
assert not req("GET", "/project/api/mentions", DAVE).json()["tasks"] or \
all(x["id"] != t["id"] for x in req("GET", "/project/api/mentions", DAVE).json()["tasks"])
# 멘션이 접근 권한을 만들지 않는다
assert req("GET", f"/project/api/tasks/{t['id']}", DAVE).status_code == 403
# 연결된 프로젝트 멤버는 태그 가능(읽기 권한)
p2 = _project("P-men2", ADMIN, (BOB, CAROL))
s2 = _stage(p2["id"], by=ADMIN)
assert req("POST", f"/project/api/tasks/{t['id']}/links", BOB, json={"project_id": p2["id"], "stage_id": s2["id"]}).status_code == 201
r = req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "@carol", "mentions": [CAROL]})
assert r.json()["mention_skipped"] == []
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", CAROL).json()["tasks"])
# 태그 후보 API 도 같은 기준
cands = {u["email"] for u in req("GET", f"/project/api/all-users?task_id={t['id']}", BOB).json()["users"]}
assert CAROL in cands and BOB in cands and DAVE not in cands and EVE not in cands
# ════════════════════════════════════════════════════════════
# [12] 연결된 프로젝트 — 읽기 전용
# ════════════════════════════════════════════════════════════
def test_linked_task_is_read_only():
home = _project("P-home", ADMIN, (BOB,))
other = _project("P-link", ADMIN, (BOB, CAROL))
secret = _project("P-secret", ADMIN, (BOB,))
hs, os_ = _stage(home["id"], by=ADMIN), _stage(other["id"], by=ADMIN)
os2 = _stage(other["id"], name="진행", by=ADMIN)
ss = _stage(secret["id"], by=ADMIN)
t = ST.create_task(project_id=home["id"], title="linked", stage_id=hs["id"], created_by=BOB)
sib = ST.create_task(project_id=home["id"], title="sibling", stage_id=hs["id"], created_by=BOB)
sub = ST.create_task(project_id=home["id"], title="child", parent_task_id=t["id"], created_by=BOB)
for pid, sid in ((other["id"], os_["id"]), (secret["id"], ss["id"])):
assert req("POST", f"/project/api/tasks/{t['id']}/links", BOB, json={"project_id": pid, "stage_id": sid}).status_code == 201
r = req("GET", f"/project/api/tasks/{t['id']}", CAROL)
assert r.status_code == 200 and r.json()["task"]["access"] == "read"
assert [ln["project_id"] for ln in r.json()["task"]["links"]] == [other["id"]] # 비밀 프로젝트는 숨김
assert r.json()["task"]["followers"] is None
assert req("GET", f"/project/api/tasks/{sub['id']}", CAROL).json()["task"]["access"] == "read" # 하위 작업도 읽기
assert req("GET", f"/project/api/tasks/{sib['id']}", CAROL).status_code == 403 # 원 소속의 다른 작업은 안 보임
assert req("GET", f"/project/api/projects/{home['id']}/members", CAROL).status_code == 403
assert req("GET", f"/project/api/tasks/{t['id']}/comments", CAROL).status_code == 200
for m, u, body in (("PUT", f"/project/api/tasks/{t['id']}", {"title": "hack"}),
("POST", f"/project/api/tasks/{t['id']}/comments", {"body": "hi"}),
("DELETE", f"/project/api/tasks/{t['id']}", None)):
r = req(m, u, CAROL, json=body) if body is not None else req(m, u, CAROL)
assert r.status_code == 403, (m, u, r.status_code)
assert ST.get_task(task_id=t["id"])["title"] == "linked"
# 연결된 프로젝트 안의 섹션 이동은 예전처럼 허용
assert req("POST", f"/project/api/tasks/{t['id']}/links", CAROL, json={"project_id": other["id"], "stage_id": os2["id"]}).status_code == 201
# 공유 링크 — 연결된 프로젝트 화면으로
r = req("GET", f"/project/t/{t['id']}", CAROL, follow_redirects=False)
assert r.status_code == 303 and r.headers["location"] == f"/project/p/{other['id']}?task={t['id']}"
# 전체 스냅샷에서 연결 행은 연결된 프로젝트 맥락으로 한 번씩(원 소속 행은 CAROL 에게 없음)
snap = req("GET", f"/project/api/projects/{other['id']}/snapshot?scope=all", CAROL).json()
rows = [x for x in snap["tasks"] if x["id"] == t["id"]]
assert [(x["context_project_id"], x["is_linked"]) for x in rows] == [(other["id"], True)]
# 연결 해제 후엔 볼 수 없다
assert req("DELETE", f"/project/api/tasks/{t['id']}/links/{other['id']}", BOB).status_code == 200
assert req("GET", f"/project/api/tasks/{t['id']}", CAROL).status_code == 403
# ════════════════════════════════════════════════════════════
# [03] 파일 댓글 — 원자적 등록·재전송 중복 방지
# ════════════════════════════════════════════════════════════
def test_file_comment_atomic_and_idempotent():
p = _project("P-file", ADMIN, (BOB, CAROL))
s = _stage(p["id"], by=ADMIN)
t = ST.create_task(project_id=p["id"], title="files", stage_id=s["id"], created_by=BOB)
url = f"/project/api/tasks/{t['id']}/comments/files"
n0 = _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"])
# JSON 경로: 예전 has_attachment 플래그로 빈 댓글을 만들 수 없다
assert req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "", "has_attachment": True}).status_code == 400
# 한 파일이라도 문제면(빈 파일) 아무것도 만들지 않고 어느 파일인지 알려 준다
r = req("POST", url, BOB, files=[("files", ("ok.txt", b"hello", "text/plain")), ("files", ("empty.txt", b"", "text/plain"))])
assert r.status_code == 400 and [f["name"] for f in r.json()["detail"]["failed"]] == ["empty.txt"]
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0
assert not os.path.isdir(os.path.join(DATA_DIR, "project", str(t["id"]))) or \
not os.listdir(os.path.join(DATA_DIR, "project", str(t["id"])))
# 정상: 본문 없이 파일 두 개, 같은 토큰으로 두 번 보내도 한 번만
files = [("files", ("a.png", b"\x89PNG....", "image/png")), ("files", ("b.pdf", b"%PDF-1", "application/pdf"))]
r1 = req("POST", url, BOB, data={"client_token": "tok-1"}, files=files)
r2 = req("POST", url, BOB, data={"client_token": "tok-1"}, files=files)
assert r1.status_code == 201 and r2.status_code == 201
assert r1.json()["comment"]["id"] == r2.json()["comment"]["id"] and r2.json().get("duplicate")
cid = r1.json()["comment"]["id"]
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0 + 1
assert _count("SELECT COUNT(*) AS n FROM task_attachments WHERE comment_id=%s", cid) == 2
# DB 저장 실패 → 방금 쓴 파일도 지우고 댓글 없음
orig = ST.add_comment_with_attachments
ST.add_comment_with_attachments = lambda **kw: (_ for _ in ()).throw(RuntimeError("db down"))
try:
before_files = set(os.listdir(os.path.join(DATA_DIR, "project", str(t["id"]))))
try:
req("POST", url, BOB, files=[("files", ("c.txt", b"data", "text/plain"))])
except RuntimeError:
pass # TestClient 가 서버 예외를 그대로 올린다(운영에선 500)
assert set(os.listdir(os.path.join(DATA_DIR, "project", str(t["id"])))) == before_files
finally:
ST.add_comment_with_attachments = orig
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0 + 1
# 남의 댓글에 파일을 붙일 수 없다
r = req("POST", f"/project/api/tasks/{t['id']}/attachments", CAROL,
data={"comment_id": str(cid)}, files={"file": ("x.txt", b"x", "text/plain")})
assert r.status_code == 403
# 동시에 같은 토큰 두 개 → 댓글 하나
out = []
ths = [threading.Thread(target=lambda: out.append(req("POST", url, BOB, data={"client_token": "tok-par"},
files=[("files", ("p.txt", b"p", "text/plain"))]).json()))
for _ in range(2)]
[th.start() for th in ths]
[th.join() for th in ths]
assert len({o["comment"]["id"] for o in out}) == 1
# ════════════════════════════════════════════════════════════
# [04] 날짜 범위
# ════════════════════════════════════════════════════════════
def test_date_range_validation():
p = _project("P-date", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
base = f"/project/api/projects/{p['id']}/tasks"
assert req("POST", base, BOB, json={"title": "bad", "stage_id": s["id"], "start_date": "2026-10-05", "due_date": "2026-10-01"}).status_code == 400
t = req("POST", base, BOB, json={"title": "ok", "stage_id": s["id"], "start_date": "2026-10-01", "due_date": "2026-10-05"}).json()["task"]
u = f"/project/api/tasks/{t['id']}"
assert req("PUT", u, BOB, json={"due_date": "2026-09-30"}).status_code == 400 # 한쪽만 바꿔도 최종 상태 검사
assert ST.get_task(task_id=t["id"])["due_date"] == "2026-10-05"
assert req("PUT", u, BOB, json={"start_date": None}).status_code == 200 # null 로 지우기
assert req("PUT", u, BOB, json={"due_date": "2026-09-30"}).status_code == 200 # 시작일 없으면 허용
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "18:00", "due_time": "09:00"}).status_code == 400
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "00:00", "due_time": "23:59"}).status_code == 200
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "09:00", "due_time": "09:00"}).status_code == 200
# 프로젝트도 같은 규칙(부분 수정 포함)
pu = f"/project/api/projects/{p['id']}"
assert req("PUT", pu, BOB, json={"start_date": "2026-11-01", "due_date": "2026-10-01"}).status_code == 400
assert req("PUT", pu, BOB, json={"due_date": "2026-10-01"}).status_code == 200
assert req("PUT", pu, BOB, json={"start_date": "2026-11-01"}).status_code == 400
assert req("POST", "/project/api/projects", BOB, json={"name": "d", "start_date": "2026-11-02", "due_date": "2026-11-01"}).status_code == 400
# ════════════════════════════════════════════════════════════
# [11] 완료 섹션에 바로 만든 작업
# ════════════════════════════════════════════════════════════
def test_create_in_done_stage_completes():
p = _project("P-done", ADMIN, (ALICE, BOB))
todo, done = _stage(p["id"], by=ADMIN), _stage(p["id"], name="완료", done=True, by=ADMIN)
SENT_MAIL.clear()
r = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "done now", "stage_id": done["id"], "assignee_email": ALICE})
t = r.json()["task"]
assert t["completed_at"] and "_newly_completed" not in t
assert _count("SELECT COUNT(*) AS n FROM project_activity WHERE task_id=%s AND action='completed'", t["id"]) == 1
assert _count("SELECT COUNT(*) AS n FROM project_notifications WHERE task_id=%s AND type='completed' AND recipient_email=%s", t["id"], ALICE) == 1
# 일반 섹션 생성 → 미완료, 완료 섹션으로 이동 → 완료(이력 1건 더), 이탈 → 미완료
t2 = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "later", "stage_id": todo["id"]}).json()["task"]
assert not t2["completed_at"]
assert req("PUT", f"/project/api/tasks/{t2['id']}", BOB, json={"stage_id": done["id"]}).json()["task"]["completed_at"]
assert not req("PUT", f"/project/api/tasks/{t2['id']}", BOB, json={"stage_id": todo["id"]}).json()["task"]["completed_at"]
# 섹션 없는 하위 작업: 수동 완료/취소
sub = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "sub", "parent_task_id": t2["id"]}).json()["task"]
assert sub["stage_id"] is None and not sub["completed_at"]
assert req("PUT", f"/project/api/tasks/{sub['id']}", BOB, json={"completed": True}).json()["task"]["completed_at"]
assert not req("PUT", f"/project/api/tasks/{sub['id']}", BOB, json={"completed": False}).json()["task"]["completed_at"]
# ════════════════════════════════════════════════════════════
# [15] 마감 알림 — 원자적·재시도·중복 방지·권한
# ════════════════════════════════════════════════════════════
def test_due_reminders_atomic_and_access():
p = _project("P-rem", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
today = today_kst()
t_ok = ST.create_task(project_id=p["id"], title=f"rem-ok-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
t_gone = ST.create_task(project_id=p["id"], title=f"rem-gone-{RUN}", stage_id=s["id"], assignee_email=ALICE, due_date=today.isoformat(), created_by=BOB)
t_fail = ST.create_task(project_id=p["id"], title=f"FAILME-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
ST.remove_member(project_id=p["id"], user_email=ALICE)
q = "SELECT COUNT(*) AS n FROM project_notifications WHERE task_id=%s AND type='due_today'"
qr = "SELECT COUNT(*) AS n FROM task_reminders WHERE task_id=%s"
with ST._pool.connection() as conn: # noqa: SLF001 - 테스트 DB 에서만: 알림 생성 실패 흉내
conn.execute(f"ALTER TABLE project_notifications ADD CONSTRAINT test_fail_{RUN} CHECK (title NOT LIKE '%%FAILME-{RUN}%%')")
try:
reminders.run_due_reminders(ST, today=today, lookup=USERS.get)
assert _count(q, t_ok["id"]) == 1 and _count(q, t_gone["id"]) == 0
assert _count(q, t_fail["id"]) == 0 and _count(qr, t_fail["id"]) == 0 # 실패 → 기록도 되돌려짐
finally:
with ST._pool.connection() as conn: # noqa: SLF001
conn.execute(f"ALTER TABLE project_notifications DROP CONSTRAINT test_fail_{RUN}")
reminders.run_due_reminders(ST, today=today, lookup=USERS.get) # 재실행: 실패분만 생성
assert _count(q, t_fail["id"]) == 1 and _count(q, t_ok["id"]) == 1
# 동시 실행에도 중복 없음
t_par = ST.create_task(project_id=p["id"], title=f"rem-par-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
ths = [threading.Thread(target=reminders.run_due_reminders, args=(ST,), kwargs={"today": today, "lookup": USERS.get}) for _ in range(4)]
[th.start() for th in ths]
[th.join() for th in ths]
assert _count(q, t_par["id"]) == 1
assert _count(q, t_gone["id"]) == 0 and _count(qr, t_gone["id"]) == 0
# ════════════════════════════════════════════════════════════
# [01] 전체 범위 스냅샷 — 다른 프로젝트의 생성·삭제·섹션 변경·권한 회수
# ════════════════════════════════════════════════════════════
def test_snapshot_all_scope():
a = _project("P-sa", ADMIN, (BOB,))
b = _project("P-sb", ADMIN, (BOB,))
sa, sb = _stage(a["id"], by=ADMIN), _stage(b["id"], by=ADMIN)
tb = ST.create_task(project_id=b["id"], title="in b", stage_id=sb["id"], created_by=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert {a["id"], b["id"]} <= {x["id"] for x in snap["projects"]}
assert any(x["id"] == tb["id"] for x in snap["tasks"]) and str(b["id"]) in snap["stages_by_project"]
sb2 = _stage(b["id"], name="new", by=ADMIN)
ST.delete_task(task_id=tb["id"], deleted_by=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert not any(x["id"] == tb["id"] for x in snap["tasks"])
assert sb2["id"] in [s["id"] for s in snap["stages_by_project"][str(b["id"])]]
ST.remove_member(project_id=b["id"], user_email=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert b["id"] not in {x["id"] for x in snap["projects"]} and str(b["id"]) not in snap["stages_by_project"]
ST.remove_member(project_id=a["id"], user_email=BOB)
assert req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).status_code == 403
_ = sa
def test_store_date_range_unit():
from app.modules.project import store
store.validate_date_range(None, "2026-01-01")
store.validate_date_range("2026-01-01", None, "10:00", None)
store.validate_date_range("2026-01-01", "2026-01-01", "23:59", None)
for args in (("2026-01-02", "2026-01-01"), ("2026-01-01", "2026-01-01", "10:01", "10:00")):
try:
store.validate_date_range(*args)
except ValueError:
continue
raise AssertionError(args)
if __name__ == "__main__":
if not ENABLED:
print("SKIP: PROJECT_TEST_DB_URL(localhost) not set")
sys.exit(0)
n = 0
for name, fn in sorted(globals().items()):
if name.startswith("test_") and callable(fn):
fn()
n += 1
print("ok", name)
print(f"{n} tests passed")
ST.close()
_ = io, timedelta