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>
This commit is contained in:
2026-10-12 11:08:56 +09:00
parent c07a3466a0
commit 89ad338024
29 changed files with 1849 additions and 378 deletions
+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: