3 Commits

Author SHA1 Message Date
king 89ad338024 fix(project): review fixes — access leaks, open paths, save safety, concurrency
- Subproject tasks via parent /tasks are re-filtered by current access (FULL/READ kept)
- PUT /api/projects/order: every id must be manageable; bad/duplicate ids -> 400, all-or-nothing
- Inbox, web alert popup, PC notifier open tasks via /project/t/{id}; embed=1 survives redirect;
  old /p/{home}?task= redirects READ users to the linked project
- Project page / snapshot / workload include the opened archived or sub project only
- Alerts: DB-side filters + oldest-first paging (no 50-row cut); badges counted without caps;
  my tasks keep every open task (completed capped)
- Meeting results: next-week meeting open, or own meeting open when no next meeting;
  header edits + result checks under row locks (FOR UPDATE / FOR SHARE)
- Inbox panel waits for the task window save (same retry/discard flow) before switching/closing;
  read failures stay unread
- Attachment upload removes only its own file on DB failure
- New project modal: create once, retry only failed member assignments
- update_task / update_project: locked-row validation in one transaction; completion hints from real transition
- Creator added as explicit member when another owner is chosen
- _once lock lifetime managed by refcount (no leak on failure)
- Section default assignee must still be a registered project user; follower add uses can_assign
- Docs (PROJECT_MODULE 6-15, help), tests (DB-less, real PostgreSQL, jsdom, Chrome)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 11:08:56 +09:00
king c07a3466a0 Merge branch 'feat/project-role-tiers' 2026-10-12 01:10:33 +09:00
king 5d054e59b6 feat(project): 4-tier roles (super/admin/pro/user), meeting header 구분
- app.store: role "pro" (ROLES, ROLE_LABELS); admin page grade select
  Admin / Pro user / User, super admin fixed to one account.
- project.access: role_of, is_pro, is_project_admin.
- router: _require_admin -> _require_pro (goals, meetings complete/delete,
  members, reorder, trash restore, assignable users); new project and
  project edit/owner change need Pro user+; task delete open to any member;
  project/section delete = Admin+ or creator; comment edit/delete of others
  and workload summary = Pro user+. Templates get pj_pro / pj_admin.
- Weekly meeting table first header "구역" -> "구분".
- Docs (CLAUDE.md, PROJECT_MODULE 6-14, overview, help page) and tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 01:10:25 +09:00
36 changed files with 2438 additions and 652 deletions
+1 -1
View File
@@ -36,7 +36,7 @@ Codex는 이 저장소에서 작업을 시작하기 전에 **반드시 아래
- 말레이시아 창고 재고관리 (`app/modules/malaysia/`, `malaysia_stock_db`) — 낱개(MT/MX/MZ) 입출고·조정, 세트(MY) BOM, 일일 재고조사(세트→낱개 자동 분해), 현재고 현황. 뚜껑(MD-)은 재고 집계 제외 — 단, 창고 랙에는 위치 확인용으로 배치 가능(`store.LID_ITEMS`). 상품은 `itemcode_db` 읽기 전용. 권한키 `malaysia`
- 말레이시아 배송 (`app/modules/dispatch/`, `dispatch_db`) — TikTok·Shopee 출고관리. 플랫폼별 데이터 엑셀 업로드(TikTok=03_TikTok_Order_Export.xlsx, Shopee=Packing List.Doorstep Delivery.xlsx) → 1박스=1카드 출고 작업 리스트·SKU 피킹 요약·Kagayaku 전달표 자동 생성. 1박스 묶음 기준 Package ID > Tracking ID > Order ID, 같은 박스 같은 SKU 합산. 작업 상태 토글(`dispatch_logs` 기록). 받는 사람 이름/전화/주소는 박스 단위로 저장(작업 카드 표시 + 출고 엑셀 생성용 — 개인정보). 배치 다운로드 zip 에 업로드 원본 + 취합 출고 엑셀(`YYYY.MM.DD(Ddd)_tictoc|shopee.xlsx`) 포함. 엑셀은 openpyxl 파싱/생성. 권한키 `dispatch`. 상세는 `docs/DISPATCH_MODULE.md`
- 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·자동복원·버전 롤백·일괄수정. 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지. 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력. 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지). 예약은 DB 저장 + 별도 worker(`app/modules/cafe24/worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다. 권한키 `cafe24`(연결/해제는 admin 전용). 상세는 `docs/CAFE24_MODULE.md`
- 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·업무(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed)·멤버 배정(`project_members`)·활동이력(`project_activity`). 메인 뷰 달력(FullCalendar)/타임라인(vis-timeline) 버튼 토글 + 보드(드래그로 단계 이동)/리스트. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성/삭제·사용자 배정은 `is_admin` 만, 배정 멤버(또는 owner)는 서브프로젝트/업무/단계 CRUD. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 업무 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 상세는 `docs/PROJECT_MODULE.md`
- 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·업무(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 새 프로젝트는 섹션 없이 시작)·멤버 배정(`project_members`)·활동이력(`project_activity`). 메인 뷰 달력(FullCalendar)/타임라인(vis-timeline) 버튼 토글 + 보드(드래그로 단계 이동)/리스트. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 권한은 등급(수퍼관리자 > Admin > Pro user > User, 2026-10-12)과 멤버십 기준 — 표는 `docs/PROJECT_MODULE.md` 6-14, 공통 판단 `access.py`(관리자도 멤버가 아니면 프로젝트가 안 보임, 예외는 수퍼관리자). 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 업무 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 상세는 `docs/PROJECT_MODULE.md`
상세는 `docs/PROJECT_OVERVIEW.md`.
+1 -1
View File
File diff suppressed because one or more lines are too long
+4
View File
@@ -35,6 +35,8 @@ from .modules.vacation import router as vacation_router
from .store import (
APPROVER_KEYS,
MODULE_KEYS,
ROLE_LABELS,
ROLES,
SUPER_ADMIN_EMAIL,
UserStore,
allowed_modules,
@@ -663,6 +665,8 @@ async def admin_page(request: Request) -> HTMLResponse:
"module_keys": list(MODULE_KEYS),
"module_labels": MODULE_LABELS,
"approver_keys": list(APPROVER_KEYS),
"roles": list(ROLES),
"role_labels": ROLE_LABELS,
"super_admin_email": SUPER_ADMIN_EMAIL,
"is_admin": True,
},
+29 -2
View File
@@ -7,10 +7,19 @@
프로젝트
관리(=보기·작업 CRUD) : 프로젝트 owner · 배정 멤버 · 슈퍼관리자. 모두 `project` 모듈 권한이 있어야 한다.
(2026-10-07 — 관리자(is_admin)도 멤버가 아닌 프로젝트는 보이지 않는다. 예외는 슈퍼관리자 한 명뿐.
멤버 배정 자체는 여전히 관리자만 — 라우터의 _require_admin.)
멤버 배정은 Pro user 이상(2026-10-12) — 라우터의 _require_pro, 아래 등급 표.)
등급(2026-10-12, app.store.ROLES) — 수퍼관리자 > admin > pro > user
is_project_admin : 수퍼관리자·admin — 남이 만든 프로젝트·섹션도 삭제.
is_pro : 수퍼관리자·admin·pro — 새 프로젝트 만들기, 프로젝트 이름·색·아이콘·소유자 수정,
멤버 배정·제외(자기가 멤버인 프로젝트), 사이드바 순서, 남의 댓글 수정·삭제,
휴지통 보기·복구, 전체 보기, 대시보드 담당자별 합계, 전체 멤버 메뉴,
목표 표 입력·구조 변경·주차별 목표·연도 추가/삭제, 회의 완료·완료 해제·회의록 삭제.
user : 멤버인 프로젝트의 작업·섹션·서브프로젝트·작업 삭제, 회의록 작성(완료 전까지).
프로젝트 단위 권한은 등급과 상관없이 멤버(owner)여야 한다 — 위 is_pro 권한도 멤버인 프로젝트 안에서만.
작업
FULL : 원 소속 프로젝트를 관리할 수 있음 → 보기·수정·댓글·첨부·삭제(삭제는 추가로 생성자 규칙)
FULL : 원 소속 프로젝트를 관리할 수 있음 → 보기·수정·댓글·첨부·삭제(작업 삭제는 멤버 누구나, 2026-10-12)
READ : 원 소속 권한은 없지만, 이 작업(또는 상위 작업)이 연결된(멀티호밍) 프로젝트를 관리할 수 있음
→ 그 작업의 상세·세부 작업 목록·댓글·첨부 보기만. 원 소속의 다른 작업·멤버는 보이지 않는다.
연결된 프로젝트 안에서의 섹션 이동(POST /links, 이미 연결된 경우)은 예전처럼 허용.
@@ -43,6 +52,24 @@ def _is_super(user: dict[str, Any] | None) -> bool:
return bool(user) and email_of(user) == SUPER_ADMIN_EMAIL
def role_of(user: dict[str, Any] | None) -> str:
"""등급 — 'super' · 'admin' · 'pro' · 'user'. 모르는 role 값은 user 로 본다."""
if _is_super(user):
return "super"
role = (user or {}).get("role")
return role if role in ("admin", "pro") else "user"
def is_project_admin(user: dict[str, Any] | None) -> bool:
"""수퍼관리자·admin — 만든 사람이 아니어도 프로젝트·섹션을 지운다."""
return role_of(user) in ("super", "admin")
def is_pro(user: dict[str, Any] | None) -> bool:
"""수퍼관리자·admin·pro — 프로젝트 관리·목표 입력 등 운영 권한(모듈 docstring 의 등급 표)."""
return role_of(user) in ("super", "admin", "pro")
def sees_all_projects(user: dict[str, Any] | None) -> bool:
"""멤버가 아니어도 모든 프로젝트를 보는가 — 슈퍼관리자만(모듈 권한도 있어야)."""
return can_use_module(user) and _is_super(user)
+249 -152
View File
@@ -98,7 +98,10 @@ class ProjectStore:
created_by: str = "",
seed_stages: bool = False,
icon: str | None = None,
member_emails: list[str] | None = None,
) -> dict[str, Any]:
"""member_emails — 만들면서 같이 넣을 멤버(같은 트랜잭션). 남을 소유자로 지정해 만든 사람이
만든 직후 자기 프로젝트를 못 여는 일이 없게 라우터가 만든 사람을 넣는다(일반 멤버 — 나중에 뺄 수 있다)."""
nm = store.validate_project_name(name)
col = store.validate_color(color)
ic = store.validate_project_icon(icon)
@@ -136,6 +139,12 @@ class ProjectStore:
vals,
).fetchone()
pid = row["id"]
for em in store.normalize_emails(member_emails or []):
conn.execute(
"INSERT INTO project_members (project_id, user_email, user_name, role) "
"VALUES (%s,%s,'','member') ON CONFLICT (project_id, user_email) DO NOTHING",
(pid, em),
)
if seed_stages:
for i, (stage_name, is_done) in enumerate(store.DEFAULT_STAGES):
conn.execute(
@@ -174,21 +183,26 @@ class ProjectStore:
if existing is None:
raise KeyError(project_id)
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)
with self._pool.connection() as conn:
row = conn.execute(
f"UPDATE projects SET {', '.join(sets)} WHERE id = %s RETURNING *",
params,
).fetchone()
with conn.transaction():
if "start_date" in clean or "due_date" in clean:
# 한쪽만 바꿔도 기존 값과 합친 최종 상태로 검사한다 — 그 행을 잠근 뒤 읽어서(FOR UPDATE)
# 두 사람이 시작일·마감일을 동시에 바꿔도 각자 옛 값으로 검사해 역전되지 않게.
existing = conn.execute(
"SELECT start_date, due_date FROM projects WHERE id = %s FOR UPDATE", (project_id,)
).fetchone()
if existing is None:
raise KeyError(project_id)
existing = self._serialize(existing)
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"),
)
row = conn.execute(
f"UPDATE projects SET {', '.join(sets)} WHERE id = %s RETURNING *",
params,
).fetchone()
if not row:
raise KeyError(project_id)
return self._serialize(row)
@@ -334,9 +348,11 @@ class ProjectStore:
return self._serialize(row) if row else None
@staticmethod
def _stage_default_assignee(conn: Any, stage_id: Any, project_id: int) -> tuple[str, str]:
def _stage_default_assignee(conn: Any, stage_id: Any, project_id: int,
allowed: Any = None) -> tuple[str, str]:
"""세션 기본 담당자(마이그레이션 009) → (email, name). 미지정·009 미적용·
그 사람이 이제 프로젝트 멤버가 아니면 ('', '').
그 사람이 이제 프로젝트 멤버가 아니면 ('', ''). allowed(email) 가 있으면 그것도 통과해야 한다 —
삭제된 사용자·project 모듈 권한을 잃은 사람에게 자동 배정(과 배정 알림)이 가지 않게(라우터가 넘김).
컬럼이 없어도 에러가 나지 않게 to_jsonb(행) 에서 키로 읽는다."""
if stage_id in (None, ""):
@@ -360,8 +376,17 @@ class ProjectStore:
).fetchone()
if not m:
return "", ""
if allowed is not None and not allowed(email):
return "", ""
return email, m["user_name"] or ""
@staticmethod
def _stage_is_done_conn(conn: Any, stage_id: Any) -> bool:
if stage_id is None:
return False
row = conn.execute("SELECT is_done_stage FROM project_stages WHERE id = %s", (stage_id,)).fetchone()
return bool(row and row["is_done_stage"])
@staticmethod
def _check_stage_in_project(conn: Any, stage_id: Any, project_id: int) -> int | None:
"""세션이 그 프로젝트 것인지 확인하고 int 로 돌려준다(None 은 그대로).
@@ -587,11 +612,13 @@ class ProjectStore:
).fetchone()
return int(row["n"] or 0)
def list_my_tasks(self, *, assignee_email: str, limit: int = 1000) -> list[dict[str, Any]]:
""""내 업무" 화면 전용 — 내가 담당자인 업무를 레벨(최상위/하위) 상관없이
전부 반환한다. 세부 업무 행에는 부모 업무 정보(`parent_title` 등)를 같이
붙여서, 부모가 내 업무가 아니어도(다른 사람 담당) 화면에서 트리로 묶어
보여줄 수 있게 한다.
def list_my_tasks(self, *, assignee_email: str, completed_limit: int = 1000) -> list[dict[str, Any]]:
""""내 업무" 화면 전용 — 내가 담당자인 업무를 레벨(최상위/하위) 상관없이 반환한다.
세부 업무 행에는 부모 업무 정보(`parent_title` 등)를 같이 붙여서, 부모가 내 업무가 아니어도
(다른 사람 담당) 화면에서 트리로 묶어 보여줄 수 있게 한다.
미완료는 **전부**, 완료는 최근에 완료한 completed_limit 건까지 — 예전엔 전체를 1000건에서 잘라
오래된 완료 업무가 새 미완료 업무를 목록 밖으로 밀어낼 수 있었다.
"""
email = store.norm_str(assignee_email, lower=True)
with self._pool.connection() as conn:
@@ -607,8 +634,11 @@ class ProjectStore:
f"LEFT JOIN project_stages s ON s.id = t.stage_id "
f"LEFT JOIN tasks pt ON pt.id = t.parent_task_id "
f"WHERE t.assignee_email = %s "
"ORDER BY t.sort_order ASC, t.id ASC LIMIT %s",
(email, int(limit)),
" AND (t.completed_at IS NULL OR t.id IN ("
" SELECT d.id FROM tasks d WHERE d.assignee_email = %s AND d.completed_at IS NOT NULL "
" ORDER BY d.completed_at DESC, d.id DESC LIMIT %s)) "
"ORDER BY t.sort_order ASC, t.id ASC",
(email, email, int(completed_limit)),
).fetchall()
return [self._serialize(r) for r in rows]
@@ -642,7 +672,9 @@ class ProjectStore:
due_time: str | None = None,
created_by: str = "",
parent_task_id: int | None = None,
assignee_allowed: Any = None,
) -> dict[str, Any]:
"""assignee_allowed — update_task 와 같이 섹션 기본 담당자 자동 배정 전 지금 권한 확인(라우터가 넘김)."""
ttl = store.validate_task_title(title)
pr = store.validate_priority(priority)
sd = store.validate_date(start_date)
@@ -681,7 +713,8 @@ class ProjectStore:
# 담당자 없이 만들면 그 세션의 기본 담당자를 배정(세부 업무는
# 세션이 없어 해당 없음).
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,
allowed=assignee_allowed)
# 완료 섹션에 바로 만든 작업은 완료 섹션으로 옮긴 것과 같이 완료 처리(완료 시각·이력).
if stage_id is not None:
done_row = conn.execute(
@@ -767,129 +800,132 @@ class ProjectStore:
return self.get_task(task_id=task_id)
def update_task(
self, *, task_id: int, fields: dict[str, Any], actor: str = ""
self, *, task_id: int, fields: dict[str, Any], actor: str = "",
assignee_allowed: Any = None,
) -> dict[str, Any]:
"""업무 수정. 반환에 알림 힌트를 담는다(라우터가 메일 발송 판단).
반환 dict 에 추가되는 키:
_newly_assigned: 새 담당자 이메일 or None
_newly_completed: 완료로 전환됐으면 True
"""
prev = self.get_task(task_id=task_id)
if prev is None:
raise KeyError(task_id)
sets: list[str] = []
params: list[Any] = []
동시성 — 기존 값 읽기·최종 날짜 검사·변경·이력을 **한 트랜잭션에서 그 작업 행을 잠그고**
(SELECT … FOR UPDATE) 한다. 두 사람이 시작일·마감일을 동시에 바꿔도 각자 옛 값으로 검사해
날짜가 역전되지 않고, 동시에 완료해도 완료 이력·알림 힌트는 실제로 완료로 바뀐 한 요청에서만 생긴다.
섹션 확인·기본 담당자·완료 섹션 여부도 같은 연결로 읽는다(다른 연결을 다시 빌리지 않는다).
assignee_allowed(email) — 섹션 기본 담당자를 자동 배정하기 전에 그 사람이 지금 등록된 project
권한 사용자인지(사용자 목록은 DB 밖이라 라우터가 넘긴다). 없으면 멤버·owner 여부만 본다.
"""
# 형식 검사는 잠그기 전에(잠금을 짧게) — 값이 틀리면 DB 에 가지 않는다.
clean: dict[str, Any] = {}
if "title" in fields:
clean["title"] = store.validate_task_title(fields["title"])
if "description" in fields:
clean["description"] = store.norm_str(fields["description"])
if "priority" in fields:
clean["priority"] = store.validate_priority(fields["priority"])
for k in ("start_date", "due_date"):
if k in fields:
clean[k] = store.validate_date(fields[k])
for k in ("start_time", "due_time"):
if k in fields:
clean[k] = store.validate_time(fields[k])
newly_assigned: str | None = None
newly_completed = False
new_stage: Any = None
if "stage_id" in fields:
new_stage = self.stage_in_project(
stage_id=fields["stage_id"], project_id=prev["project_id"]
)
# 다른 세션으로 옮겨왔고 (옮긴 뒤에도) 담당자가 비어 있으면 그 세션의
# 기본 담당자를 배정한다. 이미 담당자가 있으면 그대로 둔다.
if new_stage is not None and new_stage != prev.get("stage_id"):
final_assignee = (
store.norm_str(fields["assignee_email"], lower=True)
if "assignee_email" in fields else (prev.get("assignee_email") or "")
)
if not final_assignee:
with self._pool.connection() as conn:
dae, dan = self._stage_default_assignee(conn, new_stage, prev["project_id"])
if dae:
fields = {**fields, "assignee_email": dae, "assignee_name": dan}
if "title" in fields:
sets.append("title = %s")
params.append(store.validate_task_title(fields["title"]))
if "description" in fields:
sets.append("description = %s")
params.append(store.norm_str(fields["description"]))
if "priority" in fields:
sets.append("priority = %s")
params.append(store.validate_priority(fields["priority"]))
if "start_date" in fields:
sets.append("start_date = %s")
params.append(store.validate_date(fields["start_date"]))
if "due_date" in fields:
sets.append("due_date = %s")
params.append(store.validate_date(fields["due_date"]))
if "start_time" in fields:
sets.append("start_time = %s")
params.append(store.validate_time(fields["start_time"]))
if "due_time" in fields:
sets.append("due_time = %s")
params.append(store.validate_time(fields["due_time"]))
if "assignee_email" in fields:
new_assignee = store.norm_str(fields["assignee_email"], lower=True)
sets.append("assignee_email = %s")
params.append(new_assignee)
if "assignee_name" in fields:
sets.append("assignee_name = %s")
params.append(store.norm_str(fields["assignee_name"]))
if new_assignee and new_assignee != (prev.get("assignee_email") or ""):
newly_assigned = new_assignee
elif "assignee_name" in fields:
sets.append("assignee_name = %s")
params.append(store.norm_str(fields["assignee_name"]))
# 단계 변경 → 완료단계 진입 시 completed_at 자동 세팅. 단, 실제로 단계가
# 바뀐 경우에만 판정한다 — 업무 편집 모달의 "저장"은 매번 현재 stage_id
# 를 그대로 다시 보내는데, 여기서 무조건 판정하면 방금 "완료로 표시"로
# 켠 completed_at 을(단계는 그대로인데) 다시 꺼버리는 버그가 있었다.
if "stage_id" in fields:
sets.append("stage_id = %s")
params.append(new_stage)
if new_stage != prev.get("stage_id"):
done = self._stage_is_done(new_stage)
if done and not prev.get("completed_at"):
sets.append("completed_at = %s")
params.append(now_kst())
newly_completed = True
elif not done and prev.get("completed_at"):
sets.append("completed_at = NULL")
# 직접 완료 토글 — 세부 업무는 세션(칸반 컬럼)이 없어 위 자동 세팅이
# 적용되지 않는다. "stage_id" 를 같이 보냈으면 그쪽 판정이 우선한다.
elif "completed" in fields:
if fields["completed"] and not prev.get("completed_at"):
sets.append("completed_at = %s")
params.append(now_kst())
newly_completed = True
elif not fields["completed"] and prev.get("completed_at"):
sets.append("completed_at = NULL")
if not sets:
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)
with self._pool.connection() as conn:
with conn.transaction():
conn.execute(
f"UPDATE tasks SET {', '.join(sets)} WHERE id = %s", params
)
if newly_assigned:
self._log(conn, project_id=prev["project_id"], task_id=task_id,
actor=actor, action=store.ACTION_ASSIGNED,
detail=f"{prev['title']} → {newly_assigned}")
if newly_completed:
self._log(conn, project_id=prev["project_id"], task_id=task_id,
actor=actor, action=store.ACTION_COMPLETED,
detail=prev["title"])
row = conn.execute("SELECT * FROM tasks WHERE id = %s FOR UPDATE", (task_id,)).fetchone()
if row is None:
raise KeyError(task_id)
prev = self._serialize(row)
sets: list[str] = []
params: list[Any] = []
for k in ("title", "description", "priority", "start_date", "due_date", "start_time", "due_time"):
if k in clean:
sets.append(f"{k} = %s")
params.append(clean[k])
assignee_fields = {k: fields[k] for k in ("assignee_email", "assignee_name") if k in fields}
new_stage: Any = None
if "stage_id" in fields:
new_stage = self._check_stage_in_project(conn, fields["stage_id"], prev["project_id"])
# 다른 세션으로 옮겨왔고 (옮긴 뒤에도) 담당자가 비어 있으면 그 세션의
# 기본 담당자를 배정한다. 이미 담당자가 있으면 그대로 둔다.
if new_stage is not None and new_stage != prev.get("stage_id"):
final_assignee = (
store.norm_str(fields["assignee_email"], lower=True)
if "assignee_email" in fields else (prev.get("assignee_email") or "")
)
if not final_assignee:
dae, dan = self._stage_default_assignee(conn, new_stage, prev["project_id"],
allowed=assignee_allowed)
if dae:
assignee_fields = {"assignee_email": dae, "assignee_name": dan}
if "assignee_email" in assignee_fields:
new_assignee = store.norm_str(assignee_fields["assignee_email"], lower=True)
sets.append("assignee_email = %s")
params.append(new_assignee)
if "assignee_name" in assignee_fields:
sets.append("assignee_name = %s")
params.append(store.norm_str(assignee_fields["assignee_name"]))
if new_assignee and new_assignee != (prev.get("assignee_email") or ""):
newly_assigned = new_assignee
elif "assignee_name" in assignee_fields:
sets.append("assignee_name = %s")
params.append(store.norm_str(assignee_fields["assignee_name"]))
# 단계 변경 → 완료단계 진입 시 completed_at 자동 세팅. 단, 실제로 단계가
# 바뀐 경우에만 판정한다 — 업무 편집 모달의 "저장"은 매번 현재 stage_id
# 를 그대로 다시 보내는데, 여기서 무조건 판정하면 방금 "완료로 표시"로
# 켠 completed_at 을(단계는 그대로인데) 다시 꺼버리는 버그가 있었다.
if "stage_id" in fields:
sets.append("stage_id = %s")
params.append(new_stage)
if new_stage != prev.get("stage_id"):
done = self._stage_is_done_conn(conn, new_stage)
if done and not prev.get("completed_at"):
sets.append("completed_at = %s")
params.append(now_kst())
newly_completed = True
elif not done and prev.get("completed_at"):
sets.append("completed_at = NULL")
# 직접 완료 토글 — 세부 업무는 세션(칸반 컬럼)이 없어 위 자동 세팅이
# 적용되지 않는다. "stage_id" 를 같이 보냈으면 그쪽 판정이 우선한다.
elif "completed" in fields:
if fields["completed"] and not prev.get("completed_at"):
sets.append("completed_at = %s")
params.append(now_kst())
newly_completed = True
elif not fields["completed"] and prev.get("completed_at"):
sets.append("completed_at = NULL")
if not sets:
changed = False
else:
changed = True
# 날짜 범위 — 한쪽만 바꾸거나 지워도 (잠근) 기존 값과 합친 최종 상태로 검사.
if any(k in clean for k in ("start_date", "due_date", "start_time", "due_time")):
def final(key: str) -> Any:
return clean[key] if key in clean else prev.get(key)
store.validate_date_range(final("start_date"), final("due_date"),
final("start_time"), final("due_time"))
conn.execute(f"UPDATE tasks SET {', '.join(sets)} WHERE id = %s", (*params, task_id))
if newly_assigned:
self._log(conn, project_id=prev["project_id"], task_id=task_id,
actor=actor, action=store.ACTION_ASSIGNED,
detail=f"{prev['title']} → {newly_assigned}")
if newly_completed:
self._log(conn, project_id=prev["project_id"], task_id=task_id,
actor=actor, action=store.ACTION_COMPLETED,
detail=prev["title"])
out = self.get_task(task_id=task_id)
out["_newly_assigned"] = newly_assigned
out["_newly_completed"] = newly_completed
if out is None:
raise KeyError(task_id)
out["_newly_assigned"] = newly_assigned if changed else None
out["_newly_completed"] = newly_completed if changed else False
return out
# ════════════════════════════════════════════════════════════
@@ -1072,15 +1108,6 @@ class ProjectStore:
conn.execute("DELETE FROM project_trash WHERE id = %s", (trash_id,))
return {"task_id": int(root["id"]), "project_id": int(root["project_id"]), "task_ids": ids}
def _stage_is_done(self, stage_id: Any) -> bool:
if stage_id is None:
return False
with self._pool.connection() as conn:
row = conn.execute(
"SELECT is_done_stage FROM project_stages WHERE id = %s", (stage_id,)
).fetchone()
return bool(row and row["is_done_stage"])
# ════════════════════════════════════════════════════════════
# 멀티호밍 (task_project_links) — 업무 1개가 여러 프로젝트/세션에 동시 소속.
# 원래 소속(tasks.project_id/stage_id)은 여기서 건드리지 않는다("기본 홈"은
@@ -1548,6 +1575,31 @@ class ProjectStore:
).fetchall()
return [self._serialize(r) for r in rows]
def list_unread_after(
self, *, recipient_email: str, after_id: int, types: tuple[str, ...], limit: int = 200,
) -> list[dict[str, Any]]:
"""큰 팝업 알림 후보 — 이 사람·읽지 않음·종류·id > after_id 를 DB 에서 먼저 걸러 **오래된 것(id)부터**.
라우터가 지금 볼 수 있는 것만 남기며 마지막 id 를 다음 after_id 로 넘겨 끝까지 읽는다."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT * FROM project_notifications "
"WHERE recipient_email = %s AND is_read = FALSE AND id > %s AND type = ANY(%s) "
"ORDER BY id ASC LIMIT %s",
(store.norm_str(recipient_email, lower=True), int(after_id), list(types), int(limit)),
).fetchall()
return [self._serialize(r) for r in rows]
def list_unread_refs(self, *, recipient_email: str) -> list[dict[str, Any]]:
"""읽지 않은 알림 전부의 (id, project_id, task_id) — 수신함 배지를 개수 제한 없이 정확히 세려고
가벼운 열만 읽는다(지금 권한 거르기는 라우터)."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT id, project_id, task_id FROM project_notifications "
"WHERE recipient_email = %s AND is_read = FALSE",
(store.norm_str(recipient_email, lower=True),),
).fetchall()
return [dict(r) for r in rows]
def count_unread(self, *, recipient_email: str) -> int:
with self._pool.connection() as conn:
row = conn.execute(
@@ -1766,6 +1818,27 @@ class ProjectStore:
).fetchall()
return [self._serialize(r) for r in rows]
def list_unread_mention_refs(self, *, mentioned_email: str) -> list[dict[str, Any]]:
"""미확인 태그가 있는 작업마다 (id, project_id, unread_mentions) — 배지를 제한 없이 세는 가벼운 조회."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT t.id, t.project_id, m.unread AS unread_mentions "
"FROM (SELECT task_id, COUNT(*) AS unread FROM task_mentions "
" WHERE mentioned_email = %s AND is_read = FALSE GROUP BY task_id) m "
"JOIN tasks t ON t.id = m.task_id",
(store.norm_str(mentioned_email, lower=True),),
).fetchall()
return [dict(r) for r in rows]
def list_my_open_refs(self, *, assignee_email: str) -> list[dict[str, Any]]:
"""내가 담당인 미완료 작업 전부의 (id, project_id) — "내 작업" 배지를 제한 없이 정확히 센다."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT id, project_id FROM tasks WHERE assignee_email = %s AND completed_at IS NULL",
(store.norm_str(assignee_email, lower=True),),
).fetchall()
return [dict(r) for r in rows]
def count_unread_mentions(self, *, mentioned_email: str) -> int:
with self._pool.connection() as conn:
row = conn.execute(
@@ -2735,6 +2808,25 @@ class ProjectStore:
if row and row["completed_at"] is not None:
raise store.MeetingLocked()
def _check_result_open(self, conn: Any, own_week: Any) -> None:
"""결과 칸(result_*·status)만 고칠 때 — 그 주 결과는 다음 주 회의에서 리뷰하며 적는다(6-14 표).
· 다음 주차 회의록이 있으면 그 회의록이 열려 있을 때만(완료되면 잠금 — 그 주 회의록 완료 여부와 무관)
· 다음 주차 회의록이 아직 없으면 그 주 회의록이 열려 있을 때만(예전엔 그 주가 완료돼도 다음 회의록이
없으면 고칠 수 있었다)
다음 주차 = 바로 다음 주차 시작일(store.week_period 끝 + 1일 — 달이 바뀌어도, 월요일이 아닌 시작일도
get_meeting 이 "지난주"를 찾는 규칙과 같다). 다음 회의록 행도 잠근다(FOR SHARE) — 이미 그 주 회의록을
잠근 뒤라 잠금 순서는 늘 주차 오름차순(교착 없음), 확인 뒤 다음 회의록이 완료돼도 끼어들지 못한다.
022 전이면 잠금 없음."""
if not self._meeting_v22(conn):
return
nxt = store.week_period(own_week)[1] + timedelta(days=1)
row = conn.execute("SELECT completed_at FROM goal_meetings WHERE week_start = %s FOR SHARE",
(nxt,)).fetchone()
if row is None:
self._check_meeting_open(conn, own_week)
elif row["completed_at"] is not None:
raise store.MeetingLocked()
def set_meeting_completed(self, *, week_start: date, done: bool, by: str = "") -> dict[str, Any]:
"""회의 완료(잠금)·완료 해제 — 관리자만(라우터). 바뀐 상태를 돌려준다."""
with self._pool.connection() as conn:
@@ -2993,13 +3085,19 @@ class ProjectStore:
if not sets:
return
with self._pool.connection() as conn:
self._require_meetings(conn)
self._check_meeting_open(conn, week_start)
row = conn.execute(
f"UPDATE goal_meetings SET {', '.join(sets)}, updated_by = %s, updated_at = now() "
"WHERE week_start = %s RETURNING week_start",
(*params, store.norm_str(updated_by, lower=True), week_start),
).fetchone()
with conn.transaction():
self._require_meetings(conn)
# 완료 확인과 머리 변경을 한 트랜잭션에서 그 회의록 행을 잠그고 — [회의 완료](set_meeting_completed
# 의 UPDATE 도 같은 행을 잠근다)와 동시에 와도 완료된 회의록이 바뀌지 않는다.
if not conn.execute("SELECT week_start FROM goal_meetings WHERE week_start = %s FOR UPDATE",
(week_start,)).fetchone():
raise KeyError(str(week_start))
self._check_meeting_open(conn, week_start)
row = conn.execute(
f"UPDATE goal_meetings SET {', '.join(sets)}, updated_by = %s, updated_at = now() "
"WHERE week_start = %s RETURNING week_start",
(*params, store.norm_str(updated_by, lower=True), week_start),
).fetchone()
if row is None:
raise KeyError(str(week_start))
@@ -3103,9 +3201,8 @@ class ProjectStore:
raise ValueError(next(e for _c, t, e in texts if t)) # 021 전 — 예전처럼 숫자만
rows = self._locked_meeting_items(conn, item_id, check_open=not result_only)
if result_only:
# 지난주 결과는 다음 주 회의에서 적는다 — 그 회의록(바로 다음 주차)이 완료됐으면 잠금
own = next(r for r in rows if int(r["id"]) == item_id)["week_start"]
self._check_meeting_open(conn, store.week_period(own)[1] + timedelta(days=1))
self._check_result_open(conn, own)
if "content" in fields:
self._require_meeting_cell_visible(rows, item_id)
if sets:
File diff suppressed because it is too large Load Diff
@@ -1,6 +1,6 @@
{# ── 프로젝트 모듈 좌측 사이드바 (공용) ──────────────────────────────
수신함·내 업무·휴지통·프로젝트 화면이 함께 쓴다 — 어느 화면이든 프로젝트
목록은 똑같다(관리자: 드래그 순서 변경·✎ 수정·× 삭제·우클릭 메뉴).
목록은 똑같다(Pro user 이상: 드래그 순서 변경·✎ 수정·× 삭제·우클릭 메뉴).
변수:
mention_unread 미확인 @태그 개수 (수신함 배지)
@@ -10,7 +10,8 @@
side_active 'inbox' | 'mytasks' | 'trash' | 'goals' | '' — 개인 메뉴 활성 표시
goal_years "목표" 아래 연도 목록(router._goal_years_nav — 올해는 항상 포함)
goal_year_active 목표 화면에서 보고 있는 연도
is_admin 프로젝트 생성/수정/삭제 권한
pj_pro Pro user 이상 — 프로젝트 생성·수정·순서·전체 보기·휴지통·전체 멤버·연도 추가
pj_admin Admin 이상 — 남이 만든 프로젝트도 삭제(그 밖은 만든 사람만)
목록 동작은 project.js 의 initSideTree(첫 화면을 같은 마크업으로 다시 그림),
새 프로젝트/수정 모달은 각 화면이 include 하는 project/_side_modals.html. #}
{# 날짜 팝업(openDatePopover)이 공휴일을 빨강으로 칠할 때 쓰는 표 — 이 사이드바는
@@ -19,7 +20,7 @@
{# 모든 프로젝트 화면에서 같은 회의록 트리를 사용한다. #}
<link rel="stylesheet" href="/static/project-goal-nav.css?v=20261004e" />
<script src="/static/project-goal-nav.js?v=20261004d" defer></script>
<aside class="pj-side" data-is-admin="{{ 'true' if is_admin else 'false' }}"
<aside class="pj-side" data-is-pro="{{ 'true' if pj_pro else 'false' }}" data-is-padmin="{{ 'true' if pj_admin else 'false' }}"
data-is-super="{{ 'true' if user.is_super_admin else 'false' }}"
data-me="{{ user.email }}">
<!-- 전체 검색 — 제목·설명·댓글, 내가 볼 수 있는 모든 프로젝트(세부 업무 포함).
@@ -38,9 +39,9 @@
<span class="pj-side-navbadge" id="pj-mention-badge"
{% if not mention_unread %}hidden{% endif %}>{{ mention_unread }}</span>
</a>
{# 전체 보기(2026-10-08, 관리자만) — 예전 프로젝트 화면 오른쪽 위 "전체 프로젝트" 토글. 지금 프로젝트(없으면 목록 첫 프로젝트)
{# 전체 보기(2026-10-08, Pro user 이상 — 멤버인 프로젝트 범위) — 예전 프로젝트 화면 오른쪽 위 "전체 프로젝트" 토글. 지금 프로젝트(없으면 목록 첫 프로젝트)
화면을 ?scope=all 로 연다 — 볼 수 있는 모든 프로젝트의 작업. 프로젝트 화면에서는 project.js 가 새로고침 없이 바꾼다. #}
{% if is_admin %}
{% if pj_pro %}
{% set _all_pid = current_pid or ((nav_projects | rejectattr("status", "equalto", "completed") | list | first or {}).id or 0) %}
{% if _all_pid %}
<a class="pj-side-navlink" id="pj-side-allview" href="/project/p/{{ _all_pid }}?scope=all">
@@ -55,8 +56,8 @@
<span class="pj-side-navbadge pj-side-navbadge-open" id="pj-myopen-badge"
{% if not my_open_total %}hidden{% endif %}>{{ my_open_total }}</span>
</a>
{# 휴지통 — 관리자만 보이고(화면·복구 API 도 관리자 전용), 지운 업무를 3개월 보관. #}
{% if is_admin %}
{# 휴지통 — Pro user 이상만 보이고(화면·복구 API 도 같음), 지운 업무를 3개월 보관. #}
{% if pj_pro %}
<a class="pj-side-navlink {% if side_active == 'trash' %}is-active{% endif %}" href="/project/trash">
<span class="material-symbols-outlined pj-side-navic">delete</span>
<span class="pj-side-navtext">휴지통</span>
@@ -64,7 +65,7 @@
{% endif %}
{# 목표 — 누르면 바로 아래에 연도가 펼쳐지고, 연도를 누르면 오른쪽에 그해 전체 목표
(/project/goals/{연도}). 펼침 상태는 localStorage(pj_goal_open), 목표 화면에서는 항상 펼침.
연도 추가는 관리자만(마이그레이션 013). #}
연도 추가는 Pro user 이상(마이그레이션 013). #}
{% set goal_open = side_active == 'goals' %}
<div class="pj-side-goal{% if goal_open %} is-open{% endif %}" id="pj-side-goal"
data-force-open="{{ 'true' if goal_open else 'false' }}">
@@ -89,7 +90,7 @@
<div class="pj-side-meeting-months" id="pj-side-meeting-months-{{ y }}" data-current-week="{{ week if goal_month is defined else '' }}"></div>
</div>
{% endfor %}
{% if is_admin %}
{% if pj_pro %}
<button type="button" class="pj-side-goal-add" id="pj-goal-year-add"
data-next="{{ ((goal_years or [0]) | max) + 1 }}">+ 연도 추가</button>
{% endif %}
@@ -100,23 +101,23 @@
<div class="pj-side-block pj-tree-block">
<div class="pj-side-head">
<span>프로젝트</span>
{% if is_admin %}
{% if pj_pro %}
<button type="button" class="pj-icon-btn" id="pj-new-project-side" title="새 프로젝트">+</button>
{% endif %}
</div>
{% macro nav_li(p) %}
<li class="pj-tree-li" data-id="{{ p.id }}"{% if is_admin %} draggable="true"{% endif %}
<li class="pj-tree-li" data-id="{{ p.id }}"{% if pj_pro %} draggable="true"{% endif %}
data-name="{{ p.name }}" data-desc="{{ p.description or '' }}"
data-start="{{ p.start_date or '' }}" data-due="{{ p.due_date or '' }}"
data-color="{{ p.color }}" data-status="{{ p.status or 'active' }}"
data-creator="{{ p.created_by or '' }}" data-icon="{{ p.icon or '' }}">
<div class="pj-tree-row {% if p.id == current_pid %}is-active{% endif %}">
{% if is_admin %}<span class="pj-tree-handle" title="드래그로 순서 변경">⣿</span>{% endif %}
<a class="pj-tree-link" href="/project/p/{{ p.id }}"{% if is_admin %} draggable="false"{% endif %}>
{% if pj_pro %}<span class="pj-tree-handle" title="드래그로 순서 변경">⣿</span>{% endif %}
<a class="pj-tree-link" href="/project/p/{{ p.id }}"{% if pj_pro %} draggable="false"{% endif %}>
<span class="pj-tree-avatar{% if p.icon %} has-icon{% endif %}" style="background: {{ p.color }}">{% if p.icon %}{% set _a = p.icon.startswith("asana:") %}<span class="material-symbols-outlined pj-proj-ic{% if _a %} pj-ic-asana{% endif %}">{{ p.icon[6:] if _a else p.icon }}</span>{% else %}{{ p.name[0] | upper }}{% endif %}</span>
<span class="pj-tree-name">{{ p.name }}</span>
</a>
{% if is_admin %}
{% if pj_pro %}
<span class="pj-tree-acts">
<button type="button" class="pj-icon-btn pj-tree-edit" data-id="{{ p.id }}"
data-name="{{ p.name }}" data-desc="{{ p.description or '' }}"
@@ -145,11 +146,11 @@
{% endif %}
</div>
<!-- 전체 멤버 — 등록된 전체 직원(프로젝트 권한 보유자). 관리자 전용
(/api/all-users 도 관리자만). 아이콘 클릭 시 그 사람이 담당자인 업무를
<!-- 전체 멤버 — 등록된 전체 직원(프로젝트 권한 보유자). Pro user 이상
(/api/all-users 는 @태그 후보로 누구나 부른다). 아이콘 클릭 시 그 사람이 담당자인 업무를
팝업으로 보여준다(프로젝트/세션/마감일). 수신함·내 업무·프로젝트 화면
모두에서 보인다 — 팝업 마크업은 _member_tasks_modal.html. -->
{% if is_admin %}
{% if pj_pro %}
<div class="pj-side-block">
<div class="pj-side-head"><span>전체 멤버</span></div>
<div class="pj-allmembers-grid" id="pj-allmembers-grid">불러오는 중…</div>
@@ -1,14 +1,14 @@
{# ── 좌측 프로젝트 목록(project/_side.html)용 모달 (공용) ──────────────
"+" 새 프로젝트 / ✎ 프로젝트 수정 — 수신함·내 업무·휴지통·프로젝트 화면이
모두 include 한다(동작은 project.js 의 initSideTree). 관리자만 쓰므로
관리자에게만 그린다. 색상 원은 window.PJ_COLORS(color_palette, 32색),
모두 include 한다(동작은 project.js 의 initSideTree). Pro user 이상만 쓰므로
그들에게만 그린다. 색상 원은 window.PJ_COLORS(color_palette, 32색),
아이콘은 window.PJ_ICONS(project_icons — Material Symbols 이름). #}
<script>
window.PJ_COLORS = {{ color_palette | tojson }};
window.PJ_ICONS = {{ (project_icons or []) | tojson }};
window.PJ_ASANA_ICONS = {{ (project_asana_icons or []) | tojson }}; {# 아사나 아이콘 탭 — 값은 "asana:" + 이름 #}
</script>
{% if is_admin %}
{% if pj_pro %}
<!-- 새 프로젝트 모달 — 좌측 프로젝트 목록의 + 버튼 -->
<div class="pj-modal" id="pj-modal-project" hidden>
<div class="pj-modal-card">
@@ -28,6 +28,7 @@
<div class="pj-field-label">멤버
<div class="pj-member-picker" id="pj-f-members">불러오는 중…</div>
</div>
<p class="pj-modal-msg" id="pj-f-project-msg" role="status" hidden></p>
<div class="pj-modal-actions">
<button type="button" class="pj-btn" data-close>취소</button>
<button type="button" class="pj-btn pj-btn-primary" id="pj-save-project">만들기</button>
@@ -1,7 +1,7 @@
{% extends "project/_meeting_content_base.html" if meeting_embedded else "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -20,7 +20,7 @@
주차(store.month_weeks — 그 달 안, 1주차는 1일부터)마다 회의록 하나: 머리 영역 3칸(월 계획 + 숫자 한 줄 | 결정 사항·메모 | 작업 등록)
+ 구역(목표 표 업무 영역)별 줄 — 주요 업무·정량 목표 | 지난주: 전주 업무·결과(글)·전주 목표·결과(금액).
지난주 칸은 바로 앞 주차 회의록의 같은 줄(연결키). 월 누적 실적은 실적 모듈, 월 누적 목표는 목표 표 주차별 목표 합.
입력은 관리자만(칸별 즉시 저장, project.js initGoalMeeting). DB: project_db 015·020. #}
입력은 누구나(완료 전까지, 칸별 즉시 저장, project.js initGoalMeeting). DB: project_db 015·020. #}
<div class="pj-wrap pj-inbox-view pj-goal-view pj-meet-view" data-me="{{ (user.email if user else '') | lower }}">
<div class="pj-layout">
{% if not meeting_embedded %}{% with current_pid = 0, side_active = "goals" %}{% include "project/_side.html" %}{% endwith %}{% endif %}
@@ -38,15 +38,15 @@
<a class="pj-btn pj-btn-sm" href="/project/goals/{{ py }}/meetings/{{ pm }}">‹ {{ pm }}월</a>
<a class="pj-btn pj-btn-sm" href="/project/goals/{{ ny }}/meetings/{{ nm }}">{{ nm }}월 ›</a>
{% if meeting %}
{# 회의록은 프로젝트 권한이 있는 누구나 고친다. [회의 완료](관리자) = 수정 잠금, 완료 뒤 [완료 해제](관리자) — 마이그레이션 022 #}
{# 회의록은 프로젝트 권한이 있는 누구나 고친다. [회의 완료](Pro user 이상) = 수정 잠금, 완료 뒤 [완료 해제](Pro user 이상) — 마이그레이션 022 #}
<span class="pj-meet-title-acts">
<button type="button" class="pj-btn pj-btn-sm" id="pj-meet-print"><span class="material-symbols-outlined">print</span> 인쇄</button>
{% if is_admin %}<button type="button" class="pj-btn pj-btn-sm pj-btn-danger" id="pj-meet-del">회의록 삭제</button>{% endif %}
{% if pj_pro %}<button type="button" class="pj-btn pj-btn-sm pj-btn-danger" id="pj-meet-del">회의록 삭제</button>{% endif %}
{% if meeting.can_complete %}
{% if meeting.completed %}
<span class="pj-meet-done-badge" title="{{ meeting.completed_at }}{% if meeting.completed_by %} · {{ meeting.completed_by }}{% endif %} — 완료된 회의록은 고칠 수 없습니다"><span class="material-symbols-outlined">lock</span>회의 완료</span>
{% if is_admin %}<button type="button" class="pj-btn pj-btn-sm" id="pj-meet-reopen" title="다시 고칠 수 있게 엽니다">완료 해제</button>{% endif %}
{% elif is_admin %}<button type="button" class="pj-btn pj-btn-sm pj-meet-complete-btn" id="pj-meet-complete" title="이 회의록을 더 고칠 수 없게 잠급니다(관리자)"><span class="material-symbols-outlined">task_alt</span>회의 완료</button>{% endif %}
{% if pj_pro %}<button type="button" class="pj-btn pj-btn-sm" id="pj-meet-reopen" title="다시 고칠 수 있게 엽니다">완료 해제</button>{% endif %}
{% elif pj_pro %}<button type="button" class="pj-btn pj-btn-sm pj-meet-complete-btn" id="pj-meet-complete" title="이 회의록을 더 고칠 수 없게 잠급니다(Pro user 이상)"><span class="material-symbols-outlined">task_alt</span>회의 완료</button>{% endif %}
{% endif %}
</span>
{% endif %}
@@ -144,7 +144,7 @@
{% if meeting and not meeting.completed %}{% include "project/_cell_format.html" %}{% endif %}
<div class="pj-view pj-meet-pane" id="pj-meet-pane" data-week="{{ week }}" data-year="{{ goal_year }}"
data-month="{{ goal_month }}" data-admin="{{ 'true' if is_admin else 'false' }}"
data-month="{{ goal_month }}" data-pro="{{ 'true' if pj_pro else 'false' }}"
data-edit="{{ 'true' if meeting and not meeting.completed else 'false' }}">
{% if not meetings_enabled %}
@@ -210,7 +210,7 @@
<th colspan="4" class="is-prev">지난주 리뷰 ({{ prev_week[5:] | replace('-', '/') }} ~ {{ prev_week_end[5:] | replace('-', '/') }}){% if not h.prev_exists %} <span class="pj-meet-noprev">— 이 주 회의록 없음</span>{% endif %}</th>
</tr>
<tr>
<th class="pj-meet-c-sec">구역</th>
<th class="pj-meet-c-sec">구분</th>
<th class="pj-meet-c-label">항목</th>
<th class="pj-meet-c-text">주요 업무</th>
<th class="pj-meet-c-amt">정량 목표</th>
@@ -291,5 +291,5 @@
<script src="/static/project-goal-text.js?v=20261003d" defer></script>
<script src="/static/project-meeting-cells.js?v=20261007a" defer></script>
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -11,7 +11,7 @@
{# 연간 목표 — 좌측 사이드바 "목표" → 연도. 스프레드시트처럼 한 표에
① 매출(목표·실적·달성)·로아스(목표·실적) 월별 숫자
② 업무 영역(상품·마케팅·컨텐츠·유통 …)별 연간·월별 글.
입력·구조 변경은 관리자만(칸별 즉시 저장, project.js initGoals), 나머지는 보기만.
입력·구조 변경은 Pro user 이상(칸별 즉시 저장, project.js initGoals), 나머지는 보기만.
DB: project_db 013 (goal_years·goal_metrics·goal_areas·goal_rows·goal_cells). #}
<div class="pj-wrap pj-inbox-view pj-goal-view">
<div class="pj-layout">
@@ -22,7 +22,7 @@
<h2 class="pj-goal-title">{{ goal_year }}년 목표</h2>
{% if board %}
<div class="pj-goal-head-acts">
{% if is_admin %}
{% if pj_pro %}
<label class="pj-goal-unit">매출 단위
<input type="text" id="pj-goal-unit" maxlength="20" placeholder="예: 백만원"
value="{{ board.sales_unit }}" data-year="{{ goal_year }}" />
@@ -31,13 +31,13 @@
data-year="{{ goal_year }}">연도 삭제</button>
{% else %}
{% if board.sales_unit %}<span class="pj-goal-unit-ro">매출 단위: {{ board.sales_unit }}</span>{% endif %}
<span class="pj-goal-note">목표는 관리자만 입력할 수 있습니다.</span>
<span class="pj-goal-note">목표는 Pro user 이상만 입력할 수 있습니다.</span>
{% endif %}
</div>
{% endif %}
</div>
{% if is_admin and goals_enabled and board %}
{% if pj_pro and goals_enabled and board %}
{% include "project/_cell_format.html" %}
{% endif %}
<div class="pj-view pj-goal-pane" id="pj-goal-pane">
@@ -46,7 +46,7 @@
{% elif not board %}
<div class="pj-empty pj-goal-empty">
<p>{{ goal_year }}년 목표가 아직 없습니다.</p>
{% if is_admin %}
{% if pj_pro %}
<p class="pj-goal-empty-sub">만들면 가장 가까운 이전 연도의 업무 영역 구성을 그대로 가져옵니다(처음이면 상품·마케팅·컨텐츠·유통).</p>
<button type="button" class="pj-btn pj-btn-primary" id="pj-goal-create" data-year="{{ goal_year }}">{{ goal_year }}년 목표 만들기</button>
{% endif %}
@@ -60,7 +60,7 @@
{% macro num_cell(metric, kind, labels, mo) -%}
{%- set weekly = week_targets and metric == 'sales' and kind == 'target' -%}
<td class="pj-goal-numtd pj-goal-m{% if mo == this_month %} is-now{% endif %}{% if weekly %} is-weekly{% endif %}" data-h="{{ (mo - 1) // 3 + 1 }}">
{%- if is_admin -%}
{%- if pj_pro -%}
<input type="text" class="pj-goal-num" inputmode="decimal" autocomplete="off"
data-metric="{{ metric }}" data-kind="{{ kind }}" data-month="{{ mo }}"
{%- if weekly %} readonly data-weekly="1" title="{{ mo }}월 목표·주차별 목표 입력"{% endif %}
@@ -72,7 +72,7 @@
</td>
{%- endmacro %}
<table class="pj-goal-table" id="pj-goal-table" data-year="{{ goal_year }}"
data-admin="{{ 'true' if is_admin else 'false' }}"
data-pro="{{ 'true' if pj_pro else 'false' }}"
data-halves="{{ 'true' if board.halves else 'false' }}">
<thead>
<tr>
@@ -144,7 +144,7 @@
</tr>
</tbody>
{# ── 업무 영역 — 영역마다 tbody 하나, 배경은 영역 색. 이름은 눌러서 그 자리에서 수정(관리자) ── #}
{# ── 업무 영역 — 영역마다 tbody 하나, 배경은 영역 색. 이름은 눌러서 그 자리에서 수정(Pro user 이상) ── #}
{% for area in board.areas %}
<tbody class="pj-goal-area" data-area-id="{{ area.id }}" data-color="{{ area.color }}" style="--goal-bg: {{ area.color or '#fff' }}">
{% for row in area.rows %}
@@ -152,22 +152,22 @@
{% if loop.first %}
<th class="pj-goal-c1 pj-goal-area-name" rowspan="{{ area.rows | length }}">
{# 구역 메뉴(색·위로·아래로·줄 추가·영역 삭제) — 우클릭 또는 ⋮ 버튼(키보드 Tab → Enter/Space, 터치 탭). project.js areaMenuItems #}
<span class="pj-goal-area-text"{% if is_admin %} data-goal-edit="area" tabindex="0" role="button" title="눌러서 이름 수정(Enter) · 우클릭·⋮ = 메뉴"{% endif %}>{{ area.name }}</span>
{% if is_admin %}<button type="button" class="pj-goal-menu-btn" data-goal-menu="area" aria-haspopup="menu" aria-expanded="false"
<span class="pj-goal-area-text"{% if pj_pro %} data-goal-edit="area" tabindex="0" role="button" title="눌러서 이름 수정(Enter) · 우클릭·⋮ = 메뉴"{% endif %}>{{ area.name }}</span>
{% if pj_pro %}<button type="button" class="pj-goal-menu-btn" data-goal-menu="area" aria-haspopup="menu" aria-expanded="false"
aria-label="{{ area.name }} 구역 메뉴" title="구역 메뉴"><span class="material-symbols-outlined" aria-hidden="true">more_vert</span></button>{% endif %}
</th>
{% endif %}
{# 항목 칸(2열) — 같은 항목 칸으로 묶인 줄(016 label_cont)은 묶음 첫 줄이 rowspan 으로 덮는다 #}
{% if not row.label_cont %}
<th class="pj-goal-c2 pj-goal-row-label"{% if (row.label_span or 1) > 1 %} rowspan="{{ row.label_span }}"{% endif %} data-label-span="{{ row.label_span or 1 }}">
<span class="pj-goal-row-text"{% if is_admin %} data-goal-edit="row" tabindex="0" role="button" title="눌러서 줄 이름 수정(Enter) · 우클릭·⋮ = 메뉴"{% endif %}>{{ row.label }}</span>
{% if is_admin %}<button type="button" class="pj-goal-menu-btn" data-goal-menu="row" aria-haspopup="menu" aria-expanded="false"
<span class="pj-goal-row-text"{% if pj_pro %} data-goal-edit="row" tabindex="0" role="button" title="눌러서 줄 이름 수정(Enter) · 우클릭·⋮ = 메뉴"{% endif %}>{{ row.label }}</span>
{% if pj_pro %}<button type="button" class="pj-goal-menu-btn" data-goal-menu="row" aria-haspopup="menu" aria-expanded="false"
aria-label="{{ (row.label or '이름 없는') }} 줄 메뉴" title="줄 메뉴"><span class="material-symbols-outlined" aria-hidden="true">more_vert</span></button>{% endif %}
</th>
{% endif %}
{# 칸 배치는 router._goal_area_layout — 엑셀식 사각형 병합(colspan·rowspan), 가려진 칸은 없다 #}
{% for c in row.layout %}
{% set editable = is_admin and (c.kind != 'quarter' or (board.halves and (c.m not in (15, 16) or board.quarters))) %}
{% set editable = pj_pro and (c.kind != 'quarter' or (board.halves and (c.m not in (15, 16) or board.quarters))) %}
{% set merged = c.span > 1 or c.rspan > 1 %}
<td class="pj-goal-texttd {{ 'pj-goal-m' if c.kind == 'month' else ('pj-goal-year-col' if c.kind == 'year' else 'pj-goal-half-col') }}{% if merged %} is-merged{% endif %}{% if c.now %} is-now{% endif %}"
{% if c.kind in ('month', 'quarter') %}data-h="{{ c.h }}" {% endif %}data-month="{{ c.m }}" data-span="{{ c.span }}" data-rspan="{{ c.rspan }}"
@@ -186,7 +186,7 @@
</tbody>
{% endfor %}
</table>
{% if is_admin %}
{% if pj_pro %}
<div class="pj-goal-foot">
<button type="button" class="pj-btn" id="pj-goal-area-add">+ 업무 영역 추가</button>
<span class="pj-goal-note">칸을 고치면 바로 저장됩니다. 글자를 드래그해 선택하면 선택한 셀 상단에서 12색 견본·크기 2px 증감·굵게·기울임·밑줄·서식 초기화를 사용할 수 있습니다. 모든 행의 셀 오른쪽 경계를 끌어 열 너비를 조절하고, 더블클릭하면 그 열의 가장 긴 문단에 맞춥니다. 숫자 칸을 비우면 지워집니다. 구역·항목 칸을 우클릭하거나 칸의 ⋮ 버튼(키보드 Tab·Enter, 터치)을 누르면 색·순서·줄 추가·삭제 메뉴가 나옵니다.
@@ -207,5 +207,5 @@
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project-goal-text.js?v=20261003d" defer></script>
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
+79 -45
View File
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/project-help.css?v=20261003a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -33,7 +33,7 @@
<li><a href="#comments">댓글과 @태그</a></li>
<li><a href="#inbox">수신함과 알림</a></li>
<li><a href="#search">전체 검색과 공유 링크</a></li>
<li><a href="#trash">휴지통 (관리자)</a></li>
<li><a href="#trash">휴지통 (Pro user 이상)</a></li>
<li><a href="#goals">연간 목표</a></li>
<li><a href="#meetings">주간 회의록</a></li>
<li><a href="#tips">단축키와 자주 묻는 질문</a></li>
@@ -96,7 +96,7 @@
<h2><span class="pjh-num">2</span>화면 구성</h2>
<div class="pjh-map" aria-hidden="true">
<div class="pjh-map-top"><span><b>위쪽 바</b>화면 이름</span><span>🔔 알림 · 내 이름 · 로그아웃 · <b style="display:inline">?</b> 도움말 · 옵션</span></div>
<div class="pjh-map-side"><b>왼쪽 사이드바</b>전체 검색<br>수신함 · 전체 보기(관리자) · 내 작업 · 휴지통 · 목표<br>프로젝트 목록<br>완료 프로젝트<br>전체 멤버</div>
<div class="pjh-map-side"><b>왼쪽 사이드바</b>전체 검색<br>수신함 · 전체 보기(Pro user 이상) · 내 작업 · 휴지통 · 목표<br>프로젝트 목록<br>완료 프로젝트<br>전체 멤버</div>
<div class="pjh-map-main"><b>가운데 작업 영역</b>왼쪽 위: 프로젝트 제목 · 멤버<br>그 아래: 보기 탭(보드 · 목록 · 캘린더 · 타임라인 · 대시보드)<br>필터 바<br>작업들</div>
</div>
<h3>왼쪽 사이드바</h3>
@@ -104,12 +104,12 @@
<li><b>전체 검색</b> — 내가 볼 수 있는 모든 작업을 제목·설명·댓글로 찾습니다. (<a href="#search">18장</a>)</li>
<li><b>수신함</b> — 나를 태그한 작업과 알림. 숫자 배지는 아직 확인하지 않은 @태그 수입니다. (<a href="#inbox">17장</a>)</li>
<li><b>내 작업</b> — 내가 담당자인 작업 모음. 숫자 배지는 아직 끝나지 않은 작업 수입니다. (<a href="#mytasks">15장</a>)</li>
<li><b>휴지통</b> — 지운 작업을 3개월 보관합니다. 관리자에게만 보입니다. (<a href="#trash">19장</a>)</li>
<li><b>휴지통</b> — 지운 작업을 3개월 보관합니다. Pro user 이상에게만 보입니다. (<a href="#trash">19장</a>)</li>
<li>왼쪽 메뉴의 오른쪽 경계를 끌면 너비를 최소 170px까지 줄일 수 있습니다. 경계에 키보드 포커스를 놓고 좌우 방향키로도 조절할 수 있으며 너비는 내 브라우저에 기억됩니다. 전체 멤버는 메뉴 너비에 맞춰 4열 또는 3열로 자동 배치됩니다.</li>
<li><b>목표</b> — 연도를 골라 매출·로아스와 업무 영역별 연간·분기·월 계획을 봅니다. (<a href="#goals">연간 목표 설명</a>)</li>
<li><b>주간 회의록</b> — 목표 표의 월 이름을 눌러 이번주 계획과 지난주 리뷰를 함께 봅니다. (<a href="#meetings">주간 회의록 설명</a>)</li>
<li><b>프로젝트</b> — 내가 멤버인 프로젝트 목록입니다. 누르면 그 프로젝트 화면으로 갑니다. 완료한 프로젝트는 아래 <b>완료 프로젝트</b>에 흐리게 모입니다.</li>
<li><b>전체 멤버</b> — 관리자에게만 보입니다. 사람 아이콘을 누르면 그 사람이 맡은 모든 작업을 한눈에 봅니다.</li>
<li><b>전체 멤버</b> — Pro user 이상에게만 보입니다. 사람 아이콘을 누르면 그 사람이 맡은 모든 작업을 한눈에 봅니다.</li>
</ul>
<h3>위쪽 바</h3>
<ul>
@@ -120,7 +120,7 @@
기본 시스템 폰트·프리텐다드·나눔 스퀘어·나눔 스퀘어 네오·나눔 스퀘어 라운드 중 선택할 수 있습니다. 설정은 이 브라우저의 모든 Project 화면에서 기억합니다. <span class="pjh-ui">취소</span>는 변경을 적용하지 않고 닫습니다.</li>
</ul>
<h3>프로젝트 제목</h3>
<p>가운데 위 프로젝트 제목에 마우스를 올리면 테두리가 생깁니다. 누르면 그 자리에서 이름을 고칩니다 — <kbd>Enter</kbd>나 바깥을 누르면 저장, <kbd>Esc</kbd>는 취소. (그 프로젝트 멤버·관리자만)</p>
<p>가운데 위 프로젝트 제목에 마우스를 올리면 테두리가 생깁니다. 누르면 그 자리에서 이름을 고칩니다 — <kbd>Enter</kbd>나 바깥을 누르면 저장, <kbd>Esc</kbd>는 취소. (그 프로젝트 멤버인 Pro user 이상만)</p>
<div class="pjh-note"><span class="material-symbols-outlined">info</span>
<div>여러 사람이 동시에 써도 걱정 없습니다. 다른 사람이 바꾼 내용은 <b>약 8초 안에</b> 내 화면에 자동으로 반영됩니다(새로고침하지 않아도 됩니다). 내가 입력 중인 창은 건드리지 않습니다.</div></div>
</section>
@@ -128,27 +128,52 @@
<!-- 3. 권한 -->
<section class="pjh-sec" id="roles">
<h2><span class="pjh-num">3</span>누가 무엇을 할 수 있나요</h2>
<p class="pjh-lead">프로젝트 관리 메뉴는 관리자 페이지에서 “프로젝트 관리” 권한을 받은 직원에게 보입니다.</p>
<p class="pjh-lead">프로젝트 관리 메뉴는 관리자 페이지에서 “프로젝트 관리” 권한을 받은 직원에게 보입니다.
등급은 <b>수퍼관리자 · Admin · Pro user · User</b> 네 가지이며(관리자 페이지에서 지정, 수퍼관리자는 한 명으로 고정), 등급과 상관없이
<b>그 프로젝트의 멤버·소유자만</b> 프로젝트를 볼 수 있습니다(수퍼관리자만 예외).</p>
<h3>프로젝트</h3>
<table class="pjh-table">
<tr><th>할 수 있는 일</th><th>누가</th></tr>
<tr><td>프로젝트 보기</td><td>그 프로젝트의 <b>멤버·소유자만</b>. 관리자도 멤버가 아니면 왼쪽 프로젝트 목록·검색·휴지통에 보이지 않고, 주소를 알아도 열리지 않습니다(최고 관리자만 예외).</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>관리자 (<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>원래 프로젝트 멤버가 아니면 <b>읽기만</b> — 내용·댓글·첨부는 보이지만 고치거나 댓글을 달 수 없습니다(연결된 보드 안에서 섹션 옮기기는 됩니다).</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><th>할 수 있는 일</th><th>Admin</th><th>Pro user</th><th>User</th></tr>
<tr><td>프로젝트 보기, 작업·섹션 만들기·고치기·옮기기</td><td>O</td><td>O</td><td>O</td></tr>
<tr><td>작업 삭제(휴지통으로)</td><td>O</td><td>O</td><td>O</td></tr>
<tr><td>섹션 삭제</td><td>O</td><td>만든 사람만</td><td>만든 사람만</td></tr>
<tr><td>서브프로젝트 만들기</td><td>O</td><td>O</td><td>O</td></tr>
<tr><td>새 프로젝트 만들기 (<span class="pjh-ui">+</span>)</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>프로젝트 이름·색·아이콘 수정 (<span class="pjh-ui">✎</span>·제목 바로 고치기)</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>프로젝트 소유자 바꾸기</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>프로젝트 삭제</td><td>O</td><td>만든 사람만</td><td>만든 사람만</td></tr>
<tr><td>멤버 배정·제외</td><td>O</td><td>O (자기가 멤버인 프로젝트)</td><td>X</td></tr>
<tr><td>사이드바 프로젝트 순서 바꾸기 (<span class="pjh-ui">⣿</span>)</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>댓글 고치기·지우기</td><td>O</td><td>남의 댓글도</td><td>본인 댓글만</td></tr>
<tr><td>휴지통 보기·복구</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>전체 보기(모든 프로젝트 작업 함께 보기)</td><td>O</td><td>O (멤버인 프로젝트 범위)</td><td>X</td></tr>
<tr><td>대시보드 “담당자별 작업 합계”</td><td>O</td><td>O</td><td>X (안 보임)</td></tr>
<tr><td>사이드바 “전체 멤버”</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>수신함·내 작업·PC 알림</td><td>O</td><td>O</td><td>O (자기 것)</td></tr>
</table>
<p>만든 사람 기록이 없는 옛 섹션·프로젝트는 Admin 이상만 지울 수 있습니다. 다른 프로젝트에서 연결돼 온 작업은 원래 프로젝트 멤버가 아니면
<b>읽기만</b> 됩니다(연결된 보드 안에서 섹션 옮기기는 됩니다). 멤버에서 빠지면 그 프로젝트의 작업은 내 작업·수신함·알림·검색에서 사라지고,
예전 링크로도 열리지 않습니다.</p>
<h3>목표·주간 회의록</h3>
<table class="pjh-table">
<tr><th>할 수 있는 일</th><th>Admin</th><th>Pro user</th><th>User</th></tr>
<tr><td>연간 목표 표 보기</td><td>O</td><td>O</td><td>O</td></tr>
<tr><td>목표 표 입력·구조 변경(매출·로아스, 영역·줄, 칸 병합·이동)</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>주차별 매출 목표·월 전체 목표 입력</td><td>O</td><td>O</td><td>X (값 보기만)</td></tr>
<tr><td>연도 추가·삭제</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>회의록 만들기·글 수정·줄 추가·삭제·칸 병합</td><td>O</td><td>O</td><td>O (완료 전까지)</td></tr>
<tr><td>지난주 결과 입력</td><td>O</td><td>O</td><td>O (다음 주 회의록이 열려 있는 동안)</td></tr>
<tr><td>회의 완료·완료 해제(완료하면 수정 잠금)</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>회의록 삭제</td><td>O</td><td>O</td><td>X</td></tr>
<tr><td>회의록 보드 열기·링크 복사</td><td>O</td><td>O</td><td>O</td></tr>
<tr><td>회의록 “작업 등록 표”로 작업 만들기</td><td>내가 멤버인 프로젝트에만</td><td>내가 멤버인 프로젝트에만</td><td>내가 멤버인 프로젝트에만</td></tr>
</table>
</section>
<!-- 4. 프로젝트 -->
<section class="pjh-sec" id="project">
<h2><span class="pjh-num">4</span>프로젝트 만들기·고치기</h2>
<h3>새 프로젝트 만들기 (관리자)</h3>
<h3>새 프로젝트 만들기 (Pro user 이상)</h3>
<ol class="pjh-steps">
<li>왼쪽 사이드바 <b>프로젝트</b> 제목 옆의 <span class="pjh-ui">+</span>를 누릅니다.</li>
<li><b>이름</b>(필수)과 <b>설명</b>을 적습니다.</li>
@@ -156,9 +181,13 @@
<li><b>색상</b>(32가지)과 <b>아이콘</b>을 고릅니다. 아이콘 첫 칸 <span class="pjh-ui">Aa</span>를 고르면 아이콘 대신 이름 첫 글자가 나옵니다.</li>
<li>함께할 <b>멤버</b>에 체크하고 <span class="pjh-ui">만들기</span>를 누릅니다. 만든 사람은 자동으로 프로젝트 주인이 됩니다.</li>
</ol>
<p>프로젝트는 만들어졌는데 일부 멤버를 배정하지 못하면 창이 닫히지 않고 <b>배정하지 못한 멤버</b>가 빨갛게 표시됩니다.
<span class="pjh-ui">실패한 멤버 다시 배정</span>을 누르면 그 멤버만 다시 배정합니다(프로젝트를 또 만들지 않습니다).
창을 닫으면 만든 프로젝트로 넘어가며, 남은 멤버는 프로젝트 화면에서 배정하면 됩니다.
다른 사람을 소유자로 정해 만들면 만든 사람은 일반 멤버로 함께 들어갑니다(나중에 멤버에서 뺄 수 있습니다).</p>
<div class="pjh-tip"><span class="material-symbols-outlined">lightbulb</span>
<div>새 프로젝트는 섹션 없이 빈 보드로 시작합니다. 보드의 <span class="pjh-ui">+ 섹션 추가</span>로 “할 일 · 진행 중 · 완료”처럼 단계를 먼저 만들어 두면 편합니다. (<a href="#board">6장</a>)</div></div>
<h3>프로젝트 수정 (관리자)</h3>
<h3>프로젝트 수정 (Pro user 이상)</h3>
<p>사이드바의 프로젝트 이름에 마우스를 올리면 오른쪽에 <span class="pjh-ui">✎</span>(수정)과 <span class="pjh-ui">×</span>(삭제)가 나옵니다.
이름에서 <b>마우스 오른쪽 버튼</b>을 눌러도 <span class="pjh-ui">열기 · 수정 · 삭제</span> 메뉴가 나옵니다.</p>
<ul>
@@ -166,13 +195,14 @@
<li><b>프로젝트 완료</b>에 체크하면 목록 맨 아래 “완료 프로젝트”로 옮겨지고 흐리게 보입니다.</li>
<li>색이 밝으면(연노랑·하늘색 등) 글자와 아이콘이 자동으로 어둡게 바뀌어 잘 보입니다.</li>
</ul>
<h3>순서 바꾸기 (관리자)</h3>
<p>프로젝트 이름에 마우스를 올리면 왼쪽에 손잡이 <span class="pjh-ui">⣿</span>가 나옵니다. 잡고 위아래로 끌어 놓으면 순서가 저장됩니다.</p>
<h3>순서 바꾸기 (Pro user 이상)</h3>
<p>프로젝트 이름에 마우스를 올리면 왼쪽에 손잡이 <span class="pjh-ui">⣿</span>가 나옵니다. 잡고 위아래로 끌어 놓으면 순서가 저장됩니다.
순서는 모두가 같이 보는 순서이고, 내가 멤버인 프로젝트만 옮길 수 있습니다.</p>
<h3>프로젝트 삭제</h3>
<p><span class="pjh-ui">×</span> 또는 우클릭 <span class="pjh-ui">삭제</span>. <b>프로젝트를 만든 사람만</b> 지울 수 있고, 안의 작업도 모두 함께 지워집니다.</p>
<p><span class="pjh-ui">×</span> 또는 우클릭 <span class="pjh-ui">삭제</span>. <b>프로젝트를 만든 사람</b>(또는 Admin 이상)만 지울 수 있고, 안의 작업도 모두 함께 지워집니다.</p>
<div class="pjh-warn"><span class="material-symbols-outlined">warning</span>
<div>프로젝트 삭제는 되돌릴 수 없습니다. 끝난 프로젝트는 지우기보다 <b>프로젝트 완료</b>로 표시하는 것을 권합니다.</div></div>
<h3>멤버 배정 (관리자)</h3>
<h3>멤버 배정 (Pro user 이상)</h3>
<p>프로젝트 화면 제목 오른쪽에 멤버 사진이 겹쳐서 보입니다.</p>
<ul>
<li><span class="pjh-ui">+</span> — 멤버 배정·제외 창이 열립니다. 지금 멤버는 체크된 채로 나오며, <b>체크하면 배정, 체크를 풀면 제외</b>됩니다(제외는 확인 후). 후보는 프로젝트 관리 권한이 있는 직원이고, 소유자는 뺄 수 없습니다.</li>
@@ -195,9 +225,10 @@
<tr><td>대시보드</td><td>완료·미완료·지연 숫자와 차트로 진행 상황을 볼 때. (<a href="#dashboard">14장</a>)</td></tr>
</table>
<h3>범위: 이 프로젝트 / 전체 프로젝트</h3>
<p>프로젝트 화면은 지금 프로젝트만 보여줍니다. 관리자는 왼쪽 메뉴 수신함 아래 <b>전체 보기</b>를 누르면 내가 볼 수 있는 모든 프로젝트의 작업을 함께 봅니다
<p>프로젝트 화면은 지금 프로젝트만 보여줍니다. Pro user 이상은 왼쪽 메뉴 수신함 아래 <b>전체 보기</b>를 누르면 내가 볼 수 있는 모든 프로젝트의 작업을 함께 봅니다
(왼쪽 프로젝트 목록에서 프로젝트를 누르면 다시 그 프로젝트만).
전체 프로젝트일 때는 위 제목이 <b>전체 프로젝트</b>로 바뀌고, 카드 위에는 어느 프로젝트 작업인지 이름이 붙습니다.</p>
전체 프로젝트일 때는 위 제목이 <b>전체 프로젝트</b>로 바뀌고, 카드 위에는 어느 프로젝트 작업인지 이름이 붙습니다.
다른 프로젝트에서 연결돼 와 <b>읽기만 되는 작업</b>도 한 번씩 함께 보입니다.</p>
<h3>필터 바</h3>
<p>탭 아래 한 줄로 작업을 거르고 정렬합니다. 다섯 가지 보기 모두에 똑같이 적용되고, 프로젝트마다 이 브라우저에 기억됩니다.</p>
<ul>
@@ -408,7 +439,7 @@
<li>위쪽 숫자 카드 4개: <b>완료된 작업 합계 · 미완료 작업 합계 · 마감일이 지난 작업 합계 · 작업 합계</b></li>
<li><b>미완료 작업 합계(섹션별)</b> — 섹션마다 남은 일이 몇 개인지 막대로 보여줍니다. 막대에 마우스를 올리면 숫자가 나옵니다.</li>
<li><b>작업 합계(완료 상태별)</b> — 완료와 미완료 비율을 도넛 차트로 보여줍니다.</li>
<li><b>담당자별 작업 합계(메인·세부 작업, 완료)</b> — 이 범위에서 사람별로 배정된 작업 <b>전부</b>(마감일이 없어도, 필터와 관계없이)를 사람마다 <b>메인 작업·세부 작업 세로 막대</b>로 보여 줍니다(막대 하나 = 그 작업 전체, 초록으로 찬 높이 = 완료율, 위 숫자 = 완료/전체와 %, 이름 아래 = 전체 완료율). 막대를 누르면 오른쪽에서 그 사람의 업무 목록(미완료·완료)이 나오고, 항목을 누르면 작업 편집 창이 열립니다. 편집 창을 닫으면 숫자와 목록이 다시 계산됩니다. 세부 작업은 세부 작업에 지정된 담당자 기준입니다. <b>관리자에게만</b> 보입니다.</li>
<li><b>담당자별 작업 합계(메인·세부 작업, 완료)</b> — 이 범위에서 사람별로 배정된 작업 <b>전부</b>(마감일이 없어도, 필터와 관계없이)를 사람마다 <b>메인 작업·세부 작업 세로 막대</b>로 보여 줍니다(막대 하나 = 그 작업 전체, 초록으로 찬 높이 = 완료율, 위 숫자 = 완료/전체와 %, 이름 아래 = 전체 완료율). 막대를 누르면 오른쪽에서 그 사람의 업무 목록(미완료·완료)이 나오고, 항목을 누르면 작업 편집 창이 열립니다. 편집 창을 닫으면 숫자와 목록이 다시 계산됩니다. 세부 작업은 세부 작업에 지정된 담당자 기준입니다. <b>Pro user 이상에게만</b> 보입니다.</li>
<li>범위(이 프로젝트/전체 프로젝트)와 필터 바 설정을 그대로 따라 계산합니다.</li>
</ul>
</section>
@@ -459,7 +490,10 @@
<h3>수신함 화면</h3>
<ul>
<li><b>나를 태그한 작업</b> — 누가 나를 @태그했는지와 함께 보입니다. <span class="pjh-ui">태그 모두 확인</span>으로 한 번에 확인 처리합니다.</li>
<li><b>알림</b> — 작업 배정 · 작업 완료 · 새 댓글 · 마감 알림이 쌓입니다. 수신함에는 <b>아직 확인하지 않은 것만</b> 나옵니다. 줄을 누르면 수신함에 머문 채 <b>오른쪽에 그 작업 창</b>이 열리고(나를 태그한 작업도 같음), 작업 창이 열린 채 다른 줄을 누르면 작업 창이 그 작업으로 바뀝니다. 한 번 확인한 줄은 다른 줄을 고르거나 창을 닫으면 수신함에서 빠집니다(같은 작업의 태그·알림 줄은 함께). 열지 않고 빼려면 오른쪽 클릭 → <span class="pjh-ui">확인(목록에서 빼기)</span>. 창 맨 위 <span class="pjh-ui">프로젝트로 이동</span>을 누르면 그 작업이 있는 프로젝트 화면으로 갑니다. 창을 닫으면(→| 또는 <kbd>Esc</kbd>) 다시 수신함입니다. <kbd>Ctrl</kbd>+클릭하면 새 탭에서 프로젝트 화면으로 엽니다.</li>
<li><b>알림</b> — 작업 배정 · 작업 완료 · 새 댓글 · 마감 알림이 쌓입니다. 수신함에는 <b>아직 확인하지 않은 것만</b> 나옵니다. 줄을 누르면 수신함에 머문 채 <b>오른쪽에 그 작업 창</b>이 열리고(나를 태그한 작업도 같음), 작업 창이 열린 채 다른 줄을 누르면 작업 창이 그 작업으로 바뀝니다. 한 번 확인한 줄은 다른 줄을 고르거나 창을 닫으면 수신함에서 빠집니다(같은 작업의 태그·알림 줄은 함께). 열지 않고 빼려면 오른쪽 클릭 → <span class="pjh-ui">확인(목록에서 빼기)</span>. 창 맨 위 <span class="pjh-ui">프로젝트로 이동</span>을 누르면 그 작업이 있는 프로젝트 화면으로 갑니다. 창을 닫으면(→| 또는 <kbd>Esc</kbd>) 다시 수신함입니다. <kbd>Ctrl</kbd>+클릭하면 새 탭에서 프로젝트 화면으로 엽니다.
작업 창에서 저장 중이거나 저장하지 못한 내용이 있으면, 다른 줄로 바꾸거나 닫기 전에 저장이 끝나길 기다리고 다시 저장해 봅니다. 그래도 안 되면 <span class="pjh-ui">버리고 넘어가기 / 계속 편집</span>을 묻습니다(작업 창을 직접 닫을 때와 같음).
확인(읽음) 처리가 서버에 저장되지 않은 줄은 굵게 남아 있어 다시 누를 수 있습니다.
다른 프로젝트에서 연결돼 와 읽기만 되는 작업의 알림은, 내가 볼 수 있는 연결된 프로젝트 화면으로 열립니다(웹 팝업·PC 알림도 같음).</li>
<li><span class="pjh-ui">알림 모두 읽음</span>으로 한 번에 읽음 처리합니다. 읽지 않은 알림에서 우클릭 → <span class="pjh-ui">읽음으로 표시</span>도 됩니다.</li>
</ul>
<h3>어떤 알림이 누구에게 가나요?</h3>
@@ -492,10 +526,10 @@
<!-- 19. 휴지통 -->
<section class="pjh-sec" id="trash">
<h2><span class="pjh-num">19</span>휴지통 (관리자)</h2>
<h2><span class="pjh-num">19</span>휴지통 (Pro user 이상)</h2>
<ul>
<li>지운 작업은 바로 사라지지 않고 <b>3개월 동안</b> 휴지통에 보관됩니다. 세부 작업 · 댓글 · 협업자 · 첨부 파일도 함께 보관됩니다.</li>
<li>관리자는 왼쪽 사이드바 <b>휴지통</b>에서 지운 작업 목록(프로젝트 · 삭제한 사람 · 삭제 시각)을 봅니다. 자기가 멤버인 프로젝트의 작업만 보입니다.</li>
<li>Pro user 이상은 왼쪽 사이드바 <b>휴지통</b>에서 지운 작업 목록(프로젝트 · 삭제한 사람 · 삭제 시각)을 봅니다. 자기가 멤버인 프로젝트의 작업만 보입니다.</li>
<li><span class="pjh-ui">복구</span>를 누르면 원래 프로젝트 · 섹션 자리로 그대로 돌아옵니다. 복구된 줄의 <span class="pjh-ui">복구됨 · 열기</span>로 바로 열어 볼 수 있습니다.</li>
<li>3개월이 지나면 영구 삭제됩니다.</li>
</ul>
@@ -506,12 +540,12 @@
<!-- 20. 연간 목표 -->
<section class="pjh-sec" id="goals">
<h2><span class="pjh-num">20</span>연간 목표</h2>
<p class="pjh-lead">한 해의 매출 목표·실적과 업무 계획을 한 표에서 관리합니다. 숫자는 위쪽 지표에, 실행 계획은 아래쪽 업무 영역에 적습니다. 프로젝트 관리 권한이 있는 직원은 볼 수 있고, 입력·구조 변경은 관리자만 할 수 있습니다.</p>
<p class="pjh-lead">한 해의 매출 목표·실적과 업무 계획을 한 표에서 관리합니다. 숫자는 위쪽 지표에, 실행 계획은 아래쪽 업무 영역에 적습니다. 프로젝트 관리 권한이 있는 직원은 볼 수 있고, 입력·구조 변경은 Pro user 이상만 할 수 있습니다.</p>
<h3 id="goals-start">목표 열기와 연도 만들기</h3>
<ol class="pjh-steps">
<li>왼쪽 사이드바 <span class="pjh-ui">목표</span>를 눌러 연도 목록을 펼친 뒤 원하는 연도를 누릅니다. 올해는 목표가 아직 없어도 목록에 보입니다.</li>
<li>관리자는 빈 연도 화면에서 <span class="pjh-ui">해당 연도 목표 만들기</span>, 또는 사이드바의 <span class="pjh-ui">+ 연도 추가</span>로 새 표를 만듭니다.</li>
<li>Pro user 이상은 빈 연도 화면에서 <span class="pjh-ui">해당 연도 목표 만들기</span>, 또는 사이드바의 <span class="pjh-ui">+ 연도 추가</span>로 새 표를 만듭니다.</li>
<li>가장 가까운 이전 연도의 업무 영역·줄 구성을 가져옵니다. 이전 연도가 없으면 다음 연도의 구성을 사용하고, 처음이면 상품·마케팅·컨텐츠·유통으로 시작합니다. 이전 숫자와 계획 글은 복사하지 않습니다.</li>
<li>위쪽 <span class="pjh-ui">매출 단위</span>를 확인한 뒤 월별 숫자와 계획을 입력합니다.</li>
</ol>
@@ -520,7 +554,7 @@
<table class="pjh-table">
<tr><th>칸</th><th>입력·계산 방법</th></tr>
<tr><td>매출 목표</td><td>월 칸을 누르면 그 달 입력 창이 열립니다. 맨 위 <b>월 전체 목표</b>를 직접 넣고, 아래에 <b>주차별 목표</b>(매출 단위)를 넣은 뒤 <span class="pjh-ui">저장</span>합니다. 월 목표는 주차 합계와 따로 저장되고, 맨 아래에 <b>주차 합계</b>와 <b>차이(월 목표 − 주차 합계)</b>가 나옵니다 — +면 아직 주차에 못 나눈 금액, −면 주차 합계가 월 목표를 넘은 것입니다. 주차는 <a href="#meetings-week">주간 회의록 주차</a>와 같습니다.</td></tr>
<tr><td>매출 실적</td><td>관리자가 월별 숫자를 직접 입력합니다. 목표 표의 실적은 회의록의 자동 매출과 별도로 관리하므로 실적 모듈에서 자동으로 채워지지 않습니다.</td></tr>
<tr><td>매출 실적</td><td>Pro user 이상이 월별 숫자를 직접 입력합니다. 목표 표의 실적은 회의록의 자동 매출과 별도로 관리하므로 실적 모듈에서 자동으로 채워지지 않습니다.</td></tr>
<tr><td>매출 단위</td><td>예를 들어 단위가 <b>백만원</b>이면 30은 30,000,000원입니다. 단위를 바꿔도 이미 적은 숫자는 자동 환산되지 않으므로 숫자와 단위를 함께 확인하세요.</td></tr>
<tr><td>연간·분기 매출</td><td>해당 기간에 입력한 월 숫자의 합계입니다. 합계 칸에 따로 입력하지 않습니다.</td></tr>
<tr><td>달성</td><td>실적 ÷ 목표 × 100입니다. 월별로 계산하며, 연간·분기는 <b>기간 전체 목표 합계</b> 대비 입력된 실적 합계로 계산합니다. 목표가 없거나 0이면 달성률을 표시하지 않습니다. 100% 이상은 초록으로 표시됩니다.</td></tr>
@@ -555,7 +589,7 @@
<h3 id="goals-merge">셀 병합·병합 해제</h3>
<ol class="pjh-steps">
<li>관리자는 업무 영역의 글 칸을 마우스로 끌어 여러 칸을 선택한 뒤 우클릭 → <span class="pjh-ui">셀 병합</span>을 누릅니다.</li>
<li>Pro user 이상은 업무 영역의 글 칸을 마우스로 끌어 여러 칸을 선택한 뒤 우클릭 → <span class="pjh-ui">셀 병합</span>을 누릅니다.</li>
<li>가로 병합은 <b>같은 분기의 월 칸끼리</b> 가능합니다. 연간·분기 칸은 세로로만 병합합니다. 선택한 칸들의 글은 순서대로 첫 칸에 모입니다.</li>
<li>병합된 칸을 우클릭 → <span class="pjh-ui">병합 해제</span>하면 다시 나뉩니다. 글은 왼쪽 위 칸에 남습니다.</li>
</ol>
@@ -563,14 +597,14 @@
<h3 id="goals-save">저장 실패와 연도 삭제</h3>
<p>저장 성공 시 칸 테두리가 잠깐 초록으로 바뀝니다. 실패하면 빨간 테두리와 안내가 나오며 입력값은 유지됩니다. 다시 입력하거나 칸을 떠나면 재시도합니다. 저장 안 된 값이 있으면 영역·줄 추가, 병합을 진행하기 전에 저장을 시도하고, 실패하면 해당 작업을 멈춥니다.</p>
<p>저장되지 않은 초안은 내 브라우저에도 잠시 보관합니다. 다음에 같은 화면을 열면 복원하지만, 그 사이 다른 사람이 같은 칸을 바꿨으면 자동으로 덮어쓰지 않습니다. 저장 안 된 상태로 페이지를 떠나려 하면 브라우저가 확인합니다.</p>
<p>관리자의 <span class="pjh-ui">연도 삭제</span>는 그 연도의 숫자·업무 영역·계획 글을 삭제합니다. 확인창에 연도를 직접 입력해야 진행되며 되돌릴 수 없습니다.</p>
<p>Pro user 이상의 <span class="pjh-ui">연도 삭제</span>는 그 연도의 숫자·업무 영역·계획 글을 삭제합니다. 확인창에 연도를 직접 입력해야 진행되며 되돌릴 수 없습니다.</p>
</section>
<!-- 21. 주간 회의록 -->
<section class="pjh-sec" id="meetings">
<h2><span class="pjh-num">21</span>주간 회의록</h2>
<p class="pjh-lead">월 목표를 기준으로 지난주 결과를 리뷰하고 이번주 주요 업무와 금액 목표를 정하는 화면입니다. 연간 목표의 월 계획, 실적 모듈의 매출, 주별 결정 사항을 함께 확인합니다. 프로젝트 관리 권한이 있는 직원은 <b>누구나 회의록을 만들고 고칠 수 있습니다</b>. 관리자가 <span class="pjh-ui">회의 완료</span>를 누르면 그 회의록은 아무도 고칠 수 없게 잠기고(🔒 회의 완료 표시), 관리자는 <span class="pjh-ui">완료 해제</span>로 다시 열 수 있습니다. 회의록 삭제도 관리자만 합니다.</p>
<div class="pjh-tip"><span class="material-symbols-outlined">lightbulb</span><div>지난주 리뷰의 <b>결과</b>(글·금액)는 다음 주 회의에서 적는 값이라, 지난주 회의록이 완료돼 있어도 이번 주 회의록이 열려 있으면 적을 수 있습니다. 이번 주 회의록까지 완료하면 함께 잠깁니다.</div></div>
<p class="pjh-lead">월 목표를 기준으로 지난주 결과를 리뷰하고 이번주 주요 업무와 금액 목표를 정하는 화면입니다. 연간 목표의 월 계획, 실적 모듈의 매출, 주별 결정 사항을 함께 확인합니다. 프로젝트 관리 권한이 있는 직원은 <b>누구나 회의록을 만들고 고칠 수 있습니다</b>. Pro user 이상이 <span class="pjh-ui">회의 완료</span>를 누르면 그 회의록은 아무도 고칠 수 없게 잠기고(🔒 회의 완료 표시), Pro user 이상은 <span class="pjh-ui">완료 해제</span>로 다시 열 수 있습니다. 회의록 삭제도 Pro user 이상만 합니다.</p>
<div class="pjh-tip"><span class="material-symbols-outlined">lightbulb</span><div>지난주 리뷰의 <b>결과</b>(글·금액)는 다음 주 회의에서 적는 값이라, 지난주 회의록이 완료돼 있어도 이번 주 회의록이 열려 있으면 적을 수 있습니다. 이번 주 회의록까지 완료하면 함께 잠깁니다. 다음 주차 회의록이 아직 없으면 그 주 회의록이 열려 있는 동안만 결과를 고칠 수 있습니다.</div></div>
<h3 id="meetings-week">회의록 열기와 주차 기준</h3>
<p>왼쪽 연도 앞 화살표를 누르면 해당 연도의 하위 월 전체를 접거나 펼칠 수 있습니다. 연도 글자를 누르면 연간 목표를 엽니다. 연도와 월의 접기·펼치기 선택은 이 브라우저에 기억됩니다.</p>
@@ -589,7 +623,7 @@
</ol>
<h3 id="meetings-create">회의록 만들기와 이어받는 항목</h3>
<p>선택한 주에 회의록이 없으면 관리자에게 <span class="pjh-ui">해당 주차 회의록 만들기</span>가 보입니다. 화면을 열기만 해서는 회의록이 만들어지지 않습니다.</p>
<p>선택한 주에 회의록이 없으면 <span class="pjh-ui">해당 주차 회의록 만들기</span>가 보입니다(누구나 만들 수 있습니다). 화면을 열기만 해서는 회의록이 만들어지지 않습니다.</p>
<ul>
<li>줄이 있는 가장 가까운 앞선 회의록에서 <b>구역·항목 이름·색·순서</b>를 이어받습니다. 앞선 회의록이 없으면 가장 가까운 다음 회의록의 구성을 가져옵니다.</li>
<li>어느 쪽에도 회의록이 없으면 해당 연도 목표 표의 업무 영역과 기본 양식으로 시작합니다.</li>
@@ -641,9 +675,9 @@
<p>지난주 리뷰는 <b>바로 앞 주차의 같은 항목</b>에서 가져옵니다(앞 주차가 앞 달 마지막 주차일 수 있습니다). 이름 변경·순서 이동·회의록 생성 순서와 관계없이 이어진 같은 줄을 찾습니다. 그 주차 회의록이 없으면 “회의록 없음”, 회의록은 있지만 항목이 없으면 “지난주 회의록에 없는 줄”로 표시합니다. 몇 주 전 기록을 지난주로 대신 보여 주지 않습니다.</p>
<ul>
<li><b>전주 업무</b> — 지난 주차에 적은 주요 업무를 그대로 보여 줍니다(읽기 전용).</li>
<li><b>결과</b>(글) — 지난 주차 업무를 어떻게 했는지 관리자가 적습니다.</li>
<li><b>결과</b>(글) — 지난 주차 업무를 어떻게 했는지 적습니다(누구나).</li>
<li><b>전주 목표</b> — 지난 주차 회의록에서 그 줄에 적은 정량 목표입니다.</li>
<li><b>결과</b>(오른쪽 끝) — 관리자가 지난 주차 결과를 직접 입력합니다. 금액도, <code>18개</code> 같은 글도 됩니다(실적 모듈에서 자동 입력되지 않습니다).</li>
<li><b>결과</b>(오른쪽 끝) — 지난 주차 결과를 직접 입력합니다(누구나, 다음 주 회의록이 열려 있는 동안). 금액도, <code>18개</code> 같은 글도 됩니다(실적 모듈에서 자동 입력되지 않습니다).</li>
<li><b>저장 위치</b> — 이번 화면에서 입력한 지난주 결과(글·금액)는 <b>지난 주차 회의록의 줄</b>에 저장됩니다. 주요 업무·정량 목표는 이번 주차 회의록에 저장됩니다.</li>
<li><span class="pjh-ui">순서 바꾸기</span>는 이번주와 지난주 리뷰의 좌우 배치만 바꿉니다. 선택은 로그인한 사람별로 내 브라우저에 기억됩니다.</li>
</ul>
@@ -669,7 +703,7 @@
<h3 id="meetings-save">저장 확인·인쇄·회의록 삭제</h3>
<p>저장 실패 시 칸이 빨갛게 표시되며 입력값은 남습니다. 다시 입력하거나 칸을 떠나면 재시도합니다. 자동 실적을 갱신해도 다른 칸의 작성 중인 글은 유지됩니다. 저장이 안 된 상태에서는 줄 추가·순서 이동 같은 작업에 앞서 저장을 다시 시도합니다. 실패하면 구조 변경을 멈춥니다. 초안 복원과 페이지 떠남 보호는 <a href="#goals-save">목표의 저장 안내</a>와 같습니다.</p>
<p><span class="pjh-ui">인쇄</span>는 브라우저 인쇄창을 엽니다. 인쇄용 화면에서는 사이드바·작은 달력·편집 도구를 숨깁니다. 브라우저의 PDF 저장도 사용할 수 있습니다.</p>
<p>관리자의 <span class="pjh-ui">회의록 삭제</span>는 선택한 한 주의 회의록과 줄을 삭제합니다. 다음주 화면의 지난주 리뷰도 비게 됩니다. 같은 주를 다시 만들면 항목 구성은 이어질 수 있지만 삭제한 글과 금액은 복구되지 않습니다.</p>
<p>Pro user 이상의 <span class="pjh-ui">회의록 삭제</span>는 선택한 한 주의 회의록과 줄을 삭제합니다. 다음주 화면의 지난주 리뷰도 비게 됩니다. 같은 주를 다시 만들면 항목 구성은 이어질 수 있지만 삭제한 글과 금액은 복구되지 않습니다.</p>
</section>
<!-- 22. 단축키와 FAQ -->
@@ -685,9 +719,9 @@
<tr><td>마우스 오른쪽 버튼</td><td>작업 · 세부 작업 · 섹션 · 프로젝트에서 바로가기 메뉴</td></tr>
</table>
<h3>자주 묻는 질문</h3>
<p><b>Q. 프로젝트가 목록에 안 보여요.</b><br>그 프로젝트의 멤버가 아니면 보이지 않습니다. 관리자에게 멤버 배정을 부탁하세요.</p>
<p><b>Q. 삭제 버튼을 눌렀는데 “삭제는 만든 사람만 할 수 있습니다”라고 나와요.</b><br>작업·섹션·프로젝트는 만든 사람만 지울 수 있습니다. 만든 사람이나 최고 관리자에게 부탁하세요.</p>
<p><b>Q. 작업을 잘못 지웠어요.</b><br>3개월 안이라면 관리자가 휴지통에서 복구할 수 있습니다.</p>
<p><b>Q. 프로젝트가 목록에 안 보여요.</b><br>그 프로젝트의 멤버가 아니면 보이지 않습니다. 그 프로젝트의 Pro user 이상 멤버나 관리자에게 멤버 배정을 부탁하세요.</p>
<p><b>Q. 삭제 버튼을 눌렀는데 “삭제는 만든 사람만 할 수 있습니다”라고 나와요.</b><br>섹션·프로젝트는 만든 사람(또는 Admin 이상)만 지울 수 있습니다. 작업은 멤버 누구나 휴지통으로 지울 수 있습니다.</p>
<p><b>Q. 작업을 잘못 지웠어요.</b><br>3개월 안이라면 Pro user 이상이 휴지통에서 복구할 수 있습니다.</p>
<p><b>Q. 카드 순서를 끌어도 안 바뀌어요.</b><br>필터를 쓰고 있거나 정렬이 “기본”이 아니면 순서를 바꿀 수 없습니다. 필터 바의 <span class="pjh-ui">초기화</span>를 누른 뒤 다시 해 보세요.</p>
<p><b>Q. 다른 사람이 바꾼 내용이 안 보여요.</b><br>보통 8초 안에 자동으로 반영됩니다. 오래 걸리면 새로고침(<kbd>F5</kbd>)하세요.</p>
<p><b>Q. 세부 작업을 다른 프로젝트 작업으로 옮길 수 있나요?</b><br>세부 작업은 같은 프로젝트 안의 작업으로만 옮길 수 있습니다.</p>
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -43,7 +43,7 @@
{% for t in mentioned_tasks %}
<li class="pj-inbox-item pj-mention-item {% if t.unread_mentions %}is-unread{% endif %}" tabindex="0" role="button"
data-task-id="{{ t.id }}" data-project="{{ t.project_id }}"
data-href="/project/p/{{ t.project_id }}?task={{ t.id }}" title="누르면 오른쪽에 작업 창">
data-href="/project/t/{{ t.id }}" title="누르면 오른쪽에 작업 창">
<span class="material-symbols-outlined pj-inbox-icon">alternate_email</span>
<div class="pj-inbox-body">
<div class="pj-inbox-title {% if t.completed_at %}is-done{% endif %}">{{ t.title }}</div>
@@ -70,7 +70,7 @@
<li class="pj-inbox-item {% if not n.is_read %}is-unread{% endif %}" tabindex="0" role="button"
data-id="{{ n.id }}"
{% if n.task_id %}data-project="{{ n.project_id }}" data-task-id="{{ n.task_id }}"{% endif %}
{% if n.project_id %}data-href="/project/p/{{ n.project_id }}{% if n.task_id %}?task={{ n.task_id }}{% endif %}"{% endif %}>
{% if n.task_id %}data-href="/project/t/{{ n.task_id }}"{% elif n.project_id %}data-href="/project/p/{{ n.project_id }}"{% endif %}>
<span class="material-symbols-outlined pj-inbox-icon">
{% if n.type == 'assigned' %}assignment_ind
{% elif n.type == 'completed' %}task_alt
@@ -101,5 +101,5 @@
{% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -17,7 +17,7 @@
{% block content %}
{# 프로젝트 모듈의 첫 화면 = 내 업무. 예전 프로젝트 홈(카드 그리드)은 없앴다. #}
<div class="pj-wrap pj-mytasks-view" data-me="{{ user.email }}"
data-is-admin="{{ 'true' if is_admin else 'false' }}"
data-is-pro="{{ 'true' if pj_pro else 'false' }}" data-is-padmin="{{ 'true' if pj_admin else 'false' }}"
data-is-super="{{ 'true' if user.is_super_admin else 'false' }}">
<div class="pj-layout">
{% with current_pid = 0, side_active = "mytasks" %}{% include "project/_side.html" %}{% endwith %}
@@ -100,5 +100,5 @@
"today": {{ today | tojson }}
}
</script>
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -108,5 +108,5 @@
});
})();
</script>
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host -->
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<!-- 타임라인 vis-timeline — self-host -->
@@ -27,7 +27,7 @@
<div class="pj-wrap pj-project-view"
data-project-id="{{ project.id }}"
data-can-manage="{{ 'true' if can_manage else 'false' }}"
data-is-admin="{{ 'true' if is_admin else 'false' }}"
data-is-pro="{{ 'true' if pj_pro else 'false' }}" data-is-padmin="{{ 'true' if pj_admin else 'false' }}"
data-is-super="{{ 'true' if user.is_super_admin else 'false' }}"
data-me="{{ user.email }}">
@@ -43,7 +43,7 @@
<div class="pj-head-left">
<!-- 프로젝트 제목 + 이 프로젝트의 멤버 아이콘.
마우스를 올리면 이름(data-tip → initHoverTips), 클릭하면 그 사람이
이 프로젝트에서 맡은 업무 팝업, 우클릭(관리자)하면 제외. 목록은
이 프로젝트에서 맡은 업무 팝업, 우클릭(Pro user 이상)하면 제외. 목록은
renderMemberList 가 같은 마크업으로 다시 그린다.
"전체 프로젝트" 스코프에선 제목이 "전체 프로젝트"로 바뀌고 멤버는 숨긴다
(.pj-title-wrap.is-all-scope). -->
@@ -66,7 +66,7 @@
</span>
{% endfor %}
</div>
{% if is_admin %}
{% if pj_pro %}
<button type="button" class="pj-title-addmember" id="pj-add-member" title="멤버 배정·제외">+</button>
{% endif %}
</div>
@@ -80,7 +80,7 @@
</div>
<!-- 아사나처럼 기본은 "이 프로젝트"만 보여준다. 전체 프로젝트 보기는
예전처럼 접근 가능한 모든 프로젝트를 합쳐서 보여주는 모드. -->
{# 2026-10-08 — 토글은 숨기고 왼쪽 메뉴 "전체 보기"(관리자만, ?scope=all)로 바꿈. 상태 보관용으로만 남김 #}
{# 2026-10-08 — 토글은 숨기고 왼쪽 메뉴 "전체 보기"(Pro user 이상, ?scope=all)로 바꿈. 상태 보관용으로만 남김 #}
<div class="pj-view-tabs" id="pj-scope-toggle" style="display:none">
<button type="button" class="pj-tab is-active" data-scope="project">이 프로젝트</button>
<button type="button" class="pj-tab" data-scope="all">전체 프로젝트</button>
@@ -425,7 +425,7 @@
</div>
</div>
{% if is_admin %}
{% if pj_pro %}
<!-- 멤버 배정 모달 — 등록된 사용자(프로젝트 권한 보유)를 자동 목록화 -->
<div class="pj-modal" id="pj-modal-member" hidden>
<div class="pj-modal-card">
@@ -488,5 +488,5 @@
</script>
<script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script>
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
@@ -1,14 +1,14 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261008d" />
<link rel="stylesheet" href="/static/project.css?v=20261012a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
{% block topbar_after_logout %}{% include "project/_help_btn.html" %}{% endblock %}
{% block content %}
{# 휴지통 — 관리자 전용. 지운 업무(세부 업무·댓글·팔로워·첨부 포함)를 3개월
{# 휴지통 — Pro user 이상. 지운 업무(세부 업무·댓글·팔로워·첨부 포함)를 3개월
보관하고, [복구] 로 원래 id 그대로 되살린다(project_db 010). #}
<div class="pj-wrap pj-inbox-view pj-trash-view">
<div class="pj-layout">
@@ -17,7 +17,7 @@
<section class="pj-main">
<div class="pj-section-head">
<h2>휴지통</h2>
<span class="pj-trash-note">삭제한 작업은 3개월 동안 보관된 뒤 영구 삭제됩니다. 복구는 관리자만 할 수 있습니다.</span>
<span class="pj-trash-note">삭제한 작업은 3개월 동안 보관된 뒤 영구 삭제됩니다. 복구는 Pro user 이상만 할 수 있습니다.</span>
</div>
<div class="pj-view pj-inbox-pane">
{% if not trash_enabled %}
@@ -70,5 +70,5 @@
{% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20261008d" defer></script>
<script src="/static/project.js?v=20261012b" defer></script>
{% endblock %}
+6
View File
@@ -1028,6 +1028,12 @@ html.pj-ui-scale #pj-timeline { zoom: calc(1 / var(--pj-z)); --tz: var(--pj-z);
.pj-member-pick-avatar .pj-member-pick-icon.material-symbols-outlined { font-size: 40px; }
.pj-member-pick-avatar img.pj-member-pick-icon { width: 36px; height: 36px; }
.pj-member-pick-stacked .pj-member-pick-name { font-size: 12.5px; }
/* 새 프로젝트 — 만든 뒤 배정에 실패한 멤버(다시 배정 대상)와 안내줄 */
.pj-member-pick-stacked.is-failed { background: #fdecec; box-shadow: inset 0 0 0 1px #f1a8a8; }
.pj-member-pick-stacked.is-failed .pj-member-pick-name { color: #b42318; }
.pj-modal-msg { margin: 8px 0 0; padding: 8px 10px; border-radius: 6px; font-size: 12.5px; line-height: 1.5;
background: #f5f6f8; color: #333; }
.pj-modal-msg.is-error { background: #fdecec; color: #b42318; }
/* ── 좌측 사이드바 "전체 멤버" — 메뉴의 실제 내부 폭에 따라 4열↔3열, 아이콘 아래 이름(새 프로젝트
모달의 pj-member-pick-stacked 와 같은 아이콘 크기 재사용). ── */
+282 -114
View File
@@ -1267,7 +1267,7 @@
// ── 새 프로젝트 모달 (#pj-modal-project) — 좌측 사이드바 "+" 버튼 ──
// 내 업무 화면과 프로젝트 화면이 같은 마크업/동작을 쓴다. 만들어진 뒤
// 화면마다 할 일(트리 갱신 등)만 onCreated 로 받는다.
function initNewProjectModal(isAdmin, onCreated) {
function initNewProjectModal(isPro, onCreated) {
const btn = el("pj-new-project-side");
const modal = el("pj-modal-project");
if (!btn || !modal) return;
@@ -1278,9 +1278,9 @@
btn.addEventListener("click", async function () {
openModal(modal);
if (!membersBox) return;
// 멤버 배정은 관리자 전용 API — 관리자가 아니면 시도하지 않고 안내만.
if (!isAdmin) {
membersBox.innerHTML = "<span class='pj-empty-sm'>멤버 배정은 관리자가 나중에 할 수 있습니다.</span>";
// 멤버 배정은 Pro user 이상 API — 아니면 시도하지 않고 안내만(모달 자체가 Pro user 이상에게만 그려진다).
if (!isPro) {
membersBox.innerHTML = "<span class='pj-empty-sm'>멤버 배정은 Pro user 이상이 나중에 할 수 있습니다.</span>";
return;
}
membersBox.innerHTML = "불러오는 중…";
@@ -1294,38 +1294,107 @@
membersBox.innerHTML = "<span class='pj-empty-sm'>불러오기 실패</span>";
}
});
el("pj-save-project").addEventListener("click", async function () {
// 만들기는 두 단계 — ① 프로젝트 생성(한 번만) ② 고른 멤버 배정(사람마다). 생성이 끝난 뒤 배정이 실패하면
// 창을 닫지 않고 실패한 사람을 표시한다 — [다시 배정]은 실패한 사람만 다시 보내고 프로젝트를 또 만들지 않는다.
// 진행 중 연타는 무시하고, 진행 중 [취소]·바깥 클릭으로 닫아도 요청은 끝까지 가며 결과는 알림으로 알린다.
const saveBtn = el("pj-save-project");
const msgBox = el("pj-f-project-msg");
let created = null; // 이번 창에서 이미 만든 프로젝트(다시 배정 때 재사용)
let assigned = new Set(); // 이미 배정에 성공한 이메일
let saving = false;
function setMsg(html, isError) {
if (!msgBox) return;
msgBox.hidden = !html;
msgBox.innerHTML = html || "";
msgBox.classList.toggle("is-error", !!isError);
}
function resetForm() {
created = null;
assigned = new Set();
setMsg("");
saveBtn.textContent = "만들기";
["pj-f-name", "pj-f-desc", "pj-f-due"].forEach(function (id) { el(id).value = ""; el(id).disabled = false; });
if (membersBox) membersBox.querySelectorAll(".pj-member-pick").forEach(function (l) { l.classList.remove("is-failed"); });
getColor = renderColorPalette(el("pj-f-colors"), null, "#4573d2");
getIcon = renderIconPalette(el("pj-f-icons"), "");
}
function finish() {
const p = created;
closeModal(modal);
resetForm();
if (p && onCreated) onCreated(p);
}
// 만든 뒤 배정에 실패한 채로 창을 닫으면 — 만든 프로젝트로 넘어간다(멤버는 프로젝트 화면에서 다시 배정).
new MutationObserver(function () {
if (!modal.hidden || saving || !created) return;
showToast("프로젝트는 만들어졌습니다. 배정하지 못한 멤버는 프로젝트 화면에서 다시 배정하세요.", "error");
finish();
}).observe(modal, { attributes: true, attributeFilter: ["hidden"] });
saveBtn.addEventListener("click", async function () {
if (saving) return;
const name = el("pj-f-name").value.trim();
if (!name) { alert("이름을 입력하세요."); return; }
const memberEmails = membersBox
? Array.from(membersBox.querySelectorAll("input[type=checkbox]:checked")).map(function (c) { return c.value; })
if (!created && !name) { alert("이름을 입력하세요."); return; }
const picked = membersBox
? Array.from(membersBox.querySelectorAll("input[type=checkbox]:checked"))
: [];
saving = true;
saveBtn.disabled = true;
try {
const res = await api("POST", "/project/api/projects", {
name: name,
description: el("pj-f-desc").value.trim(),
due_date: el("pj-f-due").value || null,
color: getColor(),
icon: getIcon() || undefined,
});
const pid = res.project.id;
for (const email of memberEmails) {
try { await api("POST", "/project/api/projects/" + pid + "/members", { user_email: email }); }
catch (_) {}
if (!created) {
try {
const res = await api("POST", "/project/api/projects", {
name: name,
description: el("pj-f-desc").value.trim(),
due_date: el("pj-f-due").value || null,
color: getColor(),
icon: getIcon() || undefined,
});
created = res.project;
} catch (e) {
if (modal.hidden) showToast("프로젝트를 만들지 못했습니다: " + e.message, "error");
else setMsg("프로젝트를 만들지 못했습니다: " + escapeHtml(e.message), true);
return;
}
}
closeModal(modal);
el("pj-f-name").value = ""; el("pj-f-desc").value = "";
el("pj-f-due").value = "";
getColor = renderColorPalette(el("pj-f-colors"), null, "#4573d2");
getIcon = renderIconPalette(el("pj-f-icons"), "");
if (onCreated) onCreated(res.project);
} catch (e) { showToast("생성 실패: " + e.message, "error"); }
const failed = [];
for (const box of picked) {
const email = box.value;
if (assigned.has(email)) continue;
const label = box.closest(".pj-member-pick");
try {
await api("POST", "/project/api/projects/" + created.id + "/members", { user_email: email });
assigned.add(email);
if (label) label.classList.remove("is-failed");
} catch (e) {
failed.push({ email: email, reason: e.message });
if (label) label.classList.add("is-failed");
}
}
if (!failed.length) {
if (modal.hidden) { showToast("프로젝트를 만들었습니다."); }
finish();
return;
}
// 생성은 됐다 — 이름 등은 더 바꿀 수 없게 잠그고, 실패한 멤버만 다시 보내게 한다.
["pj-f-name", "pj-f-desc", "pj-f-due"].forEach(function (id) { el(id).disabled = true; });
saveBtn.textContent = "실패한 멤버 다시 배정";
const html = "프로젝트 '" + escapeHtml(created.name || name) + "' 는 만들어졌습니다. 멤버 " + failed.length +
"명을 배정하지 못했습니다: " + failed.map(function (f) {
return "<b>" + escapeHtml(idOf(f.email)) + "</b>(" + escapeHtml(f.reason) + ")";
}).join(", ") + ". [실패한 멤버 다시 배정]을 누르거나, 창을 닫고 프로젝트 화면에서 배정하세요.";
if (modal.hidden) showToast("프로젝트는 만들어졌지만 멤버 " + failed.length + "명을 배정하지 못했습니다.", "error");
else setMsg(html, true);
} finally {
saving = false;
saveBtn.disabled = false;
if (modal.hidden && created) finish(); // 진행 중에 창을 닫았다 — 끝난 뒤 만든 프로젝트로
}
});
}
// ── 좌측 프로젝트 목록(project/_side.html) — 수신함·내 업무·휴지통·프로젝트
// 네 화면이 모두 이 구현 하나를 쓴다(예전엔 프로젝트 화면에만 있어서 다른
// 화면에선 ✎/×·드래그 순서 변경이 없었다). 관리자에게만 손잡이(⣿)·✎·×·
// 화면에선 ✎/×·드래그 순서 변경이 없었다). Pro user 이상에게만 손잡이(⣿)·✎·×·
// 우클릭 메뉴를 붙이고, 수정/새 프로젝트 모달은 project/_side_modals.html.
// cfg:
// projects 프로젝트 배열 — 주면 제자리에서 고친다(프로젝트 화면이 뷰와
@@ -1337,13 +1406,14 @@
const side = document.querySelector(".pj-side");
const noop = { render: function () {}, merge: function () {} };
if (!side) return noop;
const isAdmin = side.dataset.isAdmin === "true";
const isSuper = side.dataset.isSuper === "true";
// 등급(2026-10-12) — isPro = Pro user 이상(새 프로젝트·✎ 수정·순서 변경), isPAdmin = Admin 이상(남이 만든 프로젝트도 삭제)
const isPro = side.dataset.isPro === "true";
const isPAdmin = side.dataset.isPadmin === "true";
const me = (side.dataset.me || "").toLowerCase();
const currentId = cfg.currentId || 0;
const DELETE_DENIED = "삭제는 만든 사람만 할 수 있습니다.";
function canDelete(createdBy) {
if (isSuper) return true;
if (isPAdmin) return true;
const cb = (createdBy || "").toLowerCase();
return !!cb && cb === me;
}
@@ -1362,7 +1432,7 @@
function treeProjLi(p) {
let acts = "";
if (isAdmin) {
if (isPro) {
acts = '<span class="pj-tree-acts">' +
'<button type="button" class="pj-icon-btn pj-tree-edit" data-id="' + p.id +
'" data-name="' + escapeHtml(p.name) + '" data-desc="' + escapeHtml(p.description || "") +
@@ -1373,9 +1443,9 @@
'" data-name="' + escapeHtml(p.name) + '" data-creator="' + escapeHtml(p.created_by || "") + '" title="프로젝트 삭제">×</button>' +
"</span>";
}
// 드래그로 순서 변경 가능함을 알려주는 손잡이(⣿) — 관리자에게만 보인다.
const handle = isAdmin ? '<span class="pj-tree-handle" title="드래그로 순서 변경">⣿</span>' : "";
return '<li class="pj-tree-li"' + (isAdmin ? ' draggable="true"' : "") + ' data-id="' + p.id + '"><div class="pj-tree-row ' +
// 드래그로 순서 변경 가능함을 알려주는 손잡이(⣿) — Pro user 이상에게만 보인다.
const handle = isPro ? '<span class="pj-tree-handle" title="드래그로 순서 변경">⣿</span>' : "";
return '<li class="pj-tree-li"' + (isPro ? ' draggable="true"' : "") + ' data-id="' + p.id + '"><div class="pj-tree-row ' +
(p.id === currentId ? "is-active" : "") + '">' +
handle +
'<a class="pj-tree-link" href="/project/p/' + p.id + '">' +
@@ -1404,7 +1474,7 @@
function wireTreeHandlers(rootUl) {
// <a> 는 기본 draggable="true" — 그대로 두면 li 대신 링크(URL) 드래그가
// 시작돼 아래 wireTreeDrag 의 dragstart 핸들러가 무력화된다.
if (isAdmin) rootUl.querySelectorAll(".pj-tree-link").forEach(function (a) { a.draggable = false; });
if (isPro) rootUl.querySelectorAll(".pj-tree-link").forEach(function (a) { a.draggable = false; });
rootUl.querySelectorAll(".pj-tree-del").forEach(function (b) {
b.addEventListener("click", function (e) {
e.preventDefault(); e.stopPropagation();
@@ -1417,7 +1487,7 @@
openProjectEditModal(b.dataset);
});
});
if (isAdmin) rootUl.querySelectorAll(".pj-tree-li").forEach(function (li) {
if (isPro) rootUl.querySelectorAll(".pj-tree-li").forEach(function (li) {
li.addEventListener("contextmenu", function (e) {
e.preventDefault();
const editBtn = li.querySelector(".pj-tree-edit");
@@ -1438,8 +1508,9 @@
}
function render() {
let rootUl = el("pj-tree-root");
const active = projects.filter(function (p) { return p.status !== "completed"; });
const done = projects.filter(function (p) { return p.status === "completed"; });
// view_only = 보관된 프로젝트·서브프로젝트를 직접 연 경우 화면용으로만 받은 것 — 목록엔 안 그린다.
const active = projects.filter(function (p) { return p.status !== "completed" && !p.view_only; });
const done = projects.filter(function (p) { return p.status === "completed" && !p.view_only; });
const block = side.querySelector(".pj-tree-block");
// 처음에 프로젝트가 하나도 없었으면 서버가 "프로젝트 없음" 만 그렸다 —
// 새로 만들면 그때 목록(ul)을 만든다.
@@ -1481,11 +1552,11 @@
doneUl.remove();
}
}
// 드래그 순서 변경 — 관리자 전용, 최상위 프로젝트만. rootUl 자체는
// 드래그 순서 변경 — Pro user 이상, 최상위 프로젝트만. rootUl 자체는
// render() 가 innerHTML 만 바꾸고 element 를 갈아치우지 않으므로 리스너는
// 한 번만 붙이면 된다.
function wireTreeDrag(rootUl) {
if (!isAdmin || !rootUl) return;
if (!isPro || !rootUl) return;
let dragLi = null;
rootUl.addEventListener("dragstart", function (e) {
const li = e.target.closest(".pj-tree-li");
@@ -1582,7 +1653,7 @@
enhanceDateInput(el("pj-e-due"), { startInput: el("pj-e-start"), iconOnly: true });
// "+" — 새 최상위 프로젝트. 기본은 만든 프로젝트 화면으로 이동한다.
initNewProjectModal(isAdmin, cfg.onCreated || function (project) {
initNewProjectModal(isPro, cfg.onCreated || function (project) {
location.href = "/project/p/" + project.id;
});
@@ -3091,15 +3162,19 @@
if (!root) return;
const projectId = parseInt(root.dataset.projectId, 10);
const canManage = root.dataset.canManage === "true";
const isAdmin = root.dataset.isAdmin === "true";
// 등급(2026-10-12) — isPro = Pro user 이상(프로젝트 수정·멤버 배정·전체 보기·담당자별 합계·남의 댓글 수정),
// isPAdmin = Admin 이상(남이 만든 섹션도 삭제).
const isPro = root.dataset.isPro === "true";
const isPAdmin = root.dataset.isPadmin === "true";
const me = (root.dataset.me || "").toLowerCase();
const isSuper = root.dataset.isSuper === "true";
// 삭제는 만든 사람만(슈퍼관리자 예외). created_by 없으면 서버가 최종 판정.
// 섹션 삭제 — Admin 이상은 누구 것이든, 그 밖은 만든 사람만. created_by 없으면 서버가 최종 판정.
function canDelete(createdBy) {
if (isSuper) return true;
if (isPAdmin) return true;
const cb = (createdBy || "").toLowerCase();
return !!cb && cb === me;
}
// 작업·세부 작업 삭제(휴지통으로)는 멤버 누구나(2026-10-12) — 서버도 생성자를 보지 않는다.
function canDeleteTask() { return true; }
const DELETE_DENIED = "삭제는 만든 사람만 할 수 있습니다.";
// 댓글 있으면 말풍선 아이콘(+개수). 색은 currentColor 상속(막대=흰, 카드/리스트=진회색).
function cmtBadgeInner(t, cls) {
@@ -3161,7 +3236,7 @@
// Enter/바깥 클릭=저장, Esc=취소. 저장 권한(_require_manage)이 있을 때만.
(function () {
const pill = document.querySelector(".pj-project-title-pill");
if (!pill || !canManage || !projectId) return;
if (!pill || !canManage || !isPro || !projectId) return;
pill.classList.add("is-editable");
pill.title = "클릭해서 프로젝트 이름 수정";
let editing = false;
@@ -3272,10 +3347,19 @@
let taskFilter = Object.assign({}, TASK_FILTER_DEFAULT);
try { Object.assign(taskFilter, JSON.parse(localStorage.getItem(FILTER_KEY) || "{}")); } catch (_) {}
const todayNowP = kstTodayIso; // 한국시간 오늘(그때그때)
// 전체 보기는 작업마다 한 행 — 원 소속 행이 있으면 그 행, 원 소속을 볼 수 없어 연결된 프로젝트의
// 행(읽기 전용)만 있으면 그중 첫 행(예전엔 원 소속 행만 남겨 이런 작업이 전체 보기에서 빠졌다).
function scopeTasks() {
return viewScope === "project"
? tasks.filter(function (t) { return t.context_project_id === projectId; })
: tasks.filter(function (t) { return t.context_project_id === t.project_id; });
if (viewScope === "project") return tasks.filter(function (t) { return t.context_project_id === projectId; });
const home = new Set();
tasks.forEach(function (t) { if (t.context_project_id === t.project_id) home.add(t.id); });
const seen = new Set();
return tasks.filter(function (t) {
if (t.context_project_id === t.project_id) return true;
if (home.has(t.id) || seen.has(t.id)) return false;
seen.add(t.id);
return true;
});
}
// 모든 뷰가 이 함수로 업무를 받는다 — 스코프 → 필터 → 정렬 순.
function visibleTasks() {
@@ -3407,8 +3491,8 @@
r.classList.toggle("is-active", !on);
});
}
if (isAdmin && new URLSearchParams(location.search).get("scope") === "all") applyAllScope(true); // 첫 그리기 전에
if (allViewLink && isAdmin) {
if (isPro && new URLSearchParams(location.search).get("scope") === "all") applyAllScope(true); // 첫 그리기 전에
if (allViewLink && isPro) {
allViewLink.addEventListener("click", function (e) {
if (e.ctrlKey || e.metaKey || e.shiftKey || e.button === 1) return;
e.preventDefault(); // 같은 화면 안에서 바로 전환
@@ -5049,7 +5133,6 @@
{
label: "세부 작업 삭제", danger: true,
onClick: async function () {
if (!canDelete(sub.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(sub.id, sub.title, null))) return;
try {
await deleteTaskRequest(sub.id);
@@ -5833,8 +5916,8 @@
// 담당자별 작업 합계(2026-10-07) — 이 범위에서 그 사람에게 배정된 작업 전부(마감일·필터와 무관),
// 메인 작업과 세부 작업을 나눠 세고 완료 수·완료율. 세부 업무는 화면 목록에 없어 서버에서 따로 받는다.
// 사람별 업무량이 드러나는 표라 관리자에게만 보여준다.
if (isAdmin) {
// 사람별 업무량이 드러나는 표라 Pro user 이상에게만 보여준다(User 는 안 보임).
if (isPro) {
const assigneeCard = document.createElement("div");
assigneeCard.className = "pj-dash-card pj-dash-card-wide";
assigneeCard.innerHTML = '<div class="pj-dash-card-title">담당자별 작업 합계(메인·세부 작업, 완료)</div>' +
@@ -6110,7 +6193,6 @@
{
label: "삭제", danger: true,
onClick: async function () {
if (!canDelete(t.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(t.id, t.title, t.subtask_total))) return;
try {
await deleteTaskRequest(t.id);
@@ -6448,6 +6530,22 @@
closeSlidePanel(taskModal);
} finally { taskClosing = false; }
}
// 수신함 오른쪽 작업 창(iframe, html.pj-embed) — 바깥(수신함)이 다른 줄로 바꾸거나 창을 닫기 전에 부른다.
// 작업 창 닫기와 같은 절차(이미지 업로드·만들기·저장 대기 → 실패 칸 재시도 → "버리고 넘어가기 / 계속 편집").
// true = 넘어가도 됨(이 창의 늦은 응답은 버린다), false = 계속 편집(창·입력 그대로).
if (document.documentElement.classList.contains("pj-embed")) {
let embedSettling = null;
window.__pjEmbedSettle = function () {
if (embedSettling) return embedSettling; // 저장 중 Esc·다른 줄 연타 — 같은 확인 하나를 기다린다
embedSettling = (async function () {
if (taskModal.hidden) return true;
if (!(await settleBeforeLeave())) return false;
taskGen++;
return true;
})();
return embedSettling.finally(function () { embedSettling = null; });
};
}
taskModal.addEventListener("click", function (e) {
if (e.target === taskModal || e.target.closest("[data-close]")) attemptCloseTaskModal();
});
@@ -6535,7 +6633,7 @@
showFollowers(task, detail.followers);
if (subtaskBlock) {
subtaskBlock.setContext({
taskId: task.id, projectId: task.project_id, canDelete: canDelete,
taskId: task.id, projectId: task.project_id, canDelete: canDeleteTask,
readOnly: taskReadOnly,
onOpen: function (sub) { openTaskById(sub.id); },
});
@@ -6962,7 +7060,7 @@
(c.body ? '<div class="pj-comment-body">' + commentBodyHtml(c.body) + "</div>" : "") +
commentAttachmentsHtml((feats._atts || {})[c.id] || []) +
'<div class="pj-react-slot">' + reactionRowHtml(c, me, feats.reactions) + "</div></div>" +
(taskReadOnly ? "" : commentHoverBarHtml(feats, { reply: true, edit: (mine || isAdmin) && !!c.body, del: mine || isAdmin }));
(taskReadOnly ? "" : commentHoverBarHtml(feats, { reply: true, edit: (mine || isPro) && !!c.body, del: mine || isPro }));
wireCommentReactions(item, c, function () {
item.querySelector(".pj-react-slot").innerHTML = reactionRowHtml(c, me, feats.reactions);
});
@@ -7139,7 +7237,6 @@
const id = el("pj-t-id").value;
if (!id) return;
const t = tasks.find(function (x) { return String(x.id) === String(id); });
if (t && !canDelete(t.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(id, el("pj-t-title").value.trim(), null))) return;
try {
await deleteTaskRequest(id);
@@ -7185,7 +7282,7 @@
projectId: projectId, projectName: currentProject.name,
});
});
if (isAdmin) chip.addEventListener("contextmenu", function (e) {
if (isPro) chip.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "제외", danger: true, onClick: function () { removeMember(chip.dataset.email); } },
@@ -8564,21 +8661,39 @@
const notiList = document.getElementById("pj-inbox");
const counter = document.getElementById("pj-mention-unread");
let panel = null;
let selected = []; // 지금 작업 창에 열린 줄들(같은 작업의 태그·알림)
let selected = []; // 지금 작업 창에 열린 줄들(같은 작업의 태그·알림)
let shownLi = null; // 지금 작업 창에 열린 줄(대표) — 창이 닫혀 있으면 null
// 창 바꾸기(다른 줄 열기·닫기)는 한 번에 하나만, 마지막 요청만 따른다 — 저장을 기다리는 사이
// A→B→A 를 빨리 눌러도 확인이 끝난 뒤 그때 원하는 쪽으로 한 번만 바꾼다. undefined = 요청 없음, null = 닫기.
let wanted;
let switching = null;
const readReq = new WeakMap(); // 줄 → 읽음/확인 요청(Promise<boolean>)
function itemsOfTask(li) {
const tid = li.dataset.taskId;
if (!tid) return [li];
return Array.prototype.slice.call(document.querySelectorAll('.pj-inbox-item[data-task-id="' + tid + '"]'));
}
// 읽음/확인 — 서버가 받았을 때만 확인한 것으로 둔다. 실패하면 굵게(읽지 않음) 되돌리고 목록에 남긴다.
function markSeen(li) {
if (li.dataset.seen) return;
li.dataset.seen = "1";
if (readReq.has(li)) return readReq.get(li);
if (li.dataset.seen === "1") return Promise.resolve(true);
li.classList.remove("is-unread");
const req = li.classList.contains("pj-mention-item")
? api("POST", "/project/api/mentions/read", { task_id: Number(li.dataset.taskId) })
: fetch("/project/api/notifications/" + li.dataset.id + "/read", { method: "POST" });
Promise.resolve(req).catch(function () {});
: fetch("/project/api/notifications/" + li.dataset.id + "/read", { method: "POST" })
.then(function (res) { if (!res.ok) throw new Error("HTTP " + res.status); });
const p = Promise.resolve(req).then(function () {
li.dataset.seen = "1";
return true;
}, function (e) {
readReq.delete(li); // 다음에 누르면 다시 보낸다
li.classList.add("is-unread");
showToast("확인 처리에 실패해 목록에 그대로 둡니다: " + ((e && e.message) || ""), "error");
return false;
});
readReq.set(li, p);
return p;
}
function refreshEmpty() {
[[mentionList, "태그된 작업이 없습니다."], [notiList, "알림이 없습니다."]].forEach(function (x) {
@@ -8596,29 +8711,52 @@
counter.hidden = n <= 0;
}
}
// 확인한 줄을 목록에서 뺀다(살짝 접히며).
// 확인이 끝난(서버가 받은) 줄만 목록에서 뺀다(살짝 접히며). 실패한 줄·지금 열린 줄은 남긴다.
function removeItems(list) {
list.forEach(function (li) {
if (!li.isConnected) return;
li.classList.add("is-leaving");
setTimeout(function () { li.remove(); refreshEmpty(); }, 220);
Promise.resolve(readReq.get(li) || li.dataset.seen === "1").then(function (ok) {
if (!ok || !li.isConnected || selected.indexOf(li) >= 0) return;
li.classList.add("is-leaving");
setTimeout(function () { li.remove(); refreshEmpty(); }, 220);
});
});
}
function setSelected(list) {
const prev = selected;
selected = list;
prev.forEach(function (li) { li.classList.remove("is-selected"); });
removeItems(prev.filter(function (li) { return list.indexOf(li) < 0; }));
list.forEach(function (li) { li.classList.add("is-selected"); });
removeItems(prev.filter(function (li) { return list.indexOf(li) < 0; }));
}
function close() {
if (!panel || !panel.classList.contains("is-open")) return;
panel.classList.remove("is-open");
setSelected([]);
const p = panel;
setTimeout(function () { if (!p.classList.contains("is-open")) p.querySelector("iframe").src = "about:blank"; }, 250);
function isOpen() { return !!panel && panel.classList.contains("is-open"); }
function isShown(target) {
if (target === null) return !isOpen();
return isOpen() && !!shownLi && itemsOfTask(shownLi).indexOf(target.li) >= 0;
}
function open(url) {
// 지금 창의 작업 창 저장이 끝나길 기다린다 — 작업 창 닫기와 같은 절차(업로드·만들기·저장 대기 → 실패 칸
// 재시도 → "버리고 넘어가기 / 계속 편집", project.js 의 __pjEmbedSettle). 창이 아직 안 열렸거나 권한 없음
// 화면이면 저장할 입력이 없다. beforeunload 경고에 기대지 않는다(iframe 주소를 바꾸면 경고 없이 사라진다).
async function settleFrame() {
if (!isOpen()) return true;
let fn = null;
try { fn = panel.querySelector("iframe").contentWindow.__pjEmbedSettle; } catch (_) { fn = null; }
if (typeof fn !== "function") return true;
try { return !!(await fn()); } catch (e) {
showToast("작업 창 저장 상태를 확인하지 못했습니다. 작업 창에서 닫아 주세요.", "error");
return false;
}
}
function applyTarget(target) {
if (target === null) {
if (!isOpen()) return;
panel.classList.remove("is-open");
shownLi = null;
setSelected([]);
const p = panel;
setTimeout(function () { if (!p.classList.contains("is-open")) p.querySelector("iframe").src = "about:blank"; }, 250);
return;
}
if (!panel) {
panel = document.createElement("div");
panel.className = "pj-inbox-panel";
@@ -8629,31 +8767,53 @@
if (w) panel.style.width = "min(" + Math.round(w * uiZoom()) + "px, 92vw)";
} catch (_) {}
}
panel.querySelector("iframe").src = url + (url.indexOf("?") >= 0 ? "&" : "?") + "embed=1";
const group = itemsOfTask(target.li);
group.forEach(markSeen); // 실제로 여는 줄만 확인한다(계속 편집을 고르면 새 줄은 그대로)
shownLi = target.li;
setSelected(group);
// /project/t/{id} — 서버가 지금 권한으로 열 수 있는 프로젝트(연결된 프로젝트 포함)로 보내며 embed=1 을 이어 준다.
panel.querySelector("iframe").src = target.href + (target.href.indexOf("?") >= 0 ? "&" : "?") + "embed=1";
void panel.offsetWidth;
panel.classList.add("is-open");
}
function requestPanel(target) {
wanted = target;
if (switching) return switching;
switching = (async function () {
while (wanted !== undefined) {
const t = wanted;
if (isShown(t)) { wanted = undefined; break; }
const ok = await settleFrame();
if (!ok) { wanted = undefined; break; } // 계속 편집 — 창·입력·선택 그대로
if (wanted !== t) continue; // 기다리는 사이 다른 줄·닫기를 눌렀다 — 그쪽으로 다시
wanted = undefined;
applyTarget(t);
}
})().finally(function () { switching = null; });
return switching;
}
function activate(li, newTab) {
const href = li.dataset.href || "";
const group = itemsOfTask(li);
group.forEach(markSeen);
if (newTab && href) { window.open(href, "_blank"); removeItems(group); return; }
if (li.dataset.taskId && href) {
if (selected.indexOf(li) >= 0 && panel && panel.classList.contains("is-open")) return;
setSelected(group);
open(href);
} else if (href) {
location.href = href; // 작업이 없는 프로젝트 알림 — 그 프로젝트로
} else {
removeItems(group); // 갈 곳이 없는 알림 — 읽음 처리하고 빼기만
if (newTab && href) { group.forEach(markSeen); window.open(href, "_blank"); removeItems(group); return; }
if (li.dataset.taskId && href) { requestPanel({ li: li, href: href }); return; }
if (href) {
// 작업이 없는 프로젝트 알림 — 열린 작업 창의 저장을 마친 뒤 그 프로젝트로
requestPanel(null).then(function () {
if (!isShown(null)) return; // 계속 편집
Promise.all(group.map(markSeen)).then(function () { location.href = href; });
});
return;
}
group.forEach(markSeen);
removeItems(group); // 갈 곳이 없는 알림 — 읽음 처리하고 빼기만
}
window.addEventListener("message", function (e) {
if (e.origin === location.origin && e.data && e.data.type === "pj-embed-close") close();
if (e.origin === location.origin && e.data && e.data.type === "pj-embed-close") requestPanel(null);
});
document.addEventListener("keydown", function (e) {
if (e.key === "Escape") { close(); return; }
if (e.key === "Escape") { if (isOpen() || switching) requestPanel(null); return; }
const li = (e.key === "Enter" || e.key === " ") && e.target.closest && e.target.closest(".pj-inbox-item");
if (li && !isImeEnter(e)) { e.preventDefault(); activate(li, false); }
});
@@ -8665,8 +8825,8 @@
return;
}
// 작업 창이 열린 채 왼쪽 수신함 영역(줄 밖)을 누르면 작업 창을 닫는다. 메뉴·모달·알림 팝업 안은 제외.
if (panel && panel.classList.contains("is-open") && e.target.closest &&
e.target.closest(".pj-inbox-view") && !e.target.closest(".pj-inbox-panel, .pj-modal, .pj-ctxmenu, .pj-alert-pop, button")) close();
if (isOpen() && e.target.closest &&
e.target.closest(".pj-inbox-view") && !e.target.closest(".pj-inbox-panel, .pj-modal, .pj-ctxmenu, .pj-alert-pop, button")) requestPanel(null);
});
// 오른쪽 클릭 — 열지 않고 확인(읽음)만
document.addEventListener("contextmenu", function (e) {
@@ -8677,24 +8837,31 @@
{ label: "확인(목록에서 빼기)", onClick: function () { const g = itemsOfTask(li); g.forEach(markSeen); if (selected.indexOf(li) < 0) removeItems(g); } },
]);
});
// 모두 확인 — 그 목록 줄을 모두 빼고, 열린 작업 창도 닫는다
// 모두 확인 — 열린 작업 창의 저장을 마친 뒤 그 목록 줄을 모두 뺀다
function readAll(list, send) {
return async function () {
await requestPanel(null);
if (!isShown(null)) return; // 계속 편집 — 아무것도 바꾸지 않는다
try {
await send();
if (!list) return;
const items = Array.prototype.slice.call(list.querySelectorAll(".pj-inbox-item"));
items.forEach(function (li) { li.dataset.seen = "1"; li.classList.remove("is-unread"); });
removeItems(items);
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
};
}
const mentionsAll = document.getElementById("pj-mentions-readall");
if (mentionsAll) mentionsAll.addEventListener("click", async function () {
try {
await api("POST", "/project/api/mentions/read", {});
close();
if (mentionList) removeItems(Array.prototype.slice.call(mentionList.querySelectorAll(".pj-inbox-item")));
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
});
if (mentionsAll) mentionsAll.addEventListener("click", readAll(mentionList, function () {
return api("POST", "/project/api/mentions/read", {});
}));
const notiAll = document.getElementById("pj-readall");
if (notiAll) notiAll.addEventListener("click", async function () {
try {
const res = await fetch("/project/api/notifications/read-all", { method: "POST" });
if (!res.ok) throw new Error("HTTP " + res.status);
close();
if (notiList) removeItems(Array.prototype.slice.call(notiList.querySelectorAll(".pj-inbox-item")));
} catch (e) { showToast("실패: " + e.message, "error"); }
});
if (notiAll) notiAll.addEventListener("click", readAll(notiList, function () {
return fetch("/project/api/notifications/read-all", { method: "POST" })
.then(function (res) { if (!res.ok) throw new Error("HTTP " + res.status); });
}));
// 자동 테스트(tests/js)에서만 — 창 바꾸기 진행 상태를 기다릴 수 있게.
if (window.__PJ_TEST__) window.__pjInbox = { settling: function () { return switching || Promise.resolve(); } };
}
// ── 실시간 새로고침 ──
@@ -9018,7 +9185,7 @@
const table = el("pj-goal-table");
if (!table) return;
const year = table.dataset.year;
const isAdmin = table.dataset.admin === "true";
const isPro = table.dataset.pro === "true"; // 입력·구조 변경 = Pro user 이상(2026-10-12)
// ── 열 너비 — 셀 오른쪽 경계에서 끌기·더블클릭 맞춤, 브라우저에 기억(localStorage pj_goal_col_w) ──
// · c1·c2 = 왼쪽 이름 두 칸(구분·항목) → 표의 CSS 변수 --goal-c1-w·--goal-c2-w(c2 의 left 도 c1 너비로 정해진다)
@@ -9161,7 +9328,7 @@
function queueCellGrowth(e) {
const field = e.target.closest("input, textarea, [contenteditable='true']");
const td = field && field.closest("td, th");
if (!isAdmin || !td || !table.contains(td)) return;
if (!isPro || !td || !table.contains(td)) return;
growingCells.add(td);
if (growFrame) return;
growFrame = requestAnimationFrame(function () {
@@ -9183,7 +9350,7 @@
const td = e.target.closest("th, td");
if (!td || !table.contains(td)) return;
// 관리자 업무 셀·이름 칸은 아래의 기존 편집 메뉴에 합쳐 표시한다.
if (isAdmin && td.closest("tbody.pj-goal-area") &&
if (isPro && td.closest("tbody.pj-goal-area") &&
(td.tagName === "TH" || table.dataset.halves === "true" || td.dataset.month === "0")) return;
e.preventDefault(); showContextMenu(e.clientX, e.clientY, widthMenuItems(td));
});
@@ -9416,7 +9583,7 @@
closeWeekPop();
const mo = cell.dataset.month, list = (WEEKS && WEEKS[mo]) || [];
const unit = window.PJ_GOAL_UNIT || "";
const edit = isAdmin && cell.tagName === "INPUT";
const edit = isPro && cell.tagName === "INPUT";
weekPop = document.createElement("div");
weekPop.className = "pj-goal-wkpop";
weekPop.innerHTML = '<div class="pj-goal-wkpop-head">' + mo + "월 주차별 매출 목표" +
@@ -9503,7 +9670,7 @@
// 병합 선택(Shift+클릭) — 관리자 전용, 아래에서 채운다. 접기 버튼이 먼저 부르므로 여기 둔다.
let clearMergeSel = function () {};
if (!isAdmin) return;
if (!isPro) return;
// ── 숫자 칸 — Enter·칸 떠남에 저장(createFieldSaver: 같은 칸 요청 차례대로, 늦은 응답이 새 입력을 덮지 않음).
// 서버 표기(쉼표)는 요청 뒤 입력이 그대로일 때만 칸에 넣는다. 실패해도 입력값은 그대로(빨간 테두리), Esc = 저장된 값으로.
@@ -10663,8 +10830,7 @@
initMeetBoard(pane.dataset.week);
initMeetQuickTasks();
const week = pane.dataset.week, year = pane.dataset.year;
const isAdmin = pane.dataset.admin === "true";
// 회의록은 누구나 고친다(2026-10-07) — 회의 완료(잠금)면 아무도 못 고친다(data-edit). 관리자만 삭제·완료·완료 해제.
// 회의록은 누구나 고친다(2026-10-07) — 회의 완료(잠금)면 아무도 못 고친다(data-edit). Pro user 이상만 삭제·완료·완료 해제.
const canEdit = pane.dataset.edit === "true";
const SCROLL_KEY = "pj_meet_scroll";
function reloadKeepScroll() {
@@ -11159,7 +11325,9 @@
'<button type="button" class="pj-btn pj-btn-sm" data-alert-close>닫기</button></div>' +
'<div class="pj-alert-list">' + items.map(function (n) {
const isMention = n.type === "mention";
const href = n.project_id ? "/project/p/" + n.project_id + (n.task_id ? "?task=" + n.task_id : "") : "/project/inbox";
// 서버가 준 주소(작업 = /project/t/{id} — 연결된 프로젝트에서만 읽을 수 있는 작업도 열린다)
const href = n.href || (n.task_id ? "/project/t/" + n.task_id
: n.project_id ? "/project/p/" + n.project_id : "/project/inbox");
return '<a class="pj-alert-item" href="' + escapeHtml(href) + '" data-alert-open="' + escapeHtml(n.id) + '">' +
'<span class="pj-alert-kind ' + (isMention ? "is-mention" : "is-assigned") + '">' +
(isMention ? "나를 태그" : "작업 배정") + "</span>" +
+9 -2
View File
@@ -41,6 +41,13 @@ MODULE_KEYS: tuple[str, ...] = (
# 승인자 권한 키 — 결재 워크플로에서 별도 검사할 때 사용
APPROVER_KEYS: tuple[str, ...] = ("expense_approver", "vacation_approver")
# 관리자 등급(2026-10-12) — 수퍼관리자(SUPER_ADMIN_EMAIL 한 명, 고정·추가 불가) > admin > pro > user.
# 저장하는 role 값은 admin / pro / user 셋뿐 — 수퍼관리자는 role 이 아니라 이메일로 정해진다.
# pro 는 프로젝트 모듈(프로젝트·목표·주간 회의록)에서만 admin 에 가까운 권한을 받고
# (app/modules/project/access.py), 다른 모듈과 관리자 페이지에서는 user 와 같다(is_admin False).
ROLES: tuple[str, ...] = ("admin", "pro", "user")
ROLE_LABELS: dict[str, str] = {"admin": "Admin", "pro": "Pro user", "user": "User"}
def _now_iso() -> str:
return now_kst_iso()
@@ -121,7 +128,7 @@ class UserStore:
email = email.lower().strip()
if not email or "@" not in email:
raise ValueError("올바른 이메일 형식이 아닙니다.")
if role not in ("admin", "user"):
if role not in ROLES:
raise ValueError(f"role 값이 잘못되었습니다: {role}")
is_super = email == SUPER_ADMIN_EMAIL
with self._lock:
@@ -187,7 +194,7 @@ class UserStore:
email = email.lower().strip()
if email == SUPER_ADMIN_EMAIL:
raise PermissionError("슈퍼 관리자 계정은 수정할 수 없습니다.")
if role is not None and role not in ("admin", "user"):
if role is not None and role not in ROLES:
raise ValueError(f"role 값이 잘못되었습니다: {role}")
with self._lock:
data = self._read()
+19 -9
View File
@@ -97,8 +97,9 @@
<input type="email" name="email" required placeholder="email@dbxcorp.co.kr" style="width: 220px;" />
<input type="text" name="name" placeholder="이름(선택)" style="width: 120px;" />
<select name="role">
<option value="user">user</option>
<option value="admin">admin</option>
{% for r in roles | reverse %}
<option value="{{ r }}">{{ role_labels[r] }}</option>
{% endfor %}
</select>
<button type="submit" class="erp-btn erp-btn-primary">사용자 추가</button>
</form>
@@ -109,7 +110,7 @@
<thead>
<tr>
<th style="width: 200px;">사용자</th>
<th style="width: 80px;">역할</th>
<th style="width: 110px;">등급</th>
<th>접근 권한 <span class="erp-mod-group">클릭하여 토글</span></th>
<th style="width: 110px;">최근 로그인</th>
<th style="width: 130px; text-align: right;">동작</th>
@@ -138,11 +139,18 @@
</div>
</td>
<td>
<select class="erp-select" data-field="role"
{% if u.is_super_admin %}disabled{% endif %}>
<option value="user" {% if u.role == 'user' %}selected{% endif %}>user</option>
<option value="admin" {% if u.role == 'admin' %}selected{% endif %}>admin</option>
{# 수퍼관리자는 한 명으로 고정 — 등급을 바꾸거나 다른 사람을 수퍼관리자로 만들 수 없다. #}
{% if u.is_super_admin %}
<select class="erp-select" data-field="role" disabled>
<option value="admin" selected>수퍼관리자</option>
</select>
{% else %}
<select class="erp-select" data-field="role">
{% for r in roles %}
<option value="{{ r }}" {% if u.role == r %}selected{% endif %}>{{ role_labels[r] }}</option>
{% endfor %}
</select>
{% endif %}
</td>
<td class="erp-perm-cell">
{% for key in module_keys %}
@@ -175,8 +183,10 @@
</div>
<p class="erp-section-meta" style="margin-top: var(--sp-16);">
※ <strong>{{ super_admin_email }}</strong> 은(는) 슈퍼 관리자, 권한 변경/삭제 불가(항상 전체 접근).
admin 역할은 기본 전체 ON 이지만 슈퍼관리자가 개별 프로그램 접근을 끌 수 있다.
※ 등급: <strong>수퍼관리자</strong>(<strong>{{ super_admin_email }}</strong> 한 명 고정 — 권한 변경/삭제 불가, 항상 전체 접근, 더 추가할 수 없음)
&gt; <strong>Admin</strong> &gt; <strong>Pro user</strong> &gt; <strong>User</strong>.
Admin 은 기본 전체 ON 이지만 슈퍼관리자가 개별 프로그램 접근을 끌 수 있다.
Pro user 는 Project 모듈(프로젝트·목표·주간 회의록)에서 프로젝트 만들기·수정·멤버 배정·휴지통·목표 입력·회의 완료 등을 할 수 있고, 다른 모듈에서는 User 와 같다.
<code>expense_approver</code> / <code>vacation_approver</code> 는 결재 승인 권한.
</p>
+5 -3
View File
@@ -46,9 +46,11 @@ namespace DbxNotifier
}
}
public string Path => ProjectId > 0
? "/project/p/" + ProjectId + (TaskId > 0 ? "?task=" + TaskId : "")
: "/project/inbox";
// 작업 알림은 공유 링크(/project/t/{id}) — 서버가 지금 권한으로 열 수 있는 프로젝트(연결된 프로젝트 포함)로
// 보낸다. 원 소속 주소로 열면 연결된 프로젝트에서만 읽을 수 있는 사람에게 403 이 났다.
public string Path => TaskId > 0
? "/project/t/" + TaskId
: ProjectId > 0 ? "/project/p/" + ProjectId : "/project/inbox";
}
internal sealed class AlertResult
+116 -19
View File
@@ -46,14 +46,14 @@
| 연결 env | `PROJECT_DB_URL` (미설정 시 "설정 필요" 안내, 앱은 죽지 않음) |
| 진입 권한 | 권한키 `project` (관리자 페이지 토글로 직원별 부여, admin 자동) |
| 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) |
| 생성 권한 | **프로젝트·섹션·작업(하위 작업 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. 다른 사람을 owner 로 지정해 만드는 건 관리자만(비관리자가 `owner_email` 을 남으로 보내면 403) |
| 소유자 변경 | **관리자만**(2026-09-30). owner 는 멤버에서 빠져도 관리 권한이 남으므로, 일반 멤버가 스스로를 owner 로 바꿔 권한 회수를 피할 수 없게 `PUT /api/projects/{id}` 의 `owner_email` 변경은 비관리자 403(같은 값은 무시). 새 owner 는 `project` 권한이 있는 등록 사용자여야 한다(아니면 400) |
| 생성 권한 | **새 최상위 프로젝트는 Pro user 이상(2026-10-12, 6-14). 섹션·작업·서브프로젝트는 그 프로젝트 멤버 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. 다른 사람을 owner 로 지정해 만드는 것도 Pro user 이상 |
| 소유자 변경 | **Pro user 이상**(2026-10-12, 예전 관리자만 2026-09-30). owner 는 멤버에서 빠져도 관리 권한이 남으므로, 일반 멤버가 스스로를 owner 로 바꿔 권한 회수를 피할 수 없게 `PUT /api/projects/{id}` 의 `owner_email` 변경은 비관리자 403(같은 값은 무시). 새 owner 는 `project` 권한이 있는 등록 사용자여야 한다(아니면 400) |
| 수정/이동 권한 | 서브프로젝트·작업·섹션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 슈퍼관리자(`_require_manage`). 작업 API 는 `_require_task(write=True)` = 원 소속 프로젝트 권한(FULL) |
| 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/섹션/작업/활동/스냅샷 API 도 멤버·owner 만(`_require_manage`). 비멤버는 403. **관리자(is_admin)도 멤버가 아니면 못 본다 — 예외는 슈퍼관리자(`app.store.SUPER_ADMIN_EMAIL`) 한 명**(2026-10-07, `access.sees_all_projects`·`visible_project_ids`). 왼쪽 사이드바 프로젝트 목록·`GET /api/projects`·검색·수신함·알림·마감 알림·휴지통(목록·복구)도 같은 기준. 멤버 배정은 여전히 관리자만이라, 관리자는 자기가 멤버인 프로젝트에서만 배정할 수 있다(직원이 만든 프로젝트는 슈퍼관리자가 배정). `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 작업만 돌려준다. 연결된(멀티호밍) 작업은 연결된 프로젝트 멤버에게 **읽기 전용**(6-10) |
| 지금 권한 기준 | 모든 판단은 **지금** 권한(`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 방지) |
| 삭제 권한 | **프로젝트·섹션은 Admin 이상이면 누구 것이든, 그 밖은 "만든 사람만"**(생성자 정보 없는 과거 데이터는 Admin 이상) — `_can_delete`. **작업은 멤버 누구나**(2026-10-12). **그리고 지금 그 프로젝트 권한이 있어야 한다**(멤버에서 빠진 생성자는 403, DB·휴지통 변화 없음) |
| 멤버 배정 | Pro user 이상, 자기가 멤버인 프로젝트만(2026-10-12). User 가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) |
| 메일 알림 | `app/mail.py` (stdlib smtplib). 작업 배정/완료 시 관리자에게 발송 |
## 1-1. 프로젝트 → 섹션 → 작업 (하위 작업 포함) 3단계 구조
@@ -239,8 +239,8 @@
좌측 사이드바는 프로젝트·수신함 화면과 공용(`project/_side.html`, `side_active` 로
활성 메뉴 표시) — 수신함 · 내 작업 ·
프로젝트 트리(+ 새 프로젝트) · "전체 멤버". 프로젝트 트리는 **수신함·내 작업·휴지통·프로젝트
네 화면 모두 같다** — 관리자에게 드래그 순서 변경(⣿)·✎ 수정·× 삭제·우클릭 메뉴(공용
`initSideTree`, 모달은 `project/_side_modals.html` 을 각 화면이 include). "전체 멤버"는 **관리자(`is_admin`)에게만**
네 화면 모두 같다** — Pro user 이상에게 드래그 순서 변경(⣿)·✎ 수정·× 삭제·우클릭 메뉴(공용
`initSideTree`, 모달은 `project/_side_modals.html` 을 각 화면이 include). "전체 멤버"는 **Pro user 이상(`pj_pro`)에게만**
그리고 수신함·내 작업·프로젝트 화면 모두에서 나온다. 아이콘 클릭 = 그 사람의 담당 작업
팝업(`_member_tasks_modal.html`, `initMemberTasks`) — 프로젝트 화면에선 더블클릭 시 그 자리에서
편집 팝업, 다른 화면에선 그 작업의 프로젝트 화면(`?task=`)으로 이동.
@@ -248,9 +248,9 @@
좌측 "내 작업"는 접이식 패널이 아니라 `/project/` 로 가는 링크다.
**이 프로젝트의 멤버는 화면 위 제목 오른쪽**에 겹친 아바타로 둔다(`.pj-title-members`) —
마우스를 올리면 이름(`data-tip`, `initHoverTips` 가 위임 방식이라 동적 요소에도 붙는다),
클릭하면 그 사람이 이 프로젝트에서 맡은 작업 팝업, 우클릭(관리자)하면 제외, 옆 `+` 는 **멤버 배정·제외 창**(2026-10-07 —
클릭하면 그 사람이 이 프로젝트에서 맡은 작업 팝업, 우클릭(Pro user 이상)하면 제외, 옆 `+` 는 **멤버 배정·제외 창**(2026-10-07 —
후보 전원 + 지금 멤버는 체크된 채, 체크 = 배정 `POST …/members`, 해제 = 제외 `DELETE …/members/{email}`(확인 뒤), 소유자는 잠금.
두 API 모두 관리자 + 그 프로젝트 관리 권한(`_require_manage`)).
두 API 모두 Pro user 이상 + 그 프로젝트 관리 권한(`_require_manage`)).
좌측 트리의 작업 클릭도 페이지 이동 없이 바로 팝업(이미 로드된 전체 작업 데이터 사용).
좌측 맨 위 **수신함**(미확인 @태그 배지)과 **내 작업**(접이식, 기본 접힘 — 작업을 고르면
팝업이 열리며 다시 접힌다)가 있다. 예전 화면 오른쪽에 항상 떠 있던 "내 작업" 패널은 없앴고
@@ -284,7 +284,7 @@
`uiZoom()` 을 곱한다. 배율을 토글하면(resize) 다시 그린다. **타임라인 CSS 에 px 크기를 새로 넣을
때도 `var(--tz)` 를 곱한다.**
- **대시보드** — 합계 타일 4개 + 미완료 작업(섹션별)·작업 합계(완료 상태별) 차트. **"담당자별 작업 합계(메인·하위
작업, 완료)" 표는 관리자(`is_admin`)에게만** 보인다(사람별 업무량이 드러나서). 화면 표시만 막는 것 —
작업, 완료)" 표는 Pro user 이상에게만** 보인다(사람별 업무량이 드러나서, 세부 작업 API `subtasks-summary` 도 Pro user 이상) —
작업 데이터 자체는 멤버가 원래 볼 수 있는 범위 그대로다. (2026-10-07, 예전 "예정된 작업 합계(담당자별)" 막대 대신)
그 범위(이 프로젝트 = 여기 연결된 작업 포함 / 전체 프로젝트)에서 사람별로 배정된 작업 **전부**(마감일·필터와 무관) —
메인 작업(`scopeTasks()` 최상위, 중복 없이)과 하위 작업(화면 목록엔 없어 `GET /api/projects/{id}/subtasks-summary?scope=`
@@ -524,7 +524,7 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
모든 조회 쿼리에 "삭제됨" 필터를 넣는 소프트 삭제 대신 이 방식 — 기존 화면·쿼리를 안 건드린다.
- 첨부 실물은 지우지 않고 `DATA_DIR/project/_trash/<trash_id>/<task_id>/` 로 옮긴다(복구 시 되돌림).
- **보관 3개월**(`expires_at`). 휴지통 화면을 열거나 작업을 지울 때 만료분을 영구 삭제(`_purge_trash`).
- **관리자 전용**: 좌측 "휴지통" 메뉴·`/project/trash` 화면·`POST /project/api/trash/{id}/restore` 모두 `is_admin`.
- **Pro user 이상**(2026-10-12, 예전 관리자 전용): 좌측 "휴지통" 메뉴·`/project/trash` 화면·`POST /project/api/trash/{id}/restore` 모두 `access.is_pro`.
복구는 원래 id 그대로(`restore_trash`): 같은 id 가 이미 있으면 거부, 프로젝트가 지워졌으면 거부, 하위 작업만
지웠는데 상위가 없으면 거부(상위 먼저 복구). 지워진 섹션은 섹션 없이, 지워진 프로젝트를 가리키는 연결/이력은 뺀다.
복구하면 휴지통 행은 지운다.
@@ -595,11 +595,11 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
화면에서 계산(저장 안 함). 매출 단위 글자는 `goal_years.sales_unit`.
- **업무 영역** `goal_areas`(연도별, 이름·색 `store.GOAL_AREA_COLORS` 연한 16색 + 색 없음(빈 값 = 흰 배경)·순서) → `goal_rows`(영역 안 줄, 최소 1줄 — 마지막 줄은
못 지움) → `goal_cells`(row × month, **0 = 연간**, 빈 글 = 행 삭제). 영역 색이 줄 전체 배경.
- 권한: 조회는 `project` 권한자 전원, **입력·구조 변경은 관리자만**(`_require_admin`, 화면도 관리자에게만 입력칸·도구).
- 권한: 조회는 `project` 권한자 전원, **입력·구조 변경은 Pro user 이상**(`_require_pro`, 화면도 `pj_pro` 에게만 입력칸·도구 — 6-14).
- 연도 추가(`POST /api/goals/years {year}`)는 가장 가까운 이전 연도(없으면 다음 연도)의 영역·줄 구조를 글 없이 복사,
목표가 하나도 없으면 `store.DEFAULT_GOAL_AREAS`(상품·마케팅·컨텐츠·유통[콜라보·인플·쿠팡·기타]). 없는 연도 화면은
관리자에게 "목표 만들기" 버튼(GET 에서 자동 생성하지 않는다). 연도 삭제는 연도를 직접 입력해야 진행(CASCADE 전부 삭제).
- API(전부 관리자): `PUT /api/goals/{y}` `{sales_unit}` · `DELETE /api/goals/{y}` · `PUT /api/goals/{y}/metrics`
- API(전부 Pro user 이상): `PUT /api/goals/{y}` `{sales_unit}` · `DELETE /api/goals/{y}` · `PUT /api/goals/{y}/metrics`
`{metric,kind,month,value}`(빈값 = 지움, 응답 `label` 은 쉼표 표기) · `POST /api/goals/{y}/areas` `{name,color}` ·
`PUT|DELETE /api/goals/areas/{id}` · `POST /api/goals/areas/{id}/move` `{direction:-1|1}` · `POST /api/goals/areas/{id}/rows` `{label, ref_row_id?, place?: above|below}`(기준 줄 위/아래, 없으면 맨 끝) ·
`PUT|DELETE /api/goals/rows/{id}` · `POST /api/goals/rows/{id}/move` · `PUT /api/goals/rows/{id}/cells/{month}` `{body}`.
@@ -902,9 +902,9 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
(`GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN` 없으면 시트 토큰 — Drive·Slides 권한으로 재발급 필요, docs/DEPLOYMENT.md). DB 변경 없음.
- **회의록 누구나 수정 · 회의 완료 잠금**(마이그레이션 022, 2026-10-07): 회의록 만들기·머리 칸·줄 추가/삭제/이동·셀 이동/병합·줄 칸 API 가
`_require_admin` → `_require_user`(프로젝트 권한자 누구나). 회의록 삭제와 `POST /api/goals/meetings/{주차}/complete {done}`(회의 완료·완료 해제)만
관리자. `goal_meetings.completed_at`·`completed_by` 가 있으면 잠금 — `db._check_meeting_open`(머리 칸·줄 추가·`_locked_meeting_items`)이
Pro user 이상(2026-10-12, 예전 관리자). `goal_meetings.completed_at`·`completed_by` 가 있으면 잠금 — `db._check_meeting_open`(머리 칸·줄 추가·`_locked_meeting_items`)이
`store.MeetingLocked` → 409. 예외: 줄 칸 변경이 결과(`result_note`·`result_amount`·`status`)뿐이면 그 줄의 회의록이 아니라 **바로 다음 주차
회의록**(그 결과를 적는 회의)의 잠금을 본다. 화면은 `data-edit`(완료 전이면 누구나) 로 편집 도구를 켜고, 관리자에게 [회의 완료]/[완료 해제],
회의록**(그 결과를 적는 회의)의 잠금을 본다. 화면은 `data-edit`(완료 전이면 누구나) 로 편집 도구를 켜고, Pro user 이상에게 [회의 완료]/[완료 해제],
완료면 "🔒 회의 완료" 표시. 022 전이면 완료 버튼 없음(`meeting.can_complete`).
- **알림 팝업**(2026-10-07): 나를 태그(mention)하거나 작업을 배정(assigned)받으면 프로젝트 화면 가운데 아래에 깜박이는 큰 팝업(`initTaskAlerts`,
`.pj-alert-pop`, body 에 붙음) — [닫기] 전까지 남는다. 20초마다(창을 다시 볼 때 바로) `GET /api/notifications/alerts?after=본 것`(읽지 않은
@@ -1011,7 +1011,7 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
`client_token`) 한 요청으로, 댓글+첨부를 한 트랜잭션(`add_comment_with_attachments`)에 만든다. 빈 파일·20MB 초과가 하나라도
있으면 아무것도 만들지 않고 400 `detail.failed=[{index,name,reason}]` → 화면은 그 파일만 빨갛게 표시하고 입력·파일을 유지.
DB 실패면 방금 쓴 파일도 지운다. 글 댓글(`POST /comments`)은 본문 필수 — 예전 `has_attachment` 플래그는 받지 않는다.
`client_token` 으로 같은 댓글의 재전송(응답 유실·연타·동시 요청)은 10분간 첫 결과를 돌려준다(웹 프로세스 메모리, 단일 워커 기준).
`client_token` 으로 같은 댓글의 재전송(응답 유실·연타·동시 요청)은 10분간 첫 결과를 돌려준다(웹 프로세스 메모리 — 보장 범위는 6-15).
작업 창 댓글 목록도 댓글별 첨부(이미지 미리보기·파일명 다운로드, 이스케이프)를 보여 주고, 첨부 파일 목록엔 "댓글" 표시.
**마감 알림** — `add_reminder_notification`: 발송 기록(`task_reminders`)과 수신함 알림을 한 트랜잭션에. 알림 생성이 실패하면
@@ -1076,9 +1076,9 @@ Windows 트레이 프로그램 **DBX 알림**(`desktop/notifier/`, C# .NET Frame
`.material-symbols-outlined.pj-ic-asana`. 목록을 늘리면 글꼴도 그 이름들로 다시 받는다. 그리는 곳: `projIconSpan`(JS)·
`_side.html`·`project.html` 제목 알약.
- **섹션 이름 굵게**(보드 `.pj-col-name`, 목록 묶음 `.pj-list-group-name`, 이름 바꾸기 칸).
- **전체 보기**: 프로젝트 화면 오른쪽 위 범위 토글(`#pj-scope-toggle`)은 숨기고, 왼쪽 메뉴 수신함 아래 **전체 보기**(관리자만,
- **전체 보기**: 프로젝트 화면 오른쪽 위 범위 토글(`#pj-scope-toggle`)은 숨기고, 왼쪽 메뉴 수신함 아래 **전체 보기**(Pro user 이상,
`#pj-side-allview`) — 지금 프로젝트(없으면 목록 첫 활성 프로젝트) `/project/p/{id}?scope=all`. 프로젝트 화면에서는 새로고침 없이
`applyAllScope(true)`. `?scope=all` 은 `data-is-admin` 일 때만 따른다. 이 프로젝트로 돌아가기 = 왼쪽 목록에서 프로젝트.
`applyAllScope(true)`. `?scope=all` 은 `data-is-pro` 일 때만 따른다. 이 프로젝트로 돌아가기 = 왼쪽 목록에서 프로젝트.
- **수신함 작업 창**: [확인]으로 연 오른쪽 작업 창은 왼쪽 수신함 영역(`.pj-inbox-view`)을 누르면 닫힌다(메뉴·모달·알림 팝업 제외).
- **설명란 글자 색·크기**: 서식 도구 [글자 색](10색, 기본)·[글자 크기](작게 12px·보통·크게 18px·더 크게 22px·제목 28px).
`execCommand` 가 만든 `<font>` 를 바로 `<span style>` 로 바꾸고, 서버 `sanitize_description_html` 은 평범한 span 의 style 에서
@@ -1097,7 +1097,104 @@ Windows 트레이 프로그램 **DBX 알림**(`desktop/notifier/`, C# .NET Frame
- **회의록 보드 링크 복사**: [회의록 보드] 오른쪽 🔗(`#pj-meet-board-copy`) — 같은 `POST …/board`(없으면 만든다)로 주소를 받아
클립보드에(실패하면 주소 창). 한 번 받은 주소는 그 화면에서 다시 쓴다.
## 6-14. 관리자 등급 4단계 — 수퍼관리자 · Admin · Pro user · User (2026-10-12, 마이그레이션 없음)
- **등급**: 사용자 레코드 `role` 이 `admin` / `pro` / `user`(`app.store.ROLES`, 관리자 페이지 등급 선택 — 표시 Admin · Pro user · User).
수퍼관리자는 role 이 아니라 `SUPER_ADMIN_EMAIL` 한 명(고정, 등급 변경·삭제·추가 불가). `pro` 는 **프로젝트 모듈에서만** 권한이
늘고, 그 밖(관리자 페이지·다른 모듈·`is_admin`)에서는 `user` 와 같다. 모듈 칩 기본값도 user 처럼 전부 꺼짐.
- **판단 함수**(`access.py`): `role_of` · `is_pro`(수퍼관리자·Admin·Pro user) · `is_project_admin`(수퍼관리자·Admin).
라우터 `_require_pro`(예전 `_require_admin` 자리 전부), 화면 값 `_role_ctx(user)` → `is_admin`(ERP 상단 관리자 메뉴용, 그대로) ·
`pj_pro` · `pj_admin`. 템플릿의 프로젝트 기능 버튼은 `pj_pro`, 마크업은 `data-is-pro`·`data-is-padmin`(사이드바·프로젝트·내 작업),
목표 표·회의록은 `data-pro`.
- **프로젝트 보기는 여전히 멤버·owner 만**(관리자도 마찬가지, 수퍼관리자만 전체 — 6-10). 아래 Pro user 권한도 멤버인 프로젝트 안에서만.
| 프로젝트 | Admin | Pro user | User | 서버 |
| --- | --- | --- | --- | --- |
| 프로젝트 보기, 작업·섹션 만들기·고치기·옮기기 | O | O | O | `_require_manage` |
| 작업 삭제(휴지통) | O | O | O | 멤버면 누구나 — 생성자 검사 없앰 |
| 섹션 삭제 | O | 만든 사람만 | 만든 사람만 | `_can_delete` (기록 없는 옛 섹션 = Admin 이상) |
| 서브프로젝트 만들기 | O | O | O | `_require_manage` |
| 새 프로젝트 만들기 | O | O | X | `POST /api/projects` → `_require_pro` |
| 프로젝트 이름·색·아이콘·날짜·완료 수정, 소유자 바꾸기 | O | O | X | `PUT /api/projects/{id}` → `_require_pro` + 멤버 |
| 프로젝트 삭제 | O | 만든 사람만 | 만든 사람만 | `_can_delete` + 멤버 |
| 멤버 배정·제외(+ 배정 후보 목록) | O | O(멤버인 프로젝트) | X | `_require_pro` + `_require_manage` |
| 사이드바 프로젝트 순서 | O | O | X | `PUT /api/projects/order` |
| 댓글 수정·삭제 / 댓글에 파일 붙이기 | O | 남의 것도 | 본인만 | `update_comment`·`delete_comment(is_admin=is_pro)` |
| 휴지통 보기·복구 | O | O | X | `/trash`·`/api/trash/{id}/restore` |
| 전체 보기 | O | O(멤버 범위) | X | 화면 `isPro` (`?scope=all` 도 isPro 일 때만) |
| 대시보드 담당자별 작업 합계 | O | O | X(안 보임) | `GET …/subtasks-summary` → `_require_pro` |
| 사이드바 전체 멤버 | O | O | X | 화면 `pj_pro` |
| 수신함·내 작업·PC 알림 | O | O | O(자기 것) | 변화 없음 |
| 목표·주간 회의록 | Admin | Pro user | User |
| --- | --- | --- | --- |
| 연간 목표 표 보기 | O | O | O |
| 목표 표 입력·구조 변경(매출·로아스, 영역·줄, 칸 병합·이동), 주차별·월 매출 목표, 연도 추가·삭제 | O | O | X |
| 회의록 만들기·글 수정·줄 추가·삭제·칸 병합(완료 전까지), 지난주 결과(다음 주 회의록이 열려 있는 동안) | O | O | O |
| 회의 완료·완료 해제, 회의록 삭제 | O | O | X |
| 회의록 보드 열기·링크 복사 | O | O | O |
| 회의록 작업 등록 표로 작업 만들기 | 멤버인 프로젝트만 | 멤버인 프로젝트만 | 멤버인 프로젝트만 |
- 회의록 표 첫 열 머리 글자 "구역" → **"구분"**(화면 글자만, 데이터·코드의 section 이름은 그대로).
- 테스트: `tests/test_project_roles.py`(DB 없이 등급별 API), `tests/test_project_module.py` 의 소유자·삭제 테스트를 새 규칙으로.
## 6-15. 검토 반영 — 권한·열기 경로·저장·동시성 (2026-10-12, 마이그레이션 없음)
권한 정책(6-14 표)은 그대로 두고, 그 정책이 새던 곳을 막았다. 테스트 `tests/test_project_review_fixes.py`(DB 없이),
`tests/test_project_meeting_lock.py`·`test_project_alerts_api.py`, `tests/js/project_ui.test.js` 의 [검토 *] 항목.
- **서브프로젝트 작업**: `GET /api/projects/{id}/tasks`(하위 프로젝트까지 재귀)는 작업마다 지금 권한으로 다시 거른다
(`access.filter_visible_tasks`) — 부모 멤버라고 멤버가 아닌 자식 프로젝트 작업이 보이지 않는다. 연결된 작업의 READ 는 그대로.
(이 API·`POST /subprojects` 는 지금 화면에서 부르지 않는다 — 외부 호출 호환 때문에 남겨 둠.)
- **사이드바 순서** `PUT /api/projects/order`: Pro user 이상 + 보낸 id **전부** 지금 관리할 수 있는 프로젝트여야(없는 id 도 같은 403,
하나라도 아니면 아무것도 안 바뀜). 빈 목록·정수 아님(참/거짓·소수·글자)·0 이하·중복 = 400. 순서는 예전처럼 모두가 같이 보는 순서.
- **작업 열기 경로 하나로**: 수신함 줄·웹 큰 팝업·PC 알림 [열기] = `/project/t/{task_id}`(공유 링크). 서버(`_task_open_project`)가
지금 권한으로 열 프로젝트를 고른다 — FULL 이면 원 소속, READ 면 내가 볼 수 있는 연결된 프로젝트. `?embed=1` 은 옮긴 주소에도
붙는다(수신함 iframe). 알림 응답에 `href` 가 붙는다. 예전 주소 `/p/{원 소속}?task=` 로 READ 사용자가 오면 403 대신 연결된
프로젝트로 보낸다(옛 PC 알림 프로그램·북마크). 작업 없는 프로젝트 알림은 예전처럼 `/p/{id}`.
- **보관·서브프로젝트 화면**: `project_page`·스냅샷(scope=all)·담당자별 합계(scope=all)는 같은 범위(`_view_scope`) — 활성 최상위
멤버 프로젝트 + **지금 연 프로젝트 하나**(보관됐거나 서브프로젝트여서 목록에 없을 때만). 다른 보관 프로젝트는 읽지 않는다. 그
프로젝트 메타는 `view_only: true` 로 와서 사이드바 목록엔 그리지 않는다(작업 권한 판단·타임라인 그룹용).
- **전체 보기**: 작업마다 한 행 — 원 소속 행이 있으면 그것, 원 소속을 볼 수 없어 연결된 프로젝트 행(READ)만 있으면 그중 첫 행
(`scopeTasks`). 예전엔 원 소속 행만 남겨 이런 작업이 빠졌다. 사용자별 작업 팝업(`/api/users/tasks`, 전체 대상)도 같은 기준(READ 포함).
- **큰 팝업 알림**(`_alerts_payload`, 웹·PC 공용): 수신자·읽지 않음·종류(태그·배정)·`id > after` 를 DB 에서 먼저 걸고
(`list_unread_after`) **오래된 것부터** 200건씩 넘기며 지금 볼 수 있는 것 10건을 모은다(한 번에 최대 25쪽 = 5,000행).
예전엔 최신 50건을 자른 뒤 걸러 — 배정 뒤 댓글 알림 50건, 배정 60건 이상, 볼 수 없는 알림이 앞을 채우면 팝업이 빠졌다.
기준점(`latest_id`)·처음 연결 때 옛 알림 안 띄움·PC 프로그램이 돌면 웹 팝업 쉼은 그대로.
- **수신함 오른쪽 작업 창**: 다른 줄로 바꾸거나 닫기(Esc·바깥 클릭·모두 확인·프로젝트 알림 이동) 전에 iframe 안 작업 창의
`window.__pjEmbedSettle()` 을 기다린다 — 작업 창 닫기와 같은 절차(업로드·만들기·저장 대기 → 실패 칸 재시도 → "버리고 넘어가기 /
계속 편집"). 계속 편집이면 창·입력·선택 그대로, 새 줄은 확인하지 않는다. 바꾸기는 한 번에 하나, 마지막 요청만(A→B→A·저장 중
Esc 연타). beforeunload 경고에 기대지 않는다. 읽음/확인은 **서버가 받았을 때만** 확인으로 두고(실패면 굵게 남기고 알림), 확인된
줄만 목록에서 뺀다. `POST /api/mentions/read` 는 006 미적용(표 없음)만 0건 성공, 그 밖의 DB 오류는 실패로 돌려준다.
- **일반 첨부**(`POST /api/tasks/{id}/attachments`): DB 저장이 실패하면 이 요청이 쓴 파일(새 uuid 이름)만 지운다. 크기·빈 파일·
권한·inline 정책은 그대로.
- **새 프로젝트 창**: ① 생성(한 번만) ② 멤버 배정(사람마다)을 나눠 안내 — 배정 실패면 창을 닫지 않고 실패한 멤버를 빨갛게,
[실패한 멤버 다시 배정]은 그 멤버만(프로젝트를 또 만들지 않음). 진행 중 연타 무시, 진행 중 닫아도 요청은 끝까지 가고 결과는 알림.
만든 프로젝트를 되돌리려고 지우지 않는다.
- **배지 개수**: 내 작업(`list_my_open_refs`)·수신함 태그(`list_unread_mention_refs`)·읽지 않은 알림(`list_unread_refs`)은 가벼운 열만
제한 없이 읽어 지금 권한으로 센다(예전 1000·1000·500건 상한). 내 작업 목록은 **미완료 전부** + 최근 완료 1000건
(`list_my_tasks(completed_limit=)`) — 오래된 완료가 새 미완료를 밀어내지 않는다.
- **동시성**: `update_task` 는 기존 값 읽기·섹션 확인·기본 담당자·완료 섹션 여부·최종 날짜 검사·변경·이력을 한 트랜잭션에서 그
작업 행을 잠그고(`FOR UPDATE`) 같은 연결로 한다 — 시작일·마감일을 동시에 바꿔도 역전되지 않고, 동시 완료의 완료 이력·알림은 실제로
바뀐 한 요청에서만. `update_project` 날짜 검사도 행 잠금 뒤. (한 창 저장 직렬화와 별개 — 여러 사람 사이의 충돌 방지.)
- **회의록**: 머리(메모·참석자·금주 목표) 수정은 그 회의록 행을 잠그고 완료 여부를 본다([회의 완료]도 같은 행을 잠근다). 결과 칸만
고칠 때(`_check_result_open`): 다음 주차 회의록이 **있으면** 그 회의록이 열려 있을 때만, **없으면** 그 주 회의록이 열려 있을 때만
(예전엔 다음 회의록이 없으면 완료된 주의 결과도 고칠 수 있었다). 다음 주차 = `week_period` 끝 + 1일(달이 바뀌어도, 월요일이 아닌
시작일도). 다음 회의록 행은 `FOR SHARE` — 잠금 순서는 늘 주차 오름차순(교착 없음).
- **소유자를 남으로 정해 만들기**: 만든 사람을 같은 트랜잭션에서 **일반 멤버 행**으로 넣는다(`create_project(member_emails=)`) —
`created_by` 로 권한을 주지 않으니 나중에 멤버에서 빼면 권한도 없어진다. 소유자 변경 뒤 옛 소유자 권한 회수도 그대로.
- **중복 방지 키**(`_once`, 댓글 `client_token`): 키별 잠금을 쓰는 요청 수로 관리해 0 이 되면 바로 뺀다(실패한 키도) — 결과를 먼저
저장한 뒤 잠금을 풀어 기다리던 요청은 결과로 답한다. 실패하면 다음 요청이 새로 만든다(재시도). **보장 범위: 웹 프로세스 하나**
— 지금 운영은 web 컨테이너 1개·uvicorn 워커 1개(Dockerfile). 워커·컨테이너를 늘리면 다른 워커로 간 재전송은 막지 못하고 재시작하면
기록도 사라진다(그때는 DB UNIQUE 키가 필요).
- **섹션 기본 담당자**: 자동 배정 전에 그 사람이 지금 등록된 project 권한 사용자인지도 본다(`_registered_project_user`, 사용자 목록만 —
잠근 트랜잭션 안에서 DB 연결을 더 빌리지 않음). 기본 담당자 지정도 같은 기준. 협업자 추가는 담당자 후보와 같은 `access.can_assign`
(예전엔 관리자는 멤버가 아니어도 넣을 수 있었다).
정책 결정이 필요한 것(바꾸지 않음): 배정·완료 **메일**은 `PROJECT_NOTIFY_EMAIL`(없으면 Admin 전원)에게 프로젝트·작업 제목·담당자가
간다 — 화면에선 비멤버 Admin 이 그 프로젝트를 못 보지만 메일로는 제목을 받는다(4장 관리자 보고 정책).
## 7. 추후 단계
작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성 · 하위 작업의 하위 작업(다단계 중첩,
아사나도 UI상 1단계만 허용해 현재 의도적으로 안 함).
작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성.
(세부 작업의 세부 작업은 2026-10-08 부터 지원 — 6-13 담당자별 합계 참고.)
+4
View File
@@ -39,6 +39,10 @@
`admin` 역할은 모든 권한 자동 부여. 신규 사용자는 관리자 페이지(`/admin`)에서 이메일만으로 등록 가능.
관리자 등급(2026-10-12): **수퍼관리자**(`SUPER_ADMIN_EMAIL` 한 명 고정 — 변경·삭제·추가 불가) > **Admin**(`role=admin`) >
**Pro user**(`role=pro`) > **User**(`role=user`). Pro user 는 Project 모듈(프로젝트·목표·주간 회의록)에서만 권한이 늘고
(`app/modules/project/access.py`, 표는 `docs/PROJECT_MODULE.md` 6-14), 다른 모듈·관리자 페이지에서는 User 와 같다.
---
## 모듈 디렉토리 규약
+13
View File
@@ -60,3 +60,16 @@ python -m unittest discover -s tests -p test_project_meeting_cells.py
`PROJECT_TEST_DB_URL`에 기존 로컬 테스트 DB를 지정해야 하며, 미설정 또는 로컬 주소가 아니면 건너뛴다.
회의록 셀 테스트는 DB 연결을 대신하는 트랜잭션 모형으로 실제 저장소 메서드·API 권한/충돌·이동/병합 롤백·
019 미적용·병합 행 작업 보호·서식 보존·안전한 템플릿 출력을 검증한다. 실제 PostgreSQL 잠금 동작 검증은 별도다.
# 프로젝트 화면·수신함 UI 테스트 (jsdom + 실제 Chrome)
`project.html`·`inbox.html` + `static/project.js` — 작업 창 저장/실패/동기화, 전체 보기의 연결된(읽기 전용) 작업,
수신함 오른쪽 작업 창(저장 대기 뒤 바꾸기·계속 편집·A→B→A·저장 중 Esc·읽음 실패), 새 프로젝트 창(생성/멤버 배정 결과 분리·
실패한 멤버만 다시 배정·연타)을 가짜 서버로 검증한다.
```powershell
python tests/js/render_project.py # → tests/js/.out/project_*.html · inbox_render.html
node tests/js/project_ui.test.js # jsdom
$env:PJ_TEST_BROWSER = 'C:/Program Files/Google/Chrome/Application/chrome.exe'
node tests/js/inbox_panel.browser.test.js # Playwright: iframe 리다이렉트 뒤 embed·저장 실패 확인창·A→B→A·iframe 안 Esc·읽음 실패
```
+134
View File
@@ -0,0 +1,134 @@
// 실제 브라우저 — 수신함 오른쪽 작업 창(iframe)이 다른 줄로 바뀌거나 닫히기 전에 작업 창의 저장을 기다리는지,
// 저장 실패면 작업 창과 같은 "버리고 넘어가기 / 계속 편집"을 묻는지, 공유 링크 리다이렉트 뒤에도 embed 인지,
// iframe 안 Esc·빠른 A→B→A·읽음 실패를 확인한다. 서버는 가짜(이 파일의 http 서버), 화면은 실제 템플릿 렌더 결과.
// python tests/js/render_project.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/inbox_panel.browser.test.js
const assert = require("node:assert/strict");
const fs = require("node:fs"), path = require("node:path"), http = require("node:http");
const { chromium } = require("playwright");
const ROOT = path.resolve(__dirname, "../.."), OUT = path.join(__dirname, ".out"), STATIC = path.join(ROOT, "app/static");
const detail = (id, title) => ({ id, title, project_id: 1, stage_id: 11, description: "", priority: "normal",
assignee_email: "", subtasks: [], links: [], followers: [], access: "full", completed_at: null });
let putStatus = 200, holdPut = false, releasePut = null, failNotiRead = false;
const puts = [], reads = [];
const server = http.createServer(async (req, res) => {
const url = new URL(req.url, "http://localhost");
const json = (code, body) => { res.statusCode = code; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(body)); };
if (url.pathname === "/project/inbox") { res.setHeader("Content-Type", "text/html; charset=utf-8"); res.end(fs.readFileSync(path.join(OUT, "inbox_render.html"))); return; }
const tm = /^\/project\/t\/(\d+)$/.exec(url.pathname);
if (tm) { // 공유 링크 — 서버(router.task_permalink)처럼 embed 를 이어서 보낸다
res.statusCode = 303;
res.setHeader("Location", `/project/p/1?task=${tm[1]}${url.searchParams.get("embed") === "1" ? "&embed=1" : ""}`);
res.end(); return;
}
if (url.pathname === "/project/p/1") { res.setHeader("Content-Type", "text/html; charset=utf-8"); res.end(fs.readFileSync(path.join(OUT, "project_render.html"))); return; }
if (url.pathname.startsWith("/project/api/")) {
let raw = ""; for await (const c of req) raw += c;
const body = raw ? JSON.parse(raw) : null;
const task = /^\/project\/api\/tasks\/(\d+)$/.exec(url.pathname);
if (task && req.method === "GET") return json(200, { task: detail(+task[1], "작업 " + task[1]) });
if (task && req.method === "PUT") {
puts.push({ id: +task[1], body });
if (holdPut) await new Promise(r => { releasePut = r; });
return putStatus >= 400 ? json(putStatus, { detail: "서버 오류" }) : json(200, { task: Object.assign(detail(+task[1], "작업"), body) });
}
if (url.pathname === "/project/api/mentions/read") { reads.push("m" + (body && body.task_id)); return json(200, { ok: true, marked: 1 }); }
const nr = /^\/project\/api\/notifications\/(\d+)\/read$/.exec(url.pathname);
if (nr) { reads.push("n" + nr[1]); return failNotiRead ? json(500, { detail: "db" }) : json(200, { ok: true }); }
if (url.pathname.endsWith("/comments")) return json(200, { comments: [], events: [], features: {} });
if (url.pathname.endsWith("/attachments")) return json(200, { attachments: [] });
if (url.pathname.endsWith("/members")) return json(200, { members: [{ user_email: "me@test.local" }] });
if (url.pathname.endsWith("/live-version")) return json(200, { ts: "v1" });
if (url.pathname.endsWith("/alerts")) return json(200, { me: "me@test.local", latest_id: 0, alerts: [] });
return json(200, {});
}
if (url.pathname.startsWith("/static/")) {
const file = path.join(STATIC, decodeURIComponent(url.pathname.slice("/static/".length)));
if (file.startsWith(STATIC) && fs.existsSync(file)) {
res.setHeader("Content-Type", file.endsWith(".js") ? "text/javascript" : file.endsWith(".css") ? "text/css" : "application/octet-stream");
res.end(fs.readFileSync(file)); return;
}
}
res.statusCode = 404; res.end("");
});
(async function () {
await new Promise(r => server.listen(0, "127.0.0.1", r));
const base = "http://127.0.0.1:" + server.address().port;
const browser = await chromium.launch(process.env.PJ_TEST_BROWSER ? { executablePath: process.env.PJ_TEST_BROWSER } : {});
const page = await browser.newPage({ viewport: { width: 1920, height: 1080 } }); // 작업 창이 왼쪽 목록을 가리지 않는 보통 PC 화면
const dialogs = [];
let dialogAnswer = false;
page.on("dialog", async d => { dialogs.push(d.type() + ":" + d.message().slice(0, 20)); if (dialogAnswer) await d.accept(); else await d.dismiss(); });
const pass = [];
const ok = (name, cond, extra) => { assert.ok(cond, name + (extra === undefined ? "" : " → " + JSON.stringify(extra))); pass.push(name); console.log("PASS " + name); };
try {
await page.goto(base + "/project/inbox");
const frameOf = () => page.frames().find(f => f !== page.mainFrame());
const frameUrl = () => (frameOf() ? frameOf().url() : "");
const waitModal = async () => {
await page.waitForFunction(() => { const f = document.querySelector(".pj-inbox-panel iframe"); const d = f && f.contentDocument;
const m = d && d.getElementById("pj-modal-task"); return !!(m && !m.hidden && d.getElementById("pj-t-id").value); });
};
await page.click('#pj-mention-tasks .pj-inbox-item[data-task-id="101"]');
await waitModal();
ok("공유 링크 리다이렉트 뒤에도 embed 화면(작업 창만)", /\/project\/p\/1\?/.test(frameUrl()) && /embed=1/.test(frameUrl()) &&
await frameOf().evaluate(() => document.documentElement.classList.contains("pj-embed")), frameUrl());
ok("같은 작업의 태그·알림을 함께 확인", reads.includes("m101") && reads.includes("n901"), reads);
// ① 저장 실패 → 다른 줄 → 묻기 → 계속 편집: 창·입력 그대로
putStatus = 500;
const fr = frameOf();
await fr.fill("#pj-t-title", "작업 101 고침");
await fr.evaluate(() => document.getElementById("pj-t-title").blur());
await page.waitForTimeout(150);
dialogAnswer = false;
await page.click('#pj-mention-tasks .pj-inbox-item[data-task-id="102"]');
await page.waitForTimeout(400);
ok("저장 실패면 바꾸기 전에 묻고(작업 창과 같은 확인), 계속 편집이면 그대로", dialogs.length === 1 && /\?task=|\/p\/1/.test(frameUrl()) &&
await fr.evaluate(() => document.getElementById("pj-t-title").value) === "작업 101 고침" &&
!reads.includes("m102"), { dialogs, url: frameUrl(), reads });
// ② 저장 대기 중 A→B→A — 확인 뒤 A 그대로, 새 줄 안 열림
putStatus = 200; holdPut = true;
await page.click('#pj-mention-tasks .pj-inbox-item[data-task-id="102"]');
await page.waitForTimeout(150);
await page.click('#pj-mention-tasks .pj-inbox-item[data-task-id="101"]');
await page.waitForTimeout(100);
ok("저장이 끝나기 전엔 창을 바꾸지 않는다", frameOf() === fr && releasePut !== null);
holdPut = false; releasePut(); releasePut = null;
await page.waitForTimeout(500);
ok("A→B→A 빨리 — 저장 성공 뒤 A 작업 창 그대로(다시 읽지 않음)", frameOf() === fr &&
await fr.evaluate(() => document.getElementById("pj-t-id").value) === "101" && puts[puts.length - 1].body.title === "작업 101 고침" &&
!reads.includes("m102"), { puts: puts.length, reads });
// ③ 저장 성공 상태에서 B → 바로 바뀌고 이탈 경고 없음
const before = dialogs.length;
await page.click('#pj-mention-tasks .pj-inbox-item[data-task-id="102"]');
await waitModal();
await page.waitForFunction(() => document.querySelector(".pj-inbox-panel iframe").contentDocument.getElementById("pj-t-id").value === "102");
ok("저장된 상태면 묻지 않고 B 로(beforeunload 경고도 없음)", dialogs.length === before && reads.includes("m102"), dialogs);
// ④ iframe 안 포커스에서 Esc — 작업 창이 닫히며 패널도 닫힘, 확인한 줄은 목록에서 빠짐
const fr2 = frameOf();
await fr2.focus("#pj-t-title");
await page.keyboard.press("Escape");
await page.waitForFunction(() => !document.querySelector(".pj-inbox-panel").classList.contains("is-open"));
await page.waitForTimeout(400);
ok("iframe 안에서 Esc → 패널 닫힘, 확인한 태그 줄은 빠짐", await page.evaluate(() =>
!document.querySelector('#pj-mention-tasks .pj-inbox-item[data-task-id="102"]')));
// ⑤ 읽음 실패한 알림 줄은 남는다
failNotiRead = true;
await page.click('#pj-inbox .pj-inbox-item[data-id="903"]', { button: "right" });
await page.click(".pj-ctxmenu button, .pj-ctxmenu [role=menuitem], .pj-ctxmenu li");
await page.waitForTimeout(400);
ok("읽음 처리 실패 — 줄이 남고 굵게(읽지 않음)", await page.evaluate(() => {
const li = document.querySelector('#pj-inbox .pj-inbox-item[data-id="903"]'); return !!li && li.classList.contains("is-unread"); }));
console.log("\nALL PASS (" + pass.length + ")");
} finally {
await browser.close();
server.close();
}
})().catch(e => { console.error(e); process.exit(1); });
+120 -1
View File
@@ -16,6 +16,7 @@ const WATCHDOG = setTimeout(function () { console.log("TIMEOUT — 어딘가에
const ROOT = path.join(__dirname, "..", "..");
const html = fs.readFileSync(path.join(__dirname, ".out", "project_render.html"), "utf8");
const adminHtml = fs.readFileSync(path.join(__dirname, ".out", "project_admin_render.html"), "utf8");
const inboxHtml = fs.readFileSync(path.join(__dirname, ".out", "inbox_render.html"), "utf8");
const JS = fs.readFileSync(path.join(ROOT, "app", "static", "project.js"), "utf8");
const fails = [];
@@ -688,7 +689,7 @@ function titleVal(d) { return d.getElementById("pj-t-title").value; }
// ── 대시보드 담당자별 작업 합계 — 사람마다 메인·하위 세로 막대(완료/전체), 막대 → 오른쪽 업무 목록, 항목 → 편집 창 ──
{
const env = makeEnv(); baseRoutes(env);
env.d.querySelector(".pj-project-view").dataset.isAdmin = "true";
env.d.querySelector(".pj-project-view").dataset.isPro = "true";
let asked = null;
env.route("GET", /\/project\/api\/projects\/1\/subtasks-summary\?scope=project$/, function (u) {
asked = u;
@@ -779,6 +780,124 @@ function titleVal(d) { return d.getElementById("pj-t-title").value; }
const shown = Array.from(d.querySelectorAll(".pj-tmember")).map(function (n) { return n.dataset.email; });
check("[멤버 배정·제외] 머리 멤버 아이콘 갱신", shown.indexOf("bob@test.local") < 0 && shown.indexOf("carol@test.local") >= 0, shown);
}
// ── [검토 A] 전체 보기 — 원 소속을 볼 수 없는 연결된 작업(301, 읽기 전용)도 한 번 나온다 ──
{
const env = makeEnv(adminHtml); baseRoutes(env);
await boot(env);
const d = env.d;
d.getElementById("pj-side-allview").click(); await settle();
const cards = function (id) { return d.querySelectorAll('.pj-card[data-task-id="' + id + '"]').length; };
check("[전체 보기] 연결된 작업(원 소속 못 봄)도 한 장, 원 소속 작업은 그대로 한 장", cards(301) === 1 && cards(101) === 1 && cards(103) === 1,
[cards(301), cards(101), cards(103)]);
}
// ── [검토 7] 수신함 iframe 안쪽 — __pjEmbedSettle 이 작업 창 닫기와 같은 저장 절차를 탄다 ──
{
const env = makeEnv(); baseRoutes(env);
env.d.documentElement.classList.add("pj-embed");
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 = "작업 A3"; ta.dispatchEvent(new env.w.Event("blur")); await settle();
env.setConfirm(false); // 계속 편집
const ok1 = await env.w.__pjEmbedSettle(); await settle();
check("[수신함 iframe] 저장 실패 → 다시 시도 후 묻고, 계속 편집이면 false·입력 유지",
ok1 === false && !modal.hidden && titleVal(d) === "작업 A3" && env.confirms === 1 && puts.length >= 2, [ok1, env.confirms, puts.length]);
putStatus = 200;
const ok2 = await env.w.__pjEmbedSettle(); await settle();
check("[수신함 iframe] 다시 — 재시도 성공이면 true(묻지 않음)", ok2 === true && env.confirms === 1 && puts[puts.length - 1].title === "작업 A3",
[ok2, env.confirms]);
}
// ── [검토 7] 수신함 작업 창 — 바꾸기·닫기 전 저장 대기, 계속 편집이면 그대로, A→B→A, 저장 중 Esc, 읽음 실패 ──
{
const env = makeEnv(inboxHtml); baseRoutes(env);
const reads = [];
env.route("POST", /\/project\/api\/mentions\/read$/, function (u, b) { reads.push("m" + (b && b.task_id)); return { body: { ok: true, marked: 1 } }; });
let failNoti = true;
env.route("POST", /\/project\/api\/notifications\/\d+\/read$/, function (u) {
reads.push("n" + u.split("/")[4]);
return failNoti ? { status: 500, body: { detail: "db" } } : { body: { ok: true } };
});
await boot(env);
const d = env.d;
const A = d.querySelector('#pj-mention-tasks .pj-inbox-item[data-task-id="101"]');
const B = d.querySelector('#pj-mention-tasks .pj-inbox-item[data-task-id="102"]');
const N901 = d.querySelector('#pj-inbox .pj-inbox-item[data-id="901"]');
const frame = function () { const p = d.body.querySelector(".pj-inbox-panel"); return p && p.querySelector("iframe"); };
const src = function () { return frame() ? frame().getAttribute("src") : ""; };
A.click(); await settle();
check("[수신함] 줄 → 오른쪽 작업 창 = 공유 링크 + embed", src() === "/project/t/101?embed=1", src());
check("[수신함] 같은 작업의 태그·알림을 함께 확인", reads.indexOf("m101") >= 0 && reads.indexOf("n901") >= 0, reads);
await settle();
check("[수신함] 알림 읽음 실패 — 굵게(읽지 않음) 그대로", N901.classList.contains("is-unread"));
let gate = deferred(), settles = 0;
frame().contentWindow.__pjEmbedSettle = function () { settles++; return gate.promise; };
B.click(); await settle();
check("[수신함] 작업 창 저장 확인 중엔 바꾸지 않음", src() === "/project/t/101?embed=1" && settles === 1, [src(), settles]);
A.click(); await settle(); // A→B→A 빨리
gate.resolve(true); await settle();
check("[수신함] A→B→A — 확인 뒤 A 그대로, B 는 열거나 확인하지 않음",
src() === "/project/t/101?embed=1" && reads.indexOf("m102") < 0 && B.classList.contains("is-unread") && settles === 1, [src(), reads, settles]);
gate = deferred();
B.click(); await settle(); gate.resolve(false); await settle();
check("[수신함] 계속 편집 — 창·선택 그대로, 새 줄 확인 안 함",
src() === "/project/t/101?embed=1" && A.classList.contains("is-selected") && !B.classList.contains("is-selected") && reads.indexOf("m102") < 0);
gate = deferred(); settles = 0;
const esc = function () { d.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Escape", bubbles: true })); };
esc(); await settle(); esc(); await settle();
const panelEl = d.body.querySelector(".pj-inbox-panel");
check("[수신함] 저장 중 Esc(두 번) — 확인 하나만, 끝나기 전엔 열린 채", panelEl.classList.contains("is-open") && settles === 1, settles);
gate.resolve(true); await settle();
check("[수신함] 저장이 끝나면 닫힘", !panelEl.classList.contains("is-open"));
await wait(260); await settle();
check("[수신함] 확인된 태그 줄은 빠지고, 읽음 실패한 알림 줄은 남는다", !A.isConnected && N901.isConnected, [A.isConnected, N901.isConnected]);
failNoti = false;
B.click(); await settle(); await settle();
check("[수신함] 닫힌 뒤 다른 줄 — 바로 열림", src() === "/project/t/102?embed=1", src());
}
// ── [검토 9] 새 프로젝트 — 생성과 멤버 배정 결과를 따로, 실패한 멤버만 다시, 연타해도 한 번 생성 ──
{
const env = makeEnv(adminHtml); baseRoutes(env);
env.route("GET", /\/project\/api\/assignable-users$/, function () { return { body: { users: [
{ email: "bob@test.local", id: "bob", name: "Bob", avatar: "" },
{ email: "carol@test.local", id: "carol", name: "Carol", avatar: "" }] } }; });
let creates = 0, failCarol = true;
const memberCalls = [];
const createGate = deferred();
env.route("POST", /\/project\/api\/projects$/, async function () {
creates++;
await createGate.promise;
return { status: 201, body: { project: { id: 9, name: "새 프로젝트" } } };
});
env.route("POST", /\/project\/api\/projects\/9\/members$/, function (u, b) {
memberCalls.push(b.user_email);
return failCarol && b.user_email === "carol@test.local" ? { status: 400, body: { detail: "배정 불가" } } : { status: 201, body: { member: {} } };
});
await boot(env);
const d = env.d;
d.getElementById("pj-new-project-side").click(); await settle();
d.getElementById("pj-f-name").value = "새 프로젝트";
d.querySelectorAll("#pj-f-members input[type=checkbox]").forEach(function (c) { c.checked = true; });
const save = d.getElementById("pj-save-project");
save.click(); save.click(); await settle(); // 연타
createGate.resolve(); await settle(); await settle();
const modal = d.getElementById("pj-modal-project");
const msg = d.getElementById("pj-f-project-msg");
const carol = d.querySelector('#pj-f-members input[value="carol@test.local"]').closest(".pj-member-pick");
check("[새 프로젝트] 연타해도 한 번만 생성", creates === 1, creates);
check("[새 프로젝트] 배정 실패 — 창 유지, 생성됨·실패 멤버 안내, 실패 표시",
!modal.hidden && !msg.hidden && /만들어졌습니다/.test(msg.textContent) && /배정 불가/.test(msg.textContent) &&
carol.classList.contains("is-failed") && /다시 배정/.test(save.textContent), [modal.hidden, msg.textContent, save.textContent]);
failCarol = false;
save.click(); await settle(); await settle();
check("[새 프로젝트] 다시 배정 — 실패한 멤버만, 프로젝트는 다시 만들지 않음, 끝나면 닫힘",
creates === 1 && JSON.stringify(memberCalls) === JSON.stringify(["bob@test.local", "carol@test.local", "carol@test.local"]) && modal.hidden,
[creates, memberCalls, modal.hidden]);
}
clearTimeout(WATCHDOG);
console.log(fails.length ? "\nFAILED: " + fails.join(", ") : "\nALL PASS");
process.exit(fails.length ? 1 : 0);
+2 -2
View File
@@ -46,7 +46,7 @@ def board() -> dict:
def goals_ctx(admin: bool) -> dict:
return {
"user": {"email": ME, "is_super_admin": False}, "is_admin": admin, "nav_projects": [], "goal_years": [2026],
"user": {"email": ME, "is_super_admin": False}, "is_admin": admin, "pj_pro": admin, "pj_admin": admin, "nav_projects": [], "goal_years": [2026],
"goal_year_active": 2026, "my_open_total": 0, "mention_unread": 0, "color_palette": ["#4573d2"],
"project_icons": ["folder"], "goals_enabled": True, "goal_year": 2026, "board": board(),
"months": list(range(1, 13)),
@@ -104,7 +104,7 @@ def meeting_view(err: bool) -> dict:
def meeting_ctx(admin: bool, err: bool, can_sync: bool = True) -> dict:
view = meeting_view(err)
ctx = {
"user": {"email": ME, "is_super_admin": False}, "is_admin": admin, "nav_projects": [], "goal_years": [2026],
"user": {"email": ME, "is_super_admin": False}, "is_admin": admin, "pj_pro": admin, "pj_admin": admin, "nav_projects": [], "goal_years": [2026],
"goal_year_active": 2026, "my_open_total": 0, "mention_unread": 0, "color_palette": ["#4573d2"],
"project_icons": ["folder"], "goal_year": 2026, "goal_month": 9, "meetings_enabled": True,
"weeks": [{"start": "2026-09-28", "end": "2026-10-04", "n": 4, "label": "9/28~10/4", "has": True, "now": False,
+26 -1
View File
@@ -52,11 +52,36 @@ def main() -> None:
env.globals["pj_kr_holidays"] = {}
for name, admin in (("project_render.html", False), ("project_admin_render.html", True)):
render_one(env, name, admin)
render_inbox(env)
def render_inbox(env) -> None:
"""수신함(project/inbox.html) — 태그한 작업 101·102, 알림(작업 101·102·프로젝트만)."""
def mt(tid: int, title: str) -> dict:
return {"id": tid, "title": title, "project_id": 1, "project_name": "P1", "project_color": "#4573d2",
"unread_mentions": 1, "stage_name": "할 일", "due_label": "", "mention_actor": "bob@test.local",
"completed_at": None}
def nt(nid: int, ntype: str, title: str, task_id: int | None) -> dict:
return {"id": nid, "type": ntype, "title": title, "body": "P1", "task_id": task_id, "project_id": 1,
"is_read": False, "actor_email": "bob@test.local", "created_at": "2026-10-12T09:00:00+09:00"}
html = env.get_template("project/inbox.html").render(
user={"email": ME, "is_super_admin": False}, is_admin=False, pj_pro=False, pj_admin=False,
nav_projects=PROJECTS, goal_years=[2026], my_open_total=0, mention_unread=2,
color_palette=["#4573d2"], project_icons=["folder"], project_asana_icons=[],
mentioned_tasks=[mt(101, "작업 A"), mt(102, "작업 B")],
notifications=[nt(901, "assigned", "작업 배정: 작업 A", 101), nt(902, "comment", "새 댓글: 작업 B", 102),
nt(903, "completed", "프로젝트 알림", None)],
)
path = os.path.join(OUT_DIR, "inbox_render.html")
io.open(path, "w", encoding="utf-8", newline="\n").write(html)
print("rendered:", path)
def render_one(env, name: str, admin: bool) -> None:
html = env.get_template("project/project.html").render(
user={"email": ME, "is_super_admin": False}, is_admin=admin, can_manage=True,
user={"email": ME, "is_super_admin": False}, is_admin=admin, pj_pro=admin, pj_admin=admin, 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=["할 일", "완료"],
+54 -8
View File
@@ -18,13 +18,24 @@ ROWS = [ # 최신순(list_notifications 와 같게)
class FakeStore:
"""list_notifications(최신순) + list_unread_after(DB 쪽 조건·오래된 것부터) — db.py 와 같은 의미."""
desktop = False
def __init__(self, rows=None):
self.rows = list(ROWS if rows is None else rows)
self.pages = 0
def notifier_active(self, email):
return self.desktop
def list_notifications(self, recipient_email, unread_only=False, limit=100):
rows = [r for r in ROWS if not unread_only or not r["is_read"]]
rows = sorted((r for r in self.rows if not unread_only or not r["is_read"]), key=lambda r: -r["id"])
return rows[:limit]
def list_unread_after(self, recipient_email, after_id, types, limit=200):
self.pages += 1
rows = sorted((r for r in self.rows if not r["is_read"] and r["id"] > after_id and r["type"] in types),
key=lambda r: r["id"])
return rows[:limit]
@@ -34,12 +45,13 @@ class AlertsApiTests(unittest.TestCase):
app.include_router(api.router)
self.client = TestClient(app)
def get(self, qs="", desktop=False):
st = FakeStore()
def get(self, qs="", desktop=False, st=None, visible=None):
st = st or FakeStore()
st.desktop = desktop
vis = visible or (lambda st, user, items: items)
with patch.object(api, "_require_user", return_value={"email": "Me@Test.local"}), \
patch.object(api, "_db_or_503", return_value=st), \
patch.object(api, "_visible_notifications", side_effect=lambda st, user, items: items):
patch.object(api, "_visible_notifications", side_effect=vis):
return self.client.get("/project/api/notifications/alerts" + qs).json()
def test_without_after_returns_only_baseline(self):
@@ -52,6 +64,13 @@ class AlertsApiTests(unittest.TestCase):
self.assertEqual(out["alerts"][1]["type"], "mention")
self.assertNotIn("desktop", out)
def test_alert_links_use_task_permalink(self):
# 작업 알림은 /project/t/{id} — 연결된 프로젝트에서만 읽을 수 있는 사람도 403 없이 열린다
out = self.get("?after=5")
self.assertEqual([a["href"] for a in out["alerts"]], ["/project/t/3", "/project/t/1"])
st = FakeStore([{"id": 3, "type": "mention", "is_read": False, "task_id": None, "project_id": 4}])
self.assertEqual(self.get("?after=0", st=st)["alerts"][0]["href"], "/project/p/4")
def test_pc_notifier_running_silences_web_popup(self):
out = self.get("?after=5", desktop=True)
self.assertEqual((out["alerts"], out["latest_id"], out["desktop"]), ([], 9, True))
@@ -60,12 +79,39 @@ class AlertsApiTests(unittest.TestCase):
class Broken(FakeStore):
def notifier_active(self, email):
raise RuntimeError("db down")
with patch.object(api, "_require_user", return_value={"email": "me@test.local"}), \
patch.object(api, "_db_or_503", return_value=Broken()), \
patch.object(api, "_visible_notifications", side_effect=lambda st, user, items: items):
out = self.client.get("/project/api/notifications/alerts?after=5").json()
out = self.get("?after=5", st=Broken())
self.assertEqual([a["id"] for a in out["alerts"]], [6, 8])
# ── 예전엔 최신 50건을 자른 뒤 걸러서 빠지던 경우들 ──
def test_assignment_behind_fifty_comment_alerts_is_not_lost(self):
rows = [{"id": 1, "type": "assigned", "title": "배정", "is_read": False, "task_id": 1, "project_id": 1}]
rows += [{"id": 100 + i, "type": "comment", "title": "댓글", "is_read": False, "task_id": 1, "project_id": 1}
for i in range(50)]
out = self.get("?after=0", st=FakeStore(rows))
self.assertEqual([a["id"] for a in out["alerts"]], [1])
def test_more_than_sixty_assignments_page_oldest_first(self):
rows = [{"id": i, "type": "assigned", "title": f"배정{i}", "is_read": False, "task_id": i, "project_id": 1}
for i in range(1, 66)]
st = FakeStore(rows)
out = self.get("?after=0", st=st)
self.assertEqual([a["id"] for a in out["alerts"]], list(range(1, 11))) # 오래된 것부터 10건
out = self.get("?after=10", st=st) # 닫으면 그 뒤 것(화면이 본 것=10 으로 다시 묻는다)
self.assertEqual([a["id"] for a in out["alerts"]], list(range(11, 21)))
out = self.get("?after=60", st=st)
self.assertEqual([a["id"] for a in out["alerts"]], [61, 62, 63, 64, 65])
def test_invisible_alerts_ahead_do_not_hide_visible_ones(self):
# 앞쪽 450건은 지금 볼 수 없는 작업(권한 회수) — 페이지를 넘겨 그 뒤의 볼 수 있는 알림을 찾는다
rows = [{"id": i, "type": "mention", "title": "x", "is_read": False, "task_id": 9, "project_id": 9}
for i in range(1, 451)]
rows.append({"id": 500, "type": "mention", "title": "보임", "is_read": False, "task_id": 1, "project_id": 1})
st = FakeStore(rows)
out = self.get("?after=0", st=st,
visible=lambda st, user, items: [n for n in items if n["project_id"] == 1])
self.assertEqual([a["id"] for a in out["alerts"]], [500])
self.assertEqual(st.pages, 3) # 200·200·51 — 끝까지 읽고 멈춘다
if __name__ == "__main__":
unittest.main()
+16 -4
View File
@@ -17,6 +17,11 @@ class FakeStore:
def list_projects(self, include_archived, member_email):
return [{"id": 1, "parent_id": None}, {"id": 2, "parent_id": None}, {"id": 5, "parent_id": 1}]
def get_project(self, project_id):
# 7 = 보관된 프로젝트(활성 목록에 없음), 5 = 서브프로젝트
return {"id": project_id, "parent_id": 1 if project_id == 5 else None,
"status": "archived" if project_id == 7 else "active"}
def list_tasks_for_projects(self, project_ids):
self.asked_projects = project_ids
return [{"id": 10 * pid} for pid in project_ids]
@@ -33,12 +38,12 @@ class SubtaskSummaryTests(unittest.TestCase):
self.client = TestClient(app)
self.st = FakeStore()
def call(self, scope):
with patch.object(api, "_require_user", return_value={"email": "me@test"}), \
def call(self, scope, pid=1):
with patch.object(api, "_require_user", return_value={"email": "me@test", "role": "pro"}), \
patch.object(api, "_db_or_503", return_value=self.st), \
patch.object(api, "_require_manage", return_value=None), \
patch.object(api, "_accessible_project_ids", return_value=None):
return self.client.get(f"/project/api/projects/1/subtasks-summary?scope={scope}")
return self.client.get(f"/project/api/projects/{pid}/subtasks-summary?scope={scope}")
def test_project_scope_uses_only_this_project(self):
r = self.call("project")
@@ -51,8 +56,15 @@ class SubtaskSummaryTests(unittest.TestCase):
self.call("all")
self.assertEqual(self.st.asked_projects, [1, 2]) # 서브프로젝트(5) 제외 — 스냅샷과 같은 범위
def test_all_scope_adds_open_archived_or_subproject_only(self):
# 지금 연 프로젝트가 보관(7)·서브프로젝트(5)면 그 하나만 더한다(다른 보관 프로젝트는 읽지 않는다)
self.call("all", pid=7)
self.assertEqual(self.st.asked_projects, [1, 2, 7])
self.call("all", pid=5)
self.assertEqual(self.st.asked_projects, [1, 2, 5])
def test_no_access_is_rejected(self):
with patch.object(api, "_require_user", return_value={"email": "me@test"}), \
with patch.object(api, "_require_user", return_value={"email": "me@test", "role": "pro"}), \
patch.object(api, "_db_or_503", return_value=self.st), \
patch.object(api, "_require_manage", side_effect=HTTPException(403)):
self.assertEqual(self.client.get("/project/api/projects/1/subtasks-summary").status_code, 403)
+1 -1
View File
@@ -261,7 +261,7 @@ class MeetingCellTests(unittest.TestCase):
DictLoader({"erp_base.html": "{% block head_extra %}{% endblock %}{% block content %}{% endblock %}"}),
FileSystemLoader(root / "app/modules/project/templates")]), autoescape=True)
html = env.get_template("project/goal_meeting.html").render(
user=dict(email="test@local"), is_admin=True, goal_year=2026, goal_month=9,
user=dict(email="test@local"), is_admin=True, pj_pro=True, goal_year=2026, goal_month=9,
meetings_enabled=True, week="2026-09-28", week_end="2026-10-04", prev_week="2026-09-21",
prev_week_end="2026-09-27", meeting_status=store.MEETING_STATUS, pj_kr_holidays={},
nav_projects=[], goal_years=[2026], color_palette=[], project_icons=[], meet_members=[], month_plan=None, **view)
+38 -2
View File
@@ -11,7 +11,7 @@ from fastapi.testclient import TestClient
from app.modules.project import store
from app.modules.project.db import ProjectStore
from tests.test_project_meeting_cells import Connection
from tests.test_project_meeting_cells import Connection, Result
api = importlib.import_module("app.modules.project.router")
@@ -20,11 +20,22 @@ class LockConnection(Connection):
def __init__(self):
super().__init__()
self.completed = set() # 완료된 주차 시작일
# 있는 회의록 — 9/28 주차(9/28~9/30)와 바로 다음 주차(10/1, 목요일 시작 — 달이 바뀐다)
self.meetings = {date(2026, 9, 28), date(2026, 10, 1)}
self.shared = [] # FOR SHARE 로 잠근 주차(다음 회의록)
def execute(self, sql, params=()):
if sql.startswith("SELECT completed_at FROM goal_meetings WHERE week_start = %s"):
from tests.test_project_meeting_cells import Result
if sql.endswith("FOR SHARE"):
assert self.depth > 0, "다음 회의록 잠금은 트랜잭션 안에서"
self.shared.append(params[0])
if params[0] not in self.meetings:
return Result([])
return Result([{"completed_at": "done" if params[0] in self.completed else None}])
if sql.startswith("UPDATE goal_meetings SET"):
assert self.locked and self.depth > 0, "머리 변경은 회의록 행을 잠근 트랜잭션 안에서"
self.calls.append((sql, params))
return Result([{"week_start": params[-1]}])
return super().execute(sql, params)
@@ -55,10 +66,35 @@ class MeetingLockTests(unittest.TestCase):
self.conn.completed.add(date(2026, 9, 28))
out = self.st.update_meeting_item(item_id=1, fields={"result_note": "잘 됨", "result_amount": "100"})
self.assertEqual((out["result_note"], out["result_amount"]), ("잘 됨", 100))
self.assertEqual(self.conn.shared, [date(2026, 10, 1)]) # 달이 바뀐 다음 주차(목요일 시작)를 잠그고 확인
self.conn.completed.add(date(2026, 10, 1))
with self.assertRaises(store.MeetingLocked):
self.st.update_meeting_item(item_id=1, fields={"result_note": "늦게"})
def test_completed_week_without_next_meeting_is_locked(self):
# 예전엔 다음 주차 회의록이 없으면 완료된 회의록의 결과도 고칠 수 있었다
self.conn.meetings.discard(date(2026, 10, 1))
self.conn.completed.add(date(2026, 9, 28))
with self.assertRaises(store.MeetingLocked):
self.st.update_meeting_item(item_id=1, fields={"result_note": "다음 회의 전"})
self.assertEqual(self.conn.rows[1]["result_note"], "")
def test_open_week_without_next_meeting_accepts_result(self):
self.conn.meetings.discard(date(2026, 10, 1))
out = self.st.update_meeting_item(item_id=1, fields={"result_note": "이번 주 결과"})
self.assertEqual(out["result_note"], "이번 주 결과")
def test_header_update_checks_lock_inside_row_lock(self):
self.st.update_meeting(week_start=date(2026, 9, 28), fields={"notes": "메모"})
sqls = [s for s, _ in self.conn.calls]
lock = next(i for i, s in enumerate(sqls) if s.startswith("SELECT week_start FROM goal_meetings") and "FOR UPDATE" in s)
upd = next(i for i, s in enumerate(sqls) if s.startswith("UPDATE goal_meetings SET"))
self.assertLess(lock, upd)
self.conn.completed.add(date(2026, 9, 28))
with self.assertRaises(store.MeetingLocked):
self.st.update_meeting(week_start=date(2026, 9, 28), fields={"notes": "잠김"})
self.assertEqual(sum(1 for s, _ in self.conn.calls if s.startswith("UPDATE goal_meetings SET")), 1)
def test_anyone_edits_but_only_admin_completes(self):
app = FastAPI()
app.include_router(api.router)
+155 -16
View File
@@ -89,6 +89,7 @@ if ENABLED:
RUN = uuid.uuid4().hex[:6]
ADMIN = USERS.add(f"admin-{RUN}@test.local", role="admin")
PRO = USERS.add(f"pro-{RUN}@test.local", role="pro") # Pro user(2026-10-12)
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")
@@ -118,18 +119,19 @@ def _count(sql: str, *args) -> int:
# ════════════════════════════════════════════════════════════
# [07] 소유자 변경은 관리자만
# [07] 프로젝트 수정·소유자 변경은 Pro user 이상(2026-10-12)
# ════════════════════════════════════════════════════════════
def test_owner_change_admin_only():
# 관리자도 멤버가 아닌 프로젝트는 못 다룬다(2026-10-07) — 소유자를 남에게 넘긴 뒤에도 바꿀 수 있게 멤버로 둔다
p = _project("P-owner", ADMIN, (BOB, ADMIN))
p = _project("P-owner", ADMIN, (BOB, ADMIN, PRO))
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
# User 는 이름만 바꾸는 것도 안 된다, Pro user 멤버는 된다(같은 소유자 값을 같이 보내는 화면 저장 포함)
assert req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"name": "no"}).status_code == 403
assert req("PUT", f"/project/api/projects/{p['id']}", PRO, 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
@@ -137,10 +139,10 @@ def test_owner_change_admin_only():
# 소유자에서 빠지면(관리자가 다시 바꿈) 멤버가 아닌 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
# 생성: User 는 새 프로젝트 불가, Pro user 는 본인·미지정 → 본인이 소유자
assert req("POST", "/project/api/projects", BOB, json={"name": "n1"}).status_code == 403
r = req("POST", "/project/api/projects", PRO, json={"name": "n2"})
assert r.status_code == 201 and r.json()["project"]["owner_email"] == PRO
# ════════════════════════════════════════════════════════════
@@ -152,8 +154,10 @@ def test_delete_requires_current_access():
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
# 작업 삭제는 멤버 누구나(2026-10-12) — 남(BOB)이 만든 작업도 ALICE 가 지울 수 있다
t_bob = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "bob task", "stage_id": s["id"]}).json()["task"]
assert req("DELETE", f"/project/api/tasks/{t_bob['id']}", ALICE).status_code == 200
trash_before = _count("SELECT COUNT(*) AS n FROM project_trash")
# 멤버에서 빠진 생성자 → 거절, 행·댓글·휴지통 변화 없음
ST.remove_member(project_id=p["id"], user_email=ALICE)
assert req("DELETE", f"/project/api/tasks/{t['id']}", ALICE).status_code == 403
@@ -342,7 +346,7 @@ def test_file_comment_atomic_and_idempotent():
# [04] 날짜 범위
# ════════════════════════════════════════════════════════════
def test_date_range_validation():
p = _project("P-date", ADMIN, (BOB,))
p = _project("P-date", ADMIN, (BOB, PRO))
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
@@ -355,12 +359,12 @@ def test_date_range_validation():
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
# 프로젝트도 같은 규칙(부분 수정 포함)
# 프로젝트도 같은 규칙(부분 수정 포함) — 프로젝트 수정은 Pro user 이상 멤버(2026-10-12)
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
assert req("PUT", pu, PRO, json={"start_date": "2026-11-01", "due_date": "2026-10-01"}).status_code == 400
assert req("PUT", pu, PRO, json={"due_date": "2026-10-01"}).status_code == 200
assert req("PUT", pu, PRO, json={"start_date": "2026-11-01"}).status_code == 400
assert req("POST", "/project/api/projects", PRO, json={"name": "d", "start_date": "2026-11-02", "due_date": "2026-11-01"}).status_code == 400
# ════════════════════════════════════════════════════════════
@@ -1027,6 +1031,141 @@ def test_meeting_perf_unknown_vs_zero():
_drop_meetings([w, w - timedelta(days=7)])
# ════════════════════════════════════════════════════════════
# [검토 2026-10-12] 실제 DB — 동시성·조회 범위·알림 페이지·배지·회의록 결과 잠금
# ════════════════════════════════════════════════════════════
def _race(fns):
"""함수들을 최대한 같은 순간에 돌리고 (결과 또는 예외) 목록."""
gate = threading.Barrier(len(fns))
out: list = [None] * len(fns)
def run(i, fn):
gate.wait()
try:
out[i] = fn()
except Exception as exc: # noqa: BLE001
out[i] = exc
ths = [threading.Thread(target=run, args=(i, f)) for i, f in enumerate(fns)]
[t.start() for t in ths]
[t.join() for t in ths]
return out
def test_review_task_dates_never_invert_under_race():
p = _project("P-race", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
for _ in range(10):
t = ST.create_task(project_id=p["id"], title="race", stage_id=s["id"],
start_date="2026-10-10", due_date="2026-10-20", created_by=BOB)
_race([lambda: ST.update_task(task_id=t["id"], fields={"start_date": "2026-10-18"}),
lambda: ST.update_task(task_id=t["id"], fields={"due_date": "2026-10-12"})])
got = ST.get_task(task_id=t["id"])
assert got["start_date"] <= got["due_date"], got # 한쪽은 지금 값으로 검사돼 거절된다
# 프로젝트도 같은 규칙
for _ in range(5):
q = ST.create_project(name=f"race-{uuid.uuid4().hex[:4]}", owner_email=ADMIN, created_by=ADMIN,
start_date="2026-10-10", due_date="2026-10-20")
_race([lambda: ST.update_project(project_id=q["id"], fields={"start_date": "2026-10-18"}),
lambda: ST.update_project(project_id=q["id"], fields={"due_date": "2026-10-12"})])
got = ST.get_project(project_id=q["id"])
assert got["start_date"] <= got["due_date"], got
def test_review_concurrent_completion_logs_once():
p = _project("P-done-race", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
t = ST.create_task(project_id=p["id"], title="once", stage_id=s["id"], created_by=BOB)
outs = _race([lambda: ST.update_task(task_id=t["id"], fields={"completed": True}, actor=BOB) for _ in range(4)])
assert sum(1 for o in outs if isinstance(o, dict) and o["_newly_completed"]) == 1, outs
assert _count("SELECT COUNT(*) AS n FROM project_activity WHERE task_id = %s AND action = 'completed'", t["id"]) == 1
def test_review_subproject_tasks_and_archived_scope():
parent = _project("P-parent", ADMIN, (BOB, CAROL))
child = ST.create_project(name=f"child-{uuid.uuid4().hex[:4]}", parent_id=parent["id"], owner_email=ADMIN, created_by=ADMIN)
ST.add_member(project_id=child["id"], user_email=CAROL)
tp = ST.create_task(project_id=parent["id"], title="부모", created_by=ADMIN)
tc = ST.create_task(project_id=child["id"], title="자식", created_by=ADMIN)
ids = lambda who: sorted(t["id"] for t in req("GET", f"/project/api/projects/{parent['id']}/tasks", who).json()["tasks"])
assert ids(BOB) == [tp["id"]] # 부모 멤버·자식 비멤버 — 자식 작업 안 보임
assert ids(CAROL) == sorted([tp["id"], tc["id"]])
assert req("GET", f"/project/api/projects/{parent['id']}/tasks", ADMIN).status_code == 200 # ADMIN = owner
# 보관된 프로젝트를 열어도 자기 작업은 받는다(스냅샷)
arch = _project("P-arch", BOB)
ta = ST.create_task(project_id=arch["id"], title="보관 작업", created_by=BOB)
ST.update_project(project_id=arch["id"], fields={"status": "archived"})
snap = req("GET", f"/project/api/projects/{arch['id']}/snapshot?scope=all", BOB).json()
assert ta["id"] in [t["id"] for t in snap["tasks"]]
assert [x["id"] for x in snap["projects"] if x.get("view_only")] == [arch["id"]]
def test_review_alert_paging_and_badges():
me = USERS.add(f"alert-{uuid.uuid4().hex[:6]}@test.local")
p = _project("P-alert", ADMIN, (me,))
t = ST.create_task(project_id=p["id"], title="x", created_by=ADMIN)
ST.add_notification(recipient_email=me, actor_email=ADMIN, project_id=p["id"], task_id=t["id"], type="assigned", title="배정")
for _ in range(55):
ST.add_notification(recipient_email=me, actor_email=ADMIN, project_id=p["id"], task_id=t["id"], type="comment", title="댓글")
out = req("GET", "/project/api/notifications/alerts?after=0", me).json()
assert [a["type"] for a in out["alerts"]] == ["assigned"] and out["alerts"][0]["href"] == f"/project/t/{t['id']}"
assert req("GET", "/project/api/notifications/unread-count", me).json()["unread"] == 56
# 권한을 잃은 프로젝트의 알림은 배지에서 빠진다(기록은 그대로)
ST.remove_member(project_id=p["id"], user_email=me)
assert req("GET", "/project/api/notifications/unread-count", me).json()["unread"] == 0
# 내 작업 배지·목록 — 미완료는 전부, 완료는 최근 것만
q = _project("P-my", ADMIN, (me,))
open_ids = [ST.create_task(project_id=q["id"], title=f"o{i}", assignee_email=me, created_by=ADMIN)["id"] for i in range(3)]
done_ids = []
for i in range(3):
d = ST.create_task(project_id=q["id"], title=f"d{i}", assignee_email=me, created_by=ADMIN)
ST.update_task(task_id=d["id"], fields={"completed": True})
done_ids.append(d["id"])
rows = ST.list_my_tasks(assignee_email=me, completed_limit=1)
assert sorted(r["id"] for r in rows if not r["completed_at"]) == sorted(open_ids)
assert [r["id"] for r in rows if r["completed_at"]] == [done_ids[-1]]
assert req("GET", "/project/api/my-tasks/open-count", me).json()["open"] == 3
ST.add_mentions(task_id=open_ids[0], emails=[me], actor_email=ADMIN)
assert req("GET", "/project/api/mentions/unread-count", me).json()["unread"] == 1
def test_review_reorder_and_creator_membership():
mine = _project("P-ord", PRO)
other = _project("P-ord-other", ADMIN)
assert req("PUT", "/project/api/projects/order", PRO, json={"ordered_ids": [mine["id"], other["id"]]}).status_code == 403
assert req("PUT", "/project/api/projects/order", PRO, json={"ordered_ids": [mine["id"], mine["id"]]}).status_code == 400
assert req("PUT", "/project/api/projects/order", PRO, json={"ordered_ids": [mine["id"]]}).status_code == 200
r = req("POST", "/project/api/projects", PRO, json={"name": f"own-{RUN}", "owner_email": ALICE})
assert r.status_code == 201, r.text
pid = r.json()["project"]["id"]
assert ST.get_project(project_id=pid)["owner_email"] == ALICE
assert req("GET", f"/project/p/{pid}", PRO).status_code == 200 # 만든 직후 자기 프로젝트를 연다(멤버 행)
ST.remove_member(project_id=pid, user_email=PRO)
assert req("GET", f"/project/p/{pid}", PRO).status_code == 403 # created_by 로는 권한이 남지 않는다
def test_review_meeting_result_lock_rules():
from app.modules.project import store
w2 = date(2031, 10, 1) # 수요일 시작 1주차(달 경계)
w1 = store.prev_week_period(w2)[0] # 9월 마지막 주차
_drop_meetings([w1, w2])
try:
_create_meeting(w1)
item = ST.get_meeting(week_start=w1)["items"][0]["id"]
put = lambda body: req("PUT", f"/project/api/goals/meeting-items/{item}", BOB, json=body).status_code
ST.set_meeting_completed(week_start=w1, done=True, by=ADMIN)
assert put({"result_note": "다음 회의 전"}) == 409 # 다음 주차 회의록이 없으면 그 주가 완료되면 잠김
_create_meeting(w2)
assert put({"result_note": "다음 회의에서"}) == 200 # 다음 주차 회의록이 열려 있으면 결과는 적을 수 있다
assert put({"content": "내용"}) == 409 # 주요 업무는 그 주 완료로 잠김(잠금 차이 보존)
ST.set_meeting_completed(week_start=w2, done=True, by=ADMIN)
assert put({"result_note": "늦게"}) == 409
r = req("PUT", f"/project/api/goals/meetings/{w2}", BOB, json={"notes": "잠김"})
assert r.status_code == 409, r.text # 완료된 회의록 머리도
finally:
_drop_meetings([w1, w2])
if __name__ == "__main__":
if not ENABLED:
print("SKIP: PROJECT_TEST_DB_URL(localhost) not set")
+6
View File
@@ -24,6 +24,10 @@ class FakeStore:
def list_notifications(self, recipient_email, unread_only=False, limit=100):
return ROWS[:limit]
def list_unread_after(self, recipient_email, after_id, types, limit=200):
return sorted((r for r in ROWS if not r["is_read"] and r["id"] > after_id and r["type"] in types),
key=lambda r: r["id"])[:limit]
def mark_read(self, notification_id, recipient_email):
self.read.append((notification_id, recipient_email))
@@ -86,6 +90,8 @@ class NotifierApiTests(unittest.TestCase):
out = res.json()
self.assertEqual([a["id"] for a in out["alerts"]], [6, 8])
self.assertEqual((out["me"], out["latest_id"], out["name"]), ("me@test.local", 8, "나"))
# PC 알림 [열기] 도 웹과 같은 주소(작업 공유 링크) — 서버가 지금 권한으로 열 프로젝트를 고른다
self.assertEqual([a["href"] for a in out["alerts"]], ["/project/t/3", "/project/t/1"])
def test_alerts_rejects_missing_or_unknown_token(self):
self.assertEqual(self.client.get("/project/api/notifier/alerts").status_code, 401)
+478
View File
@@ -0,0 +1,478 @@
"""2026-10-12 검토 반영 회귀 테스트 — 권한·링크·조회 범위·저장 실패·동시성·중복 방지. DB 없이 가짜 저장소로.
실제 PostgreSQL 이 있어야 확인되는 동시성(두 요청이 정말 동시에 행을 잠그는 경우)은
tests/test_project_module.py 의 test_review_* 가 맡는다(로컬 테스트 DB 전용).
"""
import importlib
import sys
import tempfile
import threading
import time
import types
import unittest
from contextlib import contextmanager
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
from fastapi import FastAPI
from fastapi.responses import HTMLResponse
from fastapi.testclient import TestClient
from app.modules.project import access, store
from app.modules.project.db import ProjectStore
from app.store import SUPER_ADMIN_EMAIL
api = importlib.import_module("app.modules.project.router")
PM = {"email": "pm@test.local", "role": "pro"} # 부모(1)·보관(4) 멤버, 자식(2) 비멤버
BOTH = {"email": "both@test.local", "role": "user"} # 부모·자식 멤버
CHILD = {"email": "child@test.local", "role": "user"} # 자식만
ADMIN = {"email": "admin@test.local", "role": "admin"} # 어디에도 멤버 아님
SUPER = {"email": SUPER_ADMIN_EMAIL, "role": "admin"}
READER = {"email": "reader@test.local", "role": "pro"} # 부모(1)·연결 대상(3) 멤버 — 자식 작업 20 은 3 에 연결돼 READ
class Store(MagicMock):
"""프로젝트 1(부모) ─ 2(서브), 3(다른 프로젝트), 4(보관). 작업 10∈1, 20∈2(3 에 연결), 21∈2."""
PROJECTS = {
1: {"id": 1, "parent_id": None, "name": "부모", "owner_email": "", "status": "active", "created_by": ""},
2: {"id": 2, "parent_id": 1, "name": "자식", "owner_email": "", "status": "active", "created_by": ""},
3: {"id": 3, "parent_id": None, "name": "연결", "owner_email": "", "status": "active", "created_by": ""},
4: {"id": 4, "parent_id": None, "name": "보관", "owner_email": "", "status": "archived", "created_by": ""},
}
MEMBERS = {1: {"pm@test.local", "both@test.local", "reader@test.local"},
2: {"both@test.local", "child@test.local"},
3: {"reader@test.local"},
4: {"pm@test.local"}}
TASKS = {10: {"id": 10, "project_id": 1, "title": "부모 작업", "parent_task_id": None},
20: {"id": 20, "project_id": 2, "title": "자식 작업(연결)", "parent_task_id": None},
21: {"id": 21, "project_id": 2, "title": "자식 작업", "parent_task_id": None},
40: {"id": 40, "project_id": 4, "title": "보관 작업", "parent_task_id": None}}
LINKS = {20: {3}}
def is_member(self, project_id, user_email):
return user_email in self.MEMBERS.get(int(project_id), set())
def list_projects(self, include_archived=False, member_email=None):
return [dict(p) for pid, p in self.PROJECTS.items()
if (include_archived or p["status"] != "archived")
and (member_email is None or member_email in self.MEMBERS.get(pid, set()))]
def get_project(self, project_id):
p = self.PROJECTS.get(int(project_id))
return dict(p) if p else None
def get_task(self, task_id):
t = self.TASKS.get(int(task_id))
return dict(t) if t else None
def task_link_scope(self, task_ids):
return {int(t): set(self.LINKS[int(t)]) for t in task_ids if int(t) in self.LINKS}
def list_tasks(self, project_id=None, include_subprojects=False, limit=1000, **kw):
tree = {int(project_id)}
if include_subprojects:
tree |= {pid for pid, p in self.PROJECTS.items() if p["parent_id"] in tree}
return [dict(t) for t in self.TASKS.values() if t["project_id"] in tree]
def list_tasks_for_projects(self, project_ids, **kw):
self.asked_task_projects = list(project_ids)
out = []
for pid in project_ids:
out += [{**t, "context_project_id": pid} for t in self.TASKS.values() if t["project_id"] == pid]
out += [{**self.TASKS[tid], "context_project_id": pid} for tid, ps in self.LINKS.items() if pid in ps]
return out
def list_stages_for_projects(self, project_ids):
return {int(i): [] for i in project_ids}
def list_stages(self, project_id):
return []
def list_members(self, project_id):
return [{"user_email": e} for e in sorted(self.MEMBERS.get(int(project_id), set()))]
def client_for(st, data_dir=None):
app = FastAPI()
app.include_router(api.router)
app.state.project_store = st
app.state.data_dir = data_dir or tempfile.mkdtemp(prefix="pj-review-")
return TestClient(app, raise_server_exceptions=False)
class Base(unittest.TestCase):
def setUp(self):
self.st = Store()
for p in (patch.object(access, "can_use_module", side_effect=lambda u: bool(u)),):
p.start()
self.addCleanup(p.stop)
self.client = client_for(self.st)
def call(self, who, method, url, **kw):
with patch.object(api, "_require_user", return_value=who), patch.object(api, "_db_or_503", return_value=self.st):
return self.client.request(method, url, **kw)
# ── [1] 부모 프로젝트 조회로 서브프로젝트 작업이 새지 않는다 ─────────────
class SubprojectTasksTests(Base):
def ids(self, who, pid=1):
r = self.call(who, "GET", f"/project/api/projects/{pid}/tasks")
return r.status_code, sorted(t["id"] for t in r.json().get("tasks", [])) if r.status_code == 200 else None
def test_parent_member_without_child_membership(self):
self.assertEqual(self.ids(PM), (200, [10]))
def test_member_of_both_and_child_member(self):
self.assertEqual(self.ids(BOTH), (200, [10, 20, 21]))
self.assertEqual(self.ids(CHILD)[0], 403) # 부모 화면은 못 연다
self.assertEqual(self.ids(CHILD, pid=2), (200, [20, 21]))
def test_non_member_admin_and_super(self):
self.assertEqual(self.ids(ADMIN)[0], 403)
self.assertEqual(self.ids(SUPER), (200, [10, 20, 21]))
def test_linked_read_task_stays_visible(self):
# READER 는 자식(2) 멤버가 아니지만 작업 20 이 자기 프로젝트(3)에 연결돼 읽기 권한(READ)
self.assertEqual(self.ids(READER), (200, [10, 20]))
self.assertEqual(access.task_access(self.st, READER, self.st.get_task(20)), access.READ)
# ── [2] 사이드바 순서 API — 보낸 id 전부 관리 권한, 이상한 값은 400 ──────────
class ReorderTests(Base):
def put(self, who, body):
self.st.reorder_projects.reset_mock()
return self.call(who, "PUT", "/project/api/projects/order", json=body).status_code
def test_only_manageable_projects(self):
self.assertEqual(self.put(PM, {"ordered_ids": [4, 1]}), 200)
self.st.reorder_projects.assert_called_once_with(ordered_ids=[4, 1])
self.assertEqual(self.put(PM, {"ordered_ids": [1, 3]}), 403) # 3 은 멤버 아님
self.st.reorder_projects.assert_not_called() # 일부만 바뀌지 않는다
self.assertEqual(self.put(PM, {"ordered_ids": [999]}), 403) # 없는 id 도 같은 403
self.assertEqual(self.put(ADMIN, {"ordered_ids": [1]}), 403) # 비멤버 Admin
self.assertEqual(self.put(SUPER, {"ordered_ids": [3, 1]}), 200)
self.assertEqual(self.put(SUPER, {"ordered_ids": [999]}), 403)
self.assertEqual(self.put(BOTH, {"ordered_ids": [1]}), 403) # User 는 등급에서 막힘
def test_bad_payloads_are_400(self):
for body in ({}, {"ordered_ids": []}, {"ordered_ids": "1,2"}, {"ordered_ids": [1, 1]},
{"ordered_ids": [True]}, {"ordered_ids": ["a"]}, {"ordered_ids": [1.5]},
{"ordered_ids": [0]}, {"ordered_ids": [None]}):
with self.subTest(body=body):
self.assertEqual(self.put(PM, body), 400)
self.st.reorder_projects.assert_not_called()
# ── [3][4] 작업 열기 경로·보관/서브프로젝트 화면 ─────────────────────────
class FakeMain(types.ModuleType):
def __init__(self, who):
super().__init__("app.main")
self.who = who
self.ctx = None
self.user_store = SimpleNamespace(list_all=lambda: [], get=lambda e: None)
def get_current_user_record(self, request):
return self.who
def build_erp_nav(self, user, active=""):
return []
def render_template(self, request, name, ctx, status_code=200):
self.ctx = ctx
return HTMLResponse(f"{name}|{ctx.get('reason', '')}", status_code=status_code)
class OpenPathTests(Base):
def get(self, who, url):
fake = FakeMain(who)
with patch.dict(sys.modules, {"app.main": fake}), patch("app.store.has_module", return_value=True):
r = self.call(who, "GET", url, follow_redirects=False)
return r, fake
def test_permalink_opens_linked_project_for_read_user_and_keeps_embed(self):
r, _ = self.get(READER, "/project/t/20?embed=1")
self.assertEqual((r.status_code, r.headers["location"]), (303, "/project/p/3?task=20&embed=1"))
r, _ = self.get(PM, "/project/t/10")
self.assertEqual(r.headers["location"], "/project/p/1?task=10")
r, _ = self.get(ADMIN, "/project/t/20")
self.assertEqual(r.status_code, 403)
def test_old_home_project_url_redirects_read_user(self):
# 옛 PC 알림 프로그램·북마크(/p/{원 소속}?task=) — 403 대신 읽을 수 있는 연결된 프로젝트로
r, _ = self.get(READER, "/project/p/2?task=20&embed=1")
self.assertEqual((r.status_code, r.headers["location"]), (303, "/project/p/3?task=20&embed=1"))
r, _ = self.get(ADMIN, "/project/p/2?task=20")
self.assertEqual(r.status_code, 403)
r, _ = self.get(READER, "/project/p/2")
self.assertEqual(r.status_code, 403)
def test_archived_project_page_reads_its_own_tasks_only(self):
r, fake = self.get(PM, "/project/p/4")
self.assertEqual(r.status_code, 200, r.text)
self.assertEqual(self.st.asked_task_projects, [1, 4]) # 활성 최상위(1) + 지금 연 보관 프로젝트(4)만
self.assertIn(40, [t["id"] for t in fake.ctx["tasks"]])
metas = {p["id"]: p for p in fake.ctx["projects_meta"]}
self.assertTrue(metas[4]["view_only"]) # 화면용 — 사이드바 목록에는 없다
self.assertNotIn(4, [p["id"] for p in fake.ctx["nav_projects"]])
def test_snapshot_matches_first_page_scope(self):
r = self.call(PM, "GET", "/project/api/projects/4/snapshot?scope=all")
self.assertEqual(r.status_code, 200, r.text)
out = r.json()
self.assertEqual(self.st.asked_task_projects, [1, 4])
self.assertIn(40, [t["id"] for t in out["tasks"]])
self.assertEqual([p["id"] for p in out["projects"] if p.get("view_only")], [4])
def test_subproject_page_includes_its_tasks(self):
r, fake = self.get(BOTH, "/project/p/2")
self.assertEqual(r.status_code, 200, r.text)
self.assertEqual(self.st.asked_task_projects, [1, 2]) # 최상위 멤버 프로젝트(1) + 지금 연 서브프로젝트(2)
self.assertEqual(sorted(t["id"] for t in fake.ctx["tasks"] if t["context_project_id"] == 2), [20, 21])
# ── [8] 일반 첨부 — DB 저장 실패면 이 요청이 쓴 파일만 지운다 ─────────────
class AttachmentCleanupTests(Base):
def test_db_failure_removes_only_new_file(self):
data_dir = tempfile.mkdtemp(prefix="pj-att-")
self.client = client_for(self.st, data_dir)
old = Path(data_dir) / "project" / "10"
old.mkdir(parents=True)
(old / "existing.bin").write_bytes(b"keep")
self.st.add_attachment.side_effect = RuntimeError("db down")
r = self.call(PM, "POST", "/project/api/tasks/10/attachments", files={"file": ("a.txt", b"hello", "text/plain")})
self.assertEqual(r.status_code, 500)
self.assertEqual(sorted(p.name for p in old.iterdir()), ["existing.bin"])
self.st.add_attachment.side_effect = None
self.st.add_attachment.return_value = {"id": 1}
r = self.call(PM, "POST", "/project/api/tasks/10/attachments", files={"file": ("a.txt", b"hello", "text/plain")})
self.assertEqual(r.status_code, 201)
self.assertEqual(len(list(old.iterdir())), 2)
# 빈 파일·권한은 그대로
self.assertEqual(self.call(PM, "POST", "/project/api/tasks/10/attachments",
files={"file": ("e.txt", b"", "text/plain")}).status_code, 400)
self.assertEqual(self.call(CHILD, "POST", "/project/api/tasks/10/attachments",
files={"file": ("a.txt", b"x", "text/plain")}).status_code, 403)
# ── [10] 배지 개수 — 제한 없이, 지금 권한으로 ─────────────────────────────
class BadgeCountTests(Base):
def test_my_open_count_is_exact_past_old_limit(self):
self.st.list_my_open_refs.return_value = (
[{"id": i, "project_id": 1} for i in range(1, 1501)] + [{"id": 5000 + i, "project_id": 2} for i in range(10)])
self.assertEqual(api._my_open_count(self.st, PM), 1500) # 2(비멤버)의 10건은 빼고
self.assertEqual(api._my_open_count(self.st, BOTH), 1510)
def test_unread_notification_count_is_exact(self):
self.st.list_unread_refs.return_value = (
[{"id": i, "project_id": 1, "task_id": 10} for i in range(700)] + [{"id": 900, "project_id": 2, "task_id": 21}])
self.assertEqual(api._notification_unread(self.st, PM), 700)
self.assertEqual(api._notification_unread(self.st, BOTH), 701)
def test_unread_mentions_count_filters_by_current_access(self):
self.st.list_unread_mention_refs.return_value = [
{"id": 10, "project_id": 1, "unread_mentions": 3}, {"id": 21, "project_id": 2, "unread_mentions": 4}]
self.assertEqual(api._safe_mention_unread(self.st, PM), 3)
self.assertEqual(api._safe_mention_unread(self.st, BOTH), 7)
# ── [13] 남을 소유자로 지정해 만들면 만든 사람은 명시적 멤버로 ───────────────
class CreatorMemberTests(Base):
def test_creator_added_as_member_only_when_owner_is_someone_else(self):
self.st.create_project.return_value = {"id": 9, "name": "n"}
with patch.object(api, "_check_owner_candidate"):
self.call(PM, "POST", "/project/api/projects", json={"name": "n", "owner_email": "other@test.local"})
kw = self.st.create_project.call_args.kwargs
self.assertEqual((kw["owner_email"], kw["member_emails"]), ("other@test.local", ["pm@test.local"]))
self.call(PM, "POST", "/project/api/projects", json={"name": "n"})
kw = self.st.create_project.call_args.kwargs
self.assertEqual((kw["owner_email"], kw["member_emails"]), ("pm@test.local", []))
# ── [14] 중복 방지 키 — 실패·성공·동시 요청에서 잠금이 남지 않는다 ───────────
class OnceTests(unittest.TestCase):
USER = {"email": "me@test.local"}
def setUp(self):
api._once_results.clear()
api._once_key_locks.clear()
def test_failure_releases_lock_and_retry_runs_again(self):
calls = []
def boom():
calls.append(1)
raise RuntimeError("x")
with self.assertRaises(RuntimeError):
api._once(self.USER, 1, "tok", boom)
self.assertEqual(api._once_key_locks, {}) # 실패한 키의 잠금이 남지 않는다
out = api._once(self.USER, 1, "tok", lambda: {"ok": 1})
self.assertEqual((out, len(calls)), ({"ok": 1}, 1))
self.assertEqual(api._once(self.USER, 1, "tok", lambda: {"ok": 2}), {"ok": 1, "duplicate": True}) # 응답 유실 후 재전송
self.assertEqual(api._once_key_locks, {})
def test_concurrent_same_token_runs_once(self):
started, release, runs, outs = threading.Event(), threading.Event(), [], []
def slow():
runs.append(1)
started.set()
release.wait(2)
return {"id": 7}
th = [threading.Thread(target=lambda: outs.append(api._once(self.USER, 1, "same", slow))) for _ in range(5)]
th[0].start()
started.wait(2)
for t in th[1:]:
t.start()
time.sleep(0.05)
self.assertEqual(api._once_key_locks[("me@test.local", 1, "same")][1], 5) # 기다리는 요청이 있는 동안 유지
release.set()
for t in th:
t.join(2)
self.assertEqual(len(runs), 1)
self.assertEqual(sorted(bool(o.get("duplicate")) for o in outs), [False, True, True, True, True])
self.assertEqual(api._once_key_locks, {})
def test_expired_results_are_purged(self):
api._once(self.USER, 1, "old", lambda: {"ok": 1})
with patch.object(api.time, "monotonic", return_value=time.monotonic() + api._ONCE_TTL_SEC + 1):
api._once(self.USER, 1, "new", lambda: {"ok": 2})
self.assertNotIn(("me@test.local", 1, "old"), api._once_results)
# ── [B] 섹션 기본 담당자 — 지금 권한(등록·project 권한)도 통과해야 자동 배정 ──────
class _Res:
def __init__(self, rows):
self.rows = list(rows)
def fetchone(self):
return self.rows[0] if self.rows else None
def fetchall(self):
return self.rows
class StageDefaultAssigneeTests(unittest.TestCase):
def conn(self):
def execute(sql, params=()):
if "to_jsonb(s)" in sql:
return _Res([{"e": "Gone@Test.local"}])
if "FROM project_members" in sql:
return _Res([{"user_name": "Gone"}])
raise AssertionError(sql)
return SimpleNamespace(execute=execute)
def test_revoked_or_deleted_user_is_not_auto_assigned(self):
self.assertEqual(ProjectStore._stage_default_assignee(self.conn(), 5, 1), ("gone@test.local", "Gone"))
self.assertEqual(ProjectStore._stage_default_assignee(self.conn(), 5, 1, allowed=lambda e: False), ("", ""))
self.assertEqual(ProjectStore._stage_default_assignee(self.conn(), 5, 1, allowed=lambda e: True),
("gone@test.local", "Gone"))
def test_router_check_uses_user_registry_and_module(self):
with patch.object(access, "default_user_lookup", return_value=None):
self.assertFalse(api._registered_project_user("x@test.local"))
with patch.object(access, "default_user_lookup", return_value={"email": "x@test.local"}), \
patch.object(access, "can_use_module", return_value=False):
self.assertFalse(api._registered_project_user("x@test.local"))
with patch.object(access, "default_user_lookup", return_value={"email": "x@test.local"}), \
patch.object(access, "can_use_module", return_value=True):
self.assertTrue(api._registered_project_user("x@test.local"))
# ── [11] 작업 수정 — 잠근 행으로 검사, 같은 연결, 실제 전환 기준 알림 힌트 ────────
class TaskConn:
"""tasks 한 행 + 섹션. FOR UPDATE 로 읽힌 '지금 값'이 검사·알림 기준이어야 한다."""
def __init__(self, row):
self.row = dict(row)
self.depth, self.locked, self.updates, self.logs = 0, False, [], []
self.stages = {11: {"project_id": 1, "is_done_stage": False, "dae": "dae@test.local"},
12: {"project_id": 1, "is_done_stage": True, "dae": ""}}
@contextmanager
def transaction(self):
self.depth += 1
try:
yield
finally:
self.depth -= 1
self.locked = False
def execute(self, sql, params=()):
if sql.startswith("SELECT * FROM tasks WHERE id = %s FOR UPDATE"):
assert self.depth > 0
self.locked = True
return _Res([dict(self.row)])
if sql.startswith("SELECT 1 FROM project_stages WHERE id = %s AND project_id = %s"):
s = self.stages.get(params[0])
return _Res([{"?": 1}] if s and s["project_id"] == params[1] else [])
if "to_jsonb(s)" in sql:
return _Res([{"e": self.stages[params[0]]["dae"]}])
if "FROM project_members" in sql:
return _Res([{"user_name": "Dae"}])
if sql.startswith("SELECT is_done_stage FROM project_stages"):
return _Res([{"is_done_stage": self.stages[params[0]]["is_done_stage"]}])
if sql.startswith("UPDATE tasks SET"):
assert self.locked, "변경은 잠근 행에"
self.updates.append((sql, params))
return _Res([])
if sql.startswith("INSERT INTO project_activity"):
self.logs.append(params)
return _Res([])
raise AssertionError(sql)
class UpdateTaskConcurrencyTests(unittest.TestCase):
def make(self, row, stale=None):
self.conn = TaskConn(row)
self.borrows = 0
@contextmanager
def connection():
self.borrows += 1
yield self.conn
st = ProjectStore.__new__(ProjectStore)
st._pool = SimpleNamespace(connection=connection)
# 잠그기 전 다른 연결로 읽은 옛 값(예전 코드가 검사에 쓰던 값) — 이제는 결과 표시에만 쓰인다
st.get_task = lambda task_id: {**(stale or self.conn.row), "id": task_id}
return st
BASE = {"id": 7, "project_id": 1, "stage_id": 11, "title": "t", "assignee_email": "", "completed_at": None,
"start_date": "2026-10-10", "due_date": "2026-10-20", "start_time": None, "due_time": None}
def test_date_check_uses_locked_current_row(self):
# A 가 시작일을 10/18 로 이미 바꿨다(잠근 행) — B 의 마감일 10/12 는 옛 값(10/10)으론 통과했지만 이제 거절
st = self.make({**self.BASE, "start_date": "2026-10-18"}, stale=self.BASE)
with self.assertRaises(ValueError):
st.update_task(task_id=7, fields={"due_date": "2026-10-12"})
self.assertEqual(self.conn.updates, [])
st.update_task(task_id=7, fields={"due_date": "2026-10-25"})
self.assertEqual(len(self.conn.updates), 1)
self.assertEqual(self.borrows, 2) # 요청마다 연결 하나(get_task 대역 제외) — 트랜잭션 안에서 다시 빌리지 않는다
def test_second_completion_is_not_a_new_transition(self):
st = self.make({**self.BASE, "completed_at": "2026-10-11T10:00:00+09:00"})
out = st.update_task(task_id=7, fields={"completed": True}, actor="b@test.local")
self.assertFalse(out["_newly_completed"])
self.assertEqual((self.conn.updates, self.conn.logs), ([], []))
def test_stage_move_default_assignee_and_done_in_same_connection(self):
st = self.make({**self.BASE, "stage_id": 12})
asked = []
out = st.update_task(task_id=7, fields={"stage_id": 11}, actor="a@test.local",
assignee_allowed=lambda e: asked.append(e) or True)
self.assertEqual((asked, out["_newly_assigned"], self.borrows), (["dae@test.local"], "dae@test.local", 1))
st = self.make({**self.BASE, "stage_id": 12})
out = st.update_task(task_id=7, fields={"stage_id": 11}, assignee_allowed=lambda e: False)
self.assertIsNone(out["_newly_assigned"]) # 권한을 잃은 기본 담당자는 자동 배정·배정 알림 없음
st = self.make(self.BASE)
out = st.update_task(task_id=7, fields={"stage_id": 12})
self.assertTrue(out["_newly_completed"])
self.assertEqual(len(self.conn.logs), 1)
if __name__ == "__main__":
unittest.main()
+205
View File
@@ -0,0 +1,205 @@
"""관리자 등급(2026-10-12) — 수퍼관리자 > Admin > Pro user > User 별 프로젝트·목표·회의록 권한. DB 없이."""
import importlib
import tempfile
import unittest
from unittest.mock import MagicMock, patch
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.modules.project import access
from app.store import SUPER_ADMIN_EMAIL, UserStore, is_admin
api = importlib.import_module("app.modules.project.router")
SUPER = {"email": SUPER_ADMIN_EMAIL, "role": "admin"}
ADMIN = {"email": "admin@test.local", "role": "admin"}
PRO = {"email": "pro@test.local", "role": "pro"}
USER = {"email": "user@test.local", "role": "user"}
OUTSIDER_PRO = {"email": "pro2@test.local", "role": "pro"} # 프로젝트 1 멤버가 아닌 Pro user
class FakeStore(MagicMock):
"""프로젝트 1 = admin·pro·user 멤버(pro2 는 아님). 나머지 메서드는 MagicMock 이 받아 준다."""
MEMBERS = {1: {"admin@test.local", "pro@test.local", "user@test.local"}}
def is_member(self, project_id, user_email):
return user_email in self.MEMBERS.get(int(project_id), set())
def list_projects(self, include_archived=False, member_email=None):
return [{"id": pid, "parent_id": None} for pid, ms in self.MEMBERS.items()
if member_email is None or member_email in ms]
def get_project(self, project_id):
return {"id": project_id, "name": "P1", "owner_email": "admin@test.local", "created_by": "admin@test.local"}
def get_task(self, task_id):
# 남(admin)이 만든 작업
return {"id": task_id, "project_id": 1, "title": "t", "created_by": "admin@test.local"}
def get_stage(self, stage_id):
return {"id": stage_id, "project_id": 1, "created_by": "admin@test.local"}
def task_link_scope(self, task_ids):
return {}
class RoleHelperTests(unittest.TestCase):
def test_role_of(self):
self.assertEqual(access.role_of(SUPER), "super")
self.assertEqual(access.role_of(ADMIN), "admin")
self.assertEqual(access.role_of(PRO), "pro")
self.assertEqual(access.role_of(USER), "user")
self.assertEqual(access.role_of({"email": "x@test.local", "role": "weird"}), "user")
self.assertEqual(access.role_of(None), "user")
def test_pro_and_admin_flags(self):
self.assertEqual([access.is_pro(u) for u in (SUPER, ADMIN, PRO, USER)], [True, True, True, False])
self.assertEqual([access.is_project_admin(u) for u in (SUPER, ADMIN, PRO, USER)], [True, True, False, False])
# pro 는 프로젝트 모듈 밖(관리자 페이지 등)에서는 관리자가 아니다
self.assertFalse(is_admin(PRO))
def test_can_delete_project_or_section(self):
self.assertTrue(api._can_delete(ADMIN, "someone@test.local"))
self.assertTrue(api._can_delete(SUPER, "someone@test.local"))
self.assertFalse(api._can_delete(PRO, "someone@test.local"))
self.assertTrue(api._can_delete(PRO, "pro@test.local"))
self.assertTrue(api._can_delete(USER, "USER@test.local"))
# 만든 사람 기록이 없는 옛 데이터 — Admin 이상만
self.assertTrue(api._can_delete(ADMIN, ""))
self.assertFalse(api._can_delete(PRO, ""))
self.assertFalse(api._can_delete(USER, None))
def test_role_ctx(self):
self.assertEqual(api._role_ctx(PRO), {"is_admin": False, "pj_pro": True, "pj_admin": False})
self.assertEqual(api._role_ctx(ADMIN), {"is_admin": True, "pj_pro": True, "pj_admin": True})
self.assertEqual(api._role_ctx(USER), {"is_admin": False, "pj_pro": False, "pj_admin": False})
class UserStoreRoleTests(unittest.TestCase):
def setUp(self):
d = tempfile.mkdtemp(prefix="users-")
self.us = UserStore(__import__("pathlib").Path(d) / "users.json")
def test_pro_role_saved_and_validated(self):
rec = self.us.create_user(email="p@test.local", role="pro")
self.assertEqual(rec["role"], "pro")
self.assertFalse(any(rec["modules"].values())) # pro 도 모듈은 기본 꺼짐(user 와 같음)
rec = self.us.update_permissions(email="p@test.local", role="user", modules=None)
self.assertEqual(rec["role"], "user")
with self.assertRaises(ValueError):
self.us.create_user(email="x@test.local", role="super")
with self.assertRaises(PermissionError):
self.us.update_permissions(email=SUPER_ADMIN_EMAIL, role="pro", modules=None)
class RoleApiTests(unittest.TestCase):
def setUp(self):
self.st = FakeStore()
p = patch.object(access, "can_use_module", side_effect=lambda u: bool(u))
p.start()
self.addCleanup(p.stop)
app = FastAPI()
app.include_router(api.router)
app.state.data_dir = tempfile.mkdtemp(prefix="pj-roles-")
self.client = TestClient(app)
def call(self, who, method, url, **kw):
with patch.object(api, "_require_user", return_value=who), patch.object(api, "_db_or_503", return_value=self.st):
return self.client.request(method, url, **kw)
def test_create_project_pro_and_up(self):
self.st.create_project.return_value = {"id": 9, "name": "n"}
self.assertEqual(self.call(USER, "POST", "/project/api/projects", json={"name": "n"}).status_code, 403)
for who in (PRO, ADMIN):
self.assertEqual(self.call(who, "POST", "/project/api/projects", json={"name": "n"}).status_code, 201)
def test_subproject_any_member(self):
self.st.create_project.return_value = {"id": 10, "name": "s"}
r = self.call(USER, "POST", "/project/api/projects/1/subprojects", json={"name": "s"})
self.assertEqual(r.status_code, 201, r.text)
def test_edit_project_pro_member_only(self):
self.st.update_project.return_value = {"id": 1, "name": "x"}
self.assertEqual(self.call(USER, "PUT", "/project/api/projects/1", json={"name": "x"}).status_code, 403)
self.assertEqual(self.call(OUTSIDER_PRO, "PUT", "/project/api/projects/1", json={"name": "x"}).status_code, 403)
self.assertEqual(self.call(PRO, "PUT", "/project/api/projects/1", json={"name": "x"}).status_code, 200)
def test_owner_change_by_pro(self):
self.st.update_project.return_value = {"id": 1}
with patch.object(api, "_check_owner_candidate"):
r = self.call(PRO, "PUT", "/project/api/projects/1", json={"owner_email": "user@test.local"})
self.assertEqual(r.status_code, 200, r.text)
def test_delete_project_admin_any_pro_own(self):
self.st.delete_project.return_value = []
self.assertEqual(self.call(PRO, "DELETE", "/project/api/projects/1").status_code, 403) # admin 이 만든 것
self.assertEqual(self.call(ADMIN, "DELETE", "/project/api/projects/1").status_code, 200)
def test_members_pro_in_own_project(self):
self.st.add_member.return_value = {"user_email": "x@test.local"}
body = {"user_email": "x@test.local"}
self.assertEqual(self.call(USER, "POST", "/project/api/projects/1/members", json=body).status_code, 403)
self.assertEqual(self.call(OUTSIDER_PRO, "POST", "/project/api/projects/1/members", json=body).status_code, 403)
self.assertEqual(self.call(PRO, "POST", "/project/api/projects/1/members", json=body).status_code, 201)
self.assertEqual(self.call(PRO, "DELETE", "/project/api/projects/1/members/x@test.local").status_code, 200)
def test_reorder_pro_and_up(self):
body = {"ordered_ids": [1]}
self.assertEqual(self.call(USER, "PUT", "/project/api/projects/order", json=body).status_code, 403)
self.assertEqual(self.call(PRO, "PUT", "/project/api/projects/order", json=body).status_code, 200)
# Pro user 라도 멤버가 아닌 프로젝트는 순서를 못 바꾼다(검토 2026-10-12)
self.assertEqual(self.call(OUTSIDER_PRO, "PUT", "/project/api/projects/order", json=body).status_code, 403)
def test_section_delete_admin_any_others_creator(self):
self.assertEqual(self.call(PRO, "DELETE", "/project/api/projects/1/stages/5").status_code, 403)
self.assertEqual(self.call(USER, "DELETE", "/project/api/projects/1/stages/5").status_code, 403)
self.assertEqual(self.call(ADMIN, "DELETE", "/project/api/projects/1/stages/5").status_code, 200)
def test_task_delete_any_member(self):
self.st.delete_task.return_value = ([7], None)
r = self.call(USER, "DELETE", "/project/api/tasks/7") # 남이 만든 작업도
self.assertEqual(r.status_code, 200, r.text)
self.assertEqual(self.call(OUTSIDER_PRO, "DELETE", "/project/api/tasks/7").status_code, 403)
def test_comment_edit_passes_pro_flag(self):
self.st.get_comment.return_value = {"id": 3, "task_id": 7, "author_email": "admin@test.local"}
self.st.update_comment.return_value = {"id": 3}
for who, flag in ((PRO, True), (USER, False)):
self.st.update_comment.reset_mock()
with patch.object(api, "_comment_task_access"):
self.call(who, "PUT", "/project/api/comments/3", json={"body": "b"})
self.assertEqual(self.st.update_comment.call_args.kwargs["is_admin"], flag)
def test_workload_summary_pro_only(self):
self.st.list_tasks_for_projects.return_value = []
self.st.list_subtasks_of.return_value = []
self.assertEqual(self.call(USER, "GET", "/project/api/projects/1/subtasks-summary").status_code, 403)
self.assertEqual(self.call(PRO, "GET", "/project/api/projects/1/subtasks-summary").status_code, 200)
def test_trash_restore_pro(self):
self.st.list_trash.return_value = [{"id": 4, "project_id": 1}] # 프로젝트 1 = PRO 가 멤버(list_projects)
self.st.restore_trash.return_value = {"restored": 1}
self.assertEqual(self.call(USER, "POST", "/project/api/trash/4/restore").status_code, 403)
self.assertEqual(self.call(PRO, "POST", "/project/api/trash/4/restore").status_code, 200)
def test_goals_input_pro_and_up(self):
body = {"metric": "sales", "kind": "target", "month": 1, "value": "10"}
self.assertEqual(self.call(USER, "PUT", "/project/api/goals/2026/metrics", json=body).status_code, 403)
self.assertEqual(self.call(PRO, "PUT", "/project/api/goals/2026/metrics", json=body).status_code, 200)
self.assertEqual(self.call(USER, "POST", "/project/api/goals/years", json={"year": 2027}).status_code, 403)
self.assertEqual(self.call(PRO, "POST", "/project/api/goals/years", json={"year": 2027}).status_code, 201)
self.assertEqual(self.call(USER, "DELETE", "/project/api/goals/2027").status_code, 403)
self.assertEqual(self.call(PRO, "DELETE", "/project/api/goals/2027").status_code, 200)
def test_meeting_complete_and_delete_pro(self):
self.st.set_meeting_completed.return_value = {"completed": True}
for url, method, kw in (("/project/api/goals/meetings/2026-10-12/complete", "POST", {"json": {"done": True}}),
("/project/api/goals/meetings/2026-10-12", "DELETE", {})):
self.assertEqual(self.call(USER, method, url, **kw).status_code, 403)
self.assertEqual(self.call(PRO, method, url, **kw).status_code, 200)
if __name__ == "__main__":
unittest.main()