feat(project): 연간 목표 엑셀식 칸 병합(끌어 고르기·우클릭 병합/해제) + 월별 주간 회의록

엑셀식 칸 병합 (예전 Shift+클릭·병합 버튼·오른쪽/왼쪽 칸 병합 메뉴 대체)
- 글 칸을 마우스로 끌어(또는 Shift+클릭) 사각형 선택 → 우클릭 "셀 병합 (N줄 × M칸)" / "병합 해제"
- 같은 업무 영역 안 세로(row_span) + 같은 반기 월 칸 가로, 연간·상·하반기 칸은 세로로만
- 걸친 병합은 엑셀처럼 범위를 넓혀 흡수, 글은 왼쪽 위부터 이어 왼쪽 위 칸에, 해제하면 왼쪽 위 칸에 남음
- POST /api/goals/areas/{id}/merge {row_from,row_to,col_from,col_to} (db.merge_goal_rect), router._goal_area_layout(colspan·rowspan)
- 가려진 칸 저장 거절(세로 포함), 병합 안쪽 줄 끼우기 +1 / 가려진 줄 지우기 -1, 세로 병합에 걸린 줄 이동 거절

주간 회의록 (/project/goals/{연도}/meetings/{월}, 목표 표 월 머리 클릭)
- 주(월~일) 탭, 주마다 회의록: 이번주 할 일·목표 금액 | 지난주 할 일·목표·결과·달성률·평가
- 앞선 회의록 줄 이어받기(carry_from), 처음이면 목표 표 업무 영역 + 기본 양식 줄(유통 줄 쇼핑몰 연결 추측)
- 머리: 월 목표·지난주까지 누적·주당 필요 매출(페이싱)·전주 목표/결과/달성률·금주 목표/현재 실적
- 쇼핑몰 연결 줄의 결과·누적·주간 매출은 실적 모듈 performance_store 읽기 전용(없으면 직접 입력)
- 금액 입력 120만·1.5억·3천만·1억2천만, 참석자·결정 사항 메모, 줄 메뉴(추가·순서·쇼핑몰 연결·삭제), 인쇄

마이그레이션 015(project_db): goal_cell_merges.row_span + CHECK 교체, goal_meetings, goal_meeting_items
캐시 버전 20261001c, 테스트(DB 회귀 test_goal_rect_merges·test_goal_meetings)·문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-01 11:46:25 +09:00
parent 614747ffca
commit c9bce7c976
16 changed files with 1966 additions and 198 deletions
+453 -49
View File
@@ -13,6 +13,7 @@
from __future__ import annotations
import logging
import re
import time
from datetime import date, datetime
from datetime import time as dtime
@@ -1919,8 +1920,9 @@ class ProjectStore:
metrics = {"sales": {"target": {1: 12.0, ...}, "actual": {...}}, "roas": {...}}
areas = [{id, name, color, rows: [{id, label, cells: {0: "연간 글", 1: "1월 글", 13: "상반기 글", ...},
merges: {시작월: 칸 수}}]}]
merges: {시작 칸: (가로 칸 수, 세로 줄 수)}}]}]
halves = 마이그레이션 014 적용 여부(상·하반기 글 칸·병합)
rect = 마이그레이션 015 적용 여부(세로 병합·연간/반기 칸 병합·주간 회의록)
"""
with self._pool.connection() as conn:
head = conn.execute(
@@ -1948,8 +1950,9 @@ class ProjectStore:
(year,),
).fetchall()
halves = self._table_exists(conn, "goal_cell_merges")
rect = halves and self._column_exists(conn, "goal_cell_merges", "row_span")
merge_rows = conn.execute(
"SELECT m.row_id, m.start_month, m.span FROM goal_cell_merges m "
"SELECT m.row_id, m.start_month, m.span" + (", m.row_span" if rect else "") + " FROM goal_cell_merges m "
"JOIN goal_rows r ON r.id = m.row_id JOIN goal_areas a ON a.id = r.area_id "
"WHERE a.year = %s",
(year,),
@@ -1962,9 +1965,10 @@ class ProjectStore:
cells: dict[int, dict[int, str]] = {}
for c in cell_rows:
cells.setdefault(int(c["row_id"]), {})[int(c["month"])] = c["body"]
merges: dict[int, dict[int, int]] = {}
merges: dict[int, dict[int, tuple[int, int]]] = {}
for g in merge_rows:
merges.setdefault(int(g["row_id"]), {})[int(g["start_month"])] = int(g["span"])
merges.setdefault(int(g["row_id"]), {})[int(g["start_month"])] = (
int(g["span"]), int(g.get("row_span") or 1))
rows_by_area: dict[int, list[dict[str, Any]]] = {}
for r in row_rows:
rid = int(r["id"])
@@ -1978,7 +1982,7 @@ class ProjectStore:
for a in area_rows
]
return {"year": int(head["year"]), "sales_unit": head["sales_unit"],
"metrics": metrics, "areas": areas, "halves": halves}
"metrics": metrics, "areas": areas, "halves": halves, "rect": rect}
def set_goal_metric(
self, *, year: int, metric: str, kind: str, month: int, value: float | None, updated_by: str = ""
@@ -2069,6 +2073,17 @@ class ProjectStore:
self._move_goal_item("goal_areas", "year", area_id, direction)
def move_goal_row(self, *, row_id: int, direction: int) -> None:
"""줄 순서 바꾸기 — 세로로 병합된 칸에 걸린 줄(자신 또는 바꿀 이웃)은 옮기지 않는다(엑셀처럼 병합을 먼저 해제)."""
with self._pool.connection() as conn:
me = conn.execute("SELECT area_id FROM goal_rows WHERE id = %s", (row_id,)).fetchone()
if me is None:
raise KeyError(row_id)
ids, merges, _ = self._area_geometry(conn, int(me["area_id"]))
i = ids.index(row_id)
j = i + (1 if direction > 0 else -1)
if 0 <= j < len(ids) and any(g["r1"] > g["r0"] and (g["r0"] <= i <= g["r1"] or g["r0"] <= j <= g["r1"])
for g in merges):
raise ValueError("세로로 병합된 칸에 걸린 줄은 옮길 수 없습니다. 병합을 해제한 뒤 옮기세요.")
self._move_goal_item("goal_rows", "area_id", row_id, direction)
def add_goal_row(
@@ -2102,6 +2117,17 @@ class ProjectStore:
(area_id, lb),
).fetchone()["id"])
i = ids.index(ref_row_id) + (1 if place == "below" else 0)
# 세로 병합 안쪽(시작 줄 아래 ~ 마지막 줄)에 끼우면 엑셀처럼 그 병합이 한 줄 늘어난다
if self._table_exists(conn, "goal_cell_merges") and self._column_exists(
conn, "goal_cell_merges", "row_span"):
_, merges, _ = self._area_geometry(conn, area_id)
for g in merges:
if g["r0"] < i <= g["r1"]:
conn.execute(
"UPDATE goal_cell_merges SET row_span = row_span + 1 "
"WHERE row_id = %s AND start_month = %s",
(g["row_id"], g["start"]),
)
ids.insert(i, rid)
for n, x in enumerate(ids):
conn.execute("UPDATE goal_rows SET sort_order = %s WHERE id = %s", (n, x))
@@ -2128,6 +2154,24 @@ class ProjectStore:
).fetchone()["n"]
if n <= 1:
raise ValueError("업무 영역의 마지막 줄은 지울 수 없습니다. 영역을 삭제하세요.")
# 세로 병합에 가려진 줄이면 그 병합이 한 줄 준다(시작 줄을 지우면 병합도 같이 지워진다 — CASCADE)
if self._table_exists(conn, "goal_cell_merges") and self._column_exists(
conn, "goal_cell_merges", "row_span"):
ids, merges, _ = self._area_geometry(conn, int(me["area_id"]))
i = ids.index(row_id)
for g in merges:
if g["r0"] < i <= g["r1"]:
if g["span"] * (g["row_span"] - 1) >= 2:
conn.execute(
"UPDATE goal_cell_merges SET row_span = row_span - 1 "
"WHERE row_id = %s AND start_month = %s",
(g["row_id"], g["start"]),
)
else:
conn.execute(
"DELETE FROM goal_cell_merges WHERE row_id = %s AND start_month = %s",
(g["row_id"], g["start"]),
)
conn.execute("DELETE FROM goal_rows WHERE id = %s", (row_id,))
def set_goal_cell(self, *, row_id: int, month: int, body: str, updated_by: str = "") -> None:
@@ -2136,16 +2180,14 @@ class ProjectStore:
with self._pool.connection() as conn:
if not conn.execute("SELECT 1 FROM goal_rows WHERE id = %s", (row_id,)).fetchone():
raise KeyError(row_id)
if m != store.GOAL_YEAR:
halves = self._table_exists(conn, "goal_cell_merges")
if m > 12 and not halves:
raise store.GoalMigration014Needed()
# 병합된 칸의 가운데·끝 월(글은 병합 시작 월에만 둔다) — 다른 창에서 병합된 뒤의 늦은 저장
if m <= 12 and halves and conn.execute(
"SELECT 1 FROM goal_cell_merges WHERE row_id = %s "
"AND start_month < %s AND start_month + span - 1 >= %s",
(row_id, m, m),
).fetchone():
halves = self._table_exists(conn, "goal_cell_merges")
if m > 12 and not halves:
raise store.GoalMigration014Needed()
if halves:
# 병합에 가려진 칸(글은 왼쪽 위 칸에만 둔다) — 다른 창에서 병합된 뒤의 늦은 저장
area_id = conn.execute("SELECT area_id FROM goal_rows WHERE id = %s", (row_id,)).fetchone()["area_id"]
ids, merges, _ = self._area_geometry(conn, int(area_id))
if self._covered_by(merges, ids.index(row_id), store.GOAL_COL_ORDER.index(m)):
raise ValueError("병합된 칸입니다. 새로고침해 주세요.")
if not text:
conn.execute("DELETE FROM goal_cells WHERE row_id = %s AND month = %s", (row_id, m))
@@ -2157,54 +2199,125 @@ class ProjectStore:
(row_id, m, text, store.norm_str(updated_by, lower=True)),
)
def merge_goal_cells(self, *, row_id: int, start: Any, end: Any, updated_by: str = "") -> tuple[int, int]:
"""업무 영역 줄의 start~end 월 칸을 가로로 합친다 → (시작 월, 칸 수).
# ── 엑셀식 사각형 병합 ─────────────────────────────────────────
@staticmethod
def _column_exists(conn: Any, table: str, column: str) -> bool:
row = conn.execute(
"SELECT 1 FROM information_schema.columns WHERE table_schema = 'public' "
"AND table_name = %s AND column_name = %s",
(table, column),
).fetchone()
return row is not None
걸쳐 있는 기존 병합은 통째로 흡수한다(병합은 서로 겹치지 않고 반기 안이라 범위도 반기 안).
글은 범위 안 칸들의 글을 월 순서대로 줄바꿈으로 이어 시작 월 칸에 두고, 나머지 칸 글은 지운다."""
s, e = store.validate_goal_merge(start, end)
def _area_geometry(self, conn: Any, area_id: int) -> tuple[list[int], list[dict[str, Any]], bool]:
"""업무 영역 하나의 병합 배치 — (줄 id 순서, 병합 목록, 세로 병합(015) 가능 여부).
병합 = {row_id, start, span, row_span, r0, r1(줄 순번), c0, c1(화면 칸 순번)}. 줄 범위는 영역 끝에서 자른다."""
ids = [int(r["id"]) for r in conn.execute(
"SELECT id FROM goal_rows WHERE area_id = %s ORDER BY sort_order, id", (area_id,)
).fetchall()]
if not self._table_exists(conn, "goal_cell_merges"):
return ids, [], False
rect = self._column_exists(conn, "goal_cell_merges", "row_span")
rows = conn.execute(
"SELECT m.row_id, m.start_month, m.span" + (", m.row_span" if rect else "")
+ " FROM goal_cell_merges m JOIN goal_rows r ON r.id = m.row_id WHERE r.area_id = %s",
(area_id,),
).fetchall()
merges = []
for g in rows:
rid, start = int(g["row_id"]), int(g["start_month"])
if rid not in ids or start not in store.GOAL_COL_ORDER:
continue
r0 = ids.index(rid)
span, rs = int(g["span"]), int(g.get("row_span") or 1) if rect else 1
c0 = store.GOAL_COL_ORDER.index(start)
merges.append({"row_id": rid, "start": start, "span": span, "row_span": rs, "r0": r0,
"r1": min(len(ids) - 1, r0 + rs - 1), "c0": c0,
"c1": min(len(store.GOAL_COL_ORDER) - 1, c0 + span - 1)})
return ids, merges, rect
@staticmethod
def _covered_by(merges: list[dict[str, Any]], ri: int, ci: int) -> dict[str, Any] | None:
"""(줄 순번, 칸 순번)을 가리는 병합(시작 칸 자신은 빼고)."""
for g in merges:
if g["r0"] <= ri <= g["r1"] and g["c0"] <= ci <= g["c1"] and (ri, ci) != (g["r0"], g["c0"]):
return g
return None
def merge_goal_rect(
self, *, area_id: int, row_from: Any, row_to: Any, col_from: Any, col_to: Any, updated_by: str = ""
) -> dict[str, int]:
"""업무 영역 칸을 엑셀처럼 사각형으로 합친다 → {row_id(왼쪽 위 줄), start, span, row_span}.
줄은 같은 영역 안 연속된 줄, 칸은 화면 순서(연간·1~6월·상반기·7~12월·하반기) — 가로는 같은 반기 월 칸끼리만.
걸친 기존 병합은 통째로 흡수(엑셀이 선택을 넓히듯). 글은 범위 안 칸들의 글을 왼쪽 위부터 줄·칸 순서대로
줄바꿈으로 이어 왼쪽 위 칸에 두고, 나머지 칸 글은 지운다(글을 잃지 않게)."""
who = store.norm_str(updated_by, lower=True)
try:
rf, rt = int(row_from), int(row_to)
except (TypeError, ValueError):
raise ValueError("병합할 줄이 올바르지 않습니다.")
store.validate_goal_rect_cols(col_from, col_to) # 칸 번호 검사(묶음 검사는 넓힌 뒤 다시)
with self._pool.connection() as conn:
with conn.transaction():
if not self._table_exists(conn, "goal_cell_merges"):
raise store.GoalMigration014Needed()
if not conn.execute(
"SELECT 1 FROM goal_rows WHERE id = %s FOR UPDATE", (row_id,)
).fetchone():
raise KeyError(row_id)
for g in conn.execute(
"SELECT start_month, span FROM goal_cell_merges WHERE row_id = %s", (row_id,)
).fetchall():
gs, ge = int(g["start_month"]), int(g["start_month"]) + int(g["span"]) - 1
if gs <= e and ge >= s:
s, e = min(s, gs), max(e, ge)
bodies = [
str(c["body"]).strip() for c in conn.execute(
"SELECT body FROM goal_cells WHERE row_id = %s AND month BETWEEN %s AND %s "
"ORDER BY month",
(row_id, s, e),
).fetchall()
]
text = store.validate_goal_text("\n".join(b for b in bodies if b))
if not conn.execute("SELECT 1 FROM goal_areas WHERE id = %s FOR UPDATE", (area_id,)).fetchone():
raise KeyError(area_id)
ids, merges, rect = self._area_geometry(conn, area_id)
if rf not in ids or rt not in ids:
raise KeyError(rf if rf not in ids else rt)
r0, r1 = sorted((ids.index(rf), ids.index(rt)))
c0, c1 = sorted((store.GOAL_COL_ORDER.index(int(col_from)), store.GOAL_COL_ORDER.index(int(col_to))))
grown = True
while grown: # 걸친 병합을 통째로 품을 때까지 넓힌다
grown = False
for g in merges:
if g["r0"] <= r1 and g["r1"] >= r0 and g["c0"] <= c1 and g["c1"] >= c0:
n = (min(r0, g["r0"]), max(r1, g["r1"]), min(c0, g["c0"]), max(c1, g["c1"]))
if n != (r0, r1, c0, c1):
r0, r1, c0, c1 = n
grown = True
start, span = store.validate_goal_rect_cols(store.GOAL_COL_ORDER[c0], store.GOAL_COL_ORDER[c1])
row_span = r1 - r0 + 1
if span * row_span < 2:
raise ValueError("두 칸 이상 골라야 병합할 수 있습니다.")
if (row_span > 1 or start in (store.GOAL_YEAR, store.GOAL_H1, store.GOAL_H2)) and not rect:
raise store.GoalMigration015Needed()
rows_in = ids[r0:r1 + 1]
cols_in = list(store.GOAL_COL_ORDER[c0:c1 + 1])
bodies = {(int(c["row_id"]), int(c["month"])): str(c["body"]).strip() for c in conn.execute(
"SELECT row_id, month, body FROM goal_cells WHERE row_id = ANY(%s) AND month = ANY(%s)",
(rows_in, cols_in),
).fetchall()}
text = store.validate_goal_text("\n".join(
bodies[(r, m)] for r in rows_in for m in cols_in if bodies.get((r, m))
))
conn.execute(
"DELETE FROM goal_cell_merges WHERE row_id = %s AND start_month BETWEEN %s AND %s",
(row_id, s, e),
"DELETE FROM goal_cell_merges WHERE row_id = ANY(%s) AND start_month = ANY(%s)",
(rows_in, cols_in),
)
conn.execute(
"DELETE FROM goal_cells WHERE row_id = %s AND month BETWEEN %s AND %s",
(row_id, s, e),
"DELETE FROM goal_cells WHERE row_id = ANY(%s) AND month = ANY(%s)", (rows_in, cols_in),
)
anchor = rows_in[0]
if text:
conn.execute(
"INSERT INTO goal_cells (row_id, month, body, updated_by) VALUES (%s,%s,%s,%s)",
(row_id, s, text, who),
(anchor, start, text, who),
)
conn.execute(
"INSERT INTO goal_cell_merges (row_id, start_month, span, updated_by) "
"VALUES (%s, %s, %s, %s)",
(row_id, s, e - s + 1, who),
)
return s, e - s + 1
if rect:
conn.execute(
"INSERT INTO goal_cell_merges (row_id, start_month, span, row_span, updated_by) "
"VALUES (%s, %s, %s, %s, %s)",
(anchor, start, span, row_span, who),
)
else:
conn.execute(
"INSERT INTO goal_cell_merges (row_id, start_month, span, updated_by) VALUES (%s, %s, %s, %s)",
(anchor, start, span, who),
)
return {"row_id": anchor, "start": start, "span": span, "row_span": row_span}
def unmerge_goal_cells(self, *, row_id: int, start: int) -> None:
"""병합 해제 — 글은 시작 월 칸에 그대로 남는다."""
@@ -2218,6 +2331,297 @@ class ProjectStore:
if row is None:
raise KeyError(row_id)
# ════════════════════════════════════════════════════════════
# 주간 회의록 (마이그레이션 015) — 목표 표 월 머리 → 그 달 주차별 회의록
# ════════════════════════════════════════════════════════════
_MEETING_ITEM_COLS = ("id, week_start, section, section_color, label, content, target_amount, result_amount, "
"status, marketplace_code, carry_from, sort_order")
def meetings_enabled(self) -> bool:
with self._pool.connection() as conn:
return self._table_exists(conn, "goal_meetings")
def _require_meetings(self, conn: Any) -> None:
if not self._table_exists(conn, "goal_meetings"):
raise store.GoalMigration015Needed()
@staticmethod
def _meeting_item(r: dict[str, Any]) -> dict[str, Any]:
out = dict(r)
out["id"] = int(out["id"])
out["week_start"] = out["week_start"].isoformat()
for k in ("target_amount", "result_amount", "carry_from"):
out[k] = int(out[k]) if out.get(k) is not None else None
return out
def meeting_weeks(self, *, start: date, end: date) -> list[str]:
"""기간 안에 회의록이 있는 주(월요일) 목록."""
with self._pool.connection() as conn:
if not self._table_exists(conn, "goal_meetings"):
return []
rows = conn.execute(
"SELECT week_start FROM goal_meetings WHERE week_start BETWEEN %s AND %s ORDER BY week_start",
(start, end),
).fetchall()
return [r["week_start"].isoformat() for r in rows]
def get_meeting(self, *, week_start: date) -> dict[str, Any] | None:
"""한 주 회의록 — 머리(금주 목표·참석자·메모) + 줄(전주 줄 prev 포함). 없으면 None.
prev_meeting = 이 회의록보다 앞선 가장 가까운 회의록의 머리(전주 목표)."""
with self._pool.connection() as conn:
self._require_meetings(conn)
head = conn.execute(
"SELECT week_start, week_target, attendees, notes, updated_by, updated_at "
"FROM goal_meetings WHERE week_start = %s", (week_start,),
).fetchone()
if head is None:
return None
items = conn.execute(
f"SELECT {self._MEETING_ITEM_COLS} FROM goal_meeting_items WHERE week_start = %s "
"ORDER BY sort_order, id", (week_start,),
).fetchall()
prev_ids = [int(r["carry_from"]) for r in items if r["carry_from"] is not None]
prevs = {int(r["id"]): self._meeting_item(r) for r in conn.execute(
f"SELECT {self._MEETING_ITEM_COLS} FROM goal_meeting_items WHERE id = ANY(%s)", (prev_ids,),
).fetchall()} if prev_ids else {}
prev_head = conn.execute(
"SELECT week_start, week_target FROM goal_meetings WHERE week_start < %s "
"ORDER BY week_start DESC LIMIT 1", (week_start,),
).fetchone()
out_items = []
for r in items:
it = self._meeting_item(r)
it["prev"] = prevs.get(it["carry_from"]) if it["carry_from"] is not None else None
out_items.append(it)
return {
"week_start": head["week_start"].isoformat(),
"week_target": int(head["week_target"]) if head["week_target"] is not None else None,
"attendees": head["attendees"], "notes": head["notes"], "updated_by": head["updated_by"],
"updated_at": head["updated_at"].astimezone(KST).isoformat(timespec="minutes") if head["updated_at"] else "",
"items": out_items,
"prev_meeting": {"week_start": prev_head["week_start"].isoformat(),
"week_target": int(prev_head["week_target"]) if prev_head["week_target"] is not None
else None} if prev_head else None,
}
def create_meeting(self, *, week_start: date, sections: list[tuple[str, str]], created_by: str = "") -> bool:
"""회의록 만들기 — 이미 있으면 False. 앞선 가장 가까운 회의록이 있으면 그 줄(구역·이름·쇼핑몰 연결·순서)을
글 없이 이어받고(carry_from = 그 줄 → 이번 회의에서 지난주 할 일·목표·결과를 나란히 리뷰), 없으면 sections
(목표 표 업무 영역 이름·색)마다 기본 양식 줄(store.MEETING_TEMPLATE)로 시작한다."""
ws = store.validate_week_start(week_start)
who = store.norm_str(created_by, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
self._require_meetings(conn)
ins = conn.execute(
"INSERT INTO goal_meetings (week_start, created_by, updated_by) VALUES (%s, %s, %s) "
"ON CONFLICT (week_start) DO NOTHING RETURNING week_start",
(ws, who, who),
).fetchone()
if ins is None:
return False
prev = conn.execute(
"SELECT week_start FROM goal_meetings WHERE week_start < %s ORDER BY week_start DESC LIMIT 1",
(ws,),
).fetchone()
prev_items = conn.execute(
"SELECT id, section, section_color, label, marketplace_code, sort_order FROM goal_meeting_items "
"WHERE week_start = %s ORDER BY sort_order, id", (prev["week_start"],),
).fetchall() if prev else []
if prev_items:
for n, r in enumerate(prev_items):
conn.execute(
"INSERT INTO goal_meeting_items (week_start, section, section_color, label, "
"marketplace_code, carry_from, sort_order, updated_by) VALUES (%s,%s,%s,%s,%s,%s,%s,%s)",
(ws, r["section"], r["section_color"], r["label"], r["marketplace_code"], r["id"], n, who),
)
else:
n = 0
for name, color in sections or [(k, "") for k in store.MEETING_TEMPLATE]:
for label in store.MEETING_TEMPLATE.get(name, ("",)):
conn.execute(
"INSERT INTO goal_meeting_items (week_start, section, section_color, label, "
"marketplace_code, sort_order, updated_by) VALUES (%s,%s,%s,%s,%s,%s,%s)",
(ws, name, color, label, store.guess_meeting_market(name, label), n, who),
)
n += 1
return True
def delete_meeting(self, *, week_start: date) -> None:
with self._pool.connection() as conn:
self._require_meetings(conn)
row = conn.execute(
"DELETE FROM goal_meetings WHERE week_start = %s RETURNING week_start", (week_start,)
).fetchone()
if row is None:
raise KeyError(str(week_start))
def update_meeting(self, *, week_start: date, fields: dict[str, Any], updated_by: str = "") -> None:
"""머리 칸 — week_target(금주 목표 매출, 원) · attendees(참석자) · notes(결정 사항·메모)."""
sets: list[str] = []
params: list[Any] = []
if "week_target" in fields:
v = store.validate_meeting_amount(fields["week_target"])
if v is not None and v < 0:
raise ValueError("금주 목표는 0 이상이어야 합니다.")
sets.append("week_target = %s")
params.append(v)
if "attendees" in fields:
sets.append("attendees = %s")
params.append(store.validate_meeting_text(fields["attendees"], limit=500, what="참석자"))
if "notes" in fields:
sets.append("notes = %s")
params.append(store.validate_meeting_text(fields["notes"], what="메모"))
if not sets:
return
with self._pool.connection() as conn:
self._require_meetings(conn)
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))
def add_meeting_item(
self, *, week_start: date, section: str, section_color: str = "", label: str = "",
ref_item_id: int | None = None, place: str = "below", updated_by: str = "",
) -> int:
"""줄 추가 — 기준 줄 위/아래(같은 구역), 없으면 그 구역 끝(구역이 없으면 맨 끝 = 새 구역)."""
sec = store.norm_str(section)
if not sec or len(sec) > store.MEETING_LABEL_MAX:
raise ValueError("구역 이름을 입력하세요(50자 이하).")
lb = store.validate_meeting_text(label, limit=store.MEETING_LABEL_MAX, what="줄 이름")
if place not in ("above", "below"):
raise ValueError("place 는 above 또는 below 입니다.")
with self._pool.connection() as conn:
with conn.transaction():
self._require_meetings(conn)
if not conn.execute(
"SELECT 1 FROM goal_meetings WHERE week_start = %s FOR UPDATE", (week_start,)
).fetchone():
raise KeyError(str(week_start))
rows = conn.execute(
"SELECT id, section, section_color FROM goal_meeting_items WHERE week_start = %s "
"ORDER BY sort_order, id", (week_start,),
).fetchall()
ids = [int(r["id"]) for r in rows]
color = store.norm_str(section_color) or next(
(r["section_color"] for r in rows if r["section"] == sec), "")
if ref_item_id is not None:
if ref_item_id not in ids:
raise KeyError(ref_item_id)
i = ids.index(ref_item_id) + (1 if place == "below" else 0)
else:
same = [n for n, r in enumerate(rows) if r["section"] == sec]
i = same[-1] + 1 if same else len(ids)
new_id = int(conn.execute(
"INSERT INTO goal_meeting_items (week_start, section, section_color, label, marketplace_code, "
"sort_order, updated_by) VALUES (%s,%s,%s,%s,%s,0,%s) RETURNING id",
(week_start, sec, color, lb, store.guess_meeting_market(sec, lb),
store.norm_str(updated_by, lower=True)),
).fetchone()["id"])
ids.insert(i, new_id)
for n, x in enumerate(ids):
conn.execute("UPDATE goal_meeting_items SET sort_order = %s WHERE id = %s", (n, x))
return new_id
def update_meeting_item(self, *, item_id: int, fields: dict[str, Any], updated_by: str = "") -> dict[str, Any]:
"""줄 칸 — label · content(이번주 할 일) · target_amount · result_amount(그 주 결과, 원) · status(평가) ·
marketplace_code(실적 쇼핑몰 연결 — 결과 자동). 저장된 줄을 돌려준다."""
sets: list[str] = []
params: list[Any] = []
if "label" in fields:
sets.append("label = %s")
params.append(store.validate_meeting_text(fields["label"], limit=store.MEETING_LABEL_MAX, what="줄 이름"))
if "content" in fields:
sets.append("content = %s")
params.append(store.validate_meeting_text(fields["content"]))
for k in ("target_amount", "result_amount"):
if k in fields:
v = store.validate_meeting_amount(fields[k])
if k == "target_amount" and v is not None and v < 0:
raise ValueError("목표 금액은 0 이상이어야 합니다.")
sets.append(f"{k} = %s")
params.append(v)
if "status" in fields:
sets.append("status = %s")
params.append(store.validate_meeting_status(fields["status"]))
if "marketplace_code" in fields:
code = store.norm_str(fields["marketplace_code"], lower=True)
if len(code) > 30 or not re.fullmatch(r"[a-z0-9_]*", code):
raise ValueError("쇼핑몰 코드가 올바르지 않습니다.")
sets.append("marketplace_code = %s")
params.append(code)
with self._pool.connection() as conn:
self._require_meetings(conn)
if sets:
row = conn.execute(
f"UPDATE goal_meeting_items SET {', '.join(sets)}, updated_by = %s, updated_at = now() "
f"WHERE id = %s RETURNING {self._MEETING_ITEM_COLS}",
(*params, store.norm_str(updated_by, lower=True), item_id),
).fetchone()
else:
row = conn.execute(
f"SELECT {self._MEETING_ITEM_COLS} FROM goal_meeting_items WHERE id = %s", (item_id,),
).fetchone()
if row is None:
raise KeyError(item_id)
return self._meeting_item(row)
def delete_meeting_item(self, *, item_id: int) -> None:
with self._pool.connection() as conn:
self._require_meetings(conn)
row = conn.execute("DELETE FROM goal_meeting_items WHERE id = %s RETURNING id", (item_id,)).fetchone()
if row is None:
raise KeyError(item_id)
def move_meeting_item(self, *, item_id: int, direction: int) -> None:
"""같은 구역 안에서 한 칸 위/아래."""
with self._pool.connection() as conn:
with conn.transaction():
self._require_meetings(conn)
me = conn.execute(
"SELECT week_start, section FROM goal_meeting_items WHERE id = %s", (item_id,)
).fetchone()
if me is None:
raise KeyError(item_id)
rows = conn.execute(
"SELECT id, section FROM goal_meeting_items WHERE week_start = %s ORDER BY sort_order, id "
"FOR UPDATE", (me["week_start"],),
).fetchall()
ids = [int(r["id"]) for r in rows]
i = ids.index(item_id)
j = i + (1 if direction > 0 else -1)
if not 0 <= j < len(ids) or rows[j]["section"] != me["section"]:
return
ids[i], ids[j] = ids[j], ids[i]
for n, x in enumerate(ids):
conn.execute("UPDATE goal_meeting_items SET sort_order = %s WHERE id = %s", (n, x))
def goal_month_targets(self, *, year: int, month: int) -> dict[str, Any]:
"""회의록 머리 — 그 달 매출 목표·실적, 로아스 목표(목표 표 숫자), 매출 단위. 목표 표가 없으면 빈 값."""
with self._pool.connection() as conn:
if not self._table_exists(conn, "goal_years"):
return {"sales_unit": "", "sales_target": None, "sales_actual": None, "roas_target": None}
head = conn.execute("SELECT sales_unit FROM goal_years WHERE year = %s", (year,)).fetchone()
vals = {(r["metric"], r["kind"]): float(r["value"]) for r in conn.execute(
"SELECT metric, kind, value FROM goal_metrics WHERE year = %s AND month = %s", (year, month),
).fetchall()}
return {"sales_unit": head["sales_unit"] if head else "", "sales_target": vals.get(("sales", "target")),
"sales_actual": vals.get(("sales", "actual")), "roas_target": vals.get(("roas", "target"))}
def goal_area_sections(self, *, year: int) -> list[tuple[str, str]]:
"""그 해 목표 표의 업무 영역(이름, 색) — 첫 회의록 구역. 없으면 빈 목록(기본 양식 구역)."""
with self._pool.connection() as conn:
if not self._table_exists(conn, "goal_areas"):
return []
rows = conn.execute(
"SELECT name, color FROM goal_areas WHERE year = %s ORDER BY sort_order, id", (year,)
).fetchall()
return [(r["name"], r["color"]) for r in rows]
# ════════════════════════════════════════════════════════════
# 직렬화
# ════════════════════════════════════════════════════════════