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:
+453
-49
@@ -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]
|
||||
|
||||
# ════════════════════════════════════════════════════════════
|
||||
# 직렬화
|
||||
# ════════════════════════════════════════════════════════════
|
||||
|
||||
Reference in New Issue
Block a user