Files
Aislo/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py
T
eomsangdonandClaude Opus 5.5 11e91da39e feat(855-B): 막힘 · 저장 검사를 수식 문서 기준으로 — 2-B3 · 새 master_doc_block
- 새 master_doc_block — 문서 막힘 = 문서 검사 표지 + 단가산출 부름 닫힘 · 넘긴 입력 이름 + 요소 닫힘(요소 · 표 키 · 선택 구멍 펼친 키 · 재료 고르기 후보) · 저장 검사는 문서 사이 순환까지 · 문서 없는 새 줄 = 막힘 아님(지금 그대로)
- M01 /logic blocked · reasons · 목록 막힘(Store_Cache._check · 부름 · 본 요소 지도도 문서에서) · 일위대가 조합 막힘(M01 Store_Combo · M02 Combo_Store = problems_of) = 새 길 · 서버 답 꼴 그대로
- 저장 검사 로직 몫 = 옛 check_logics(좁힌 줄) 먼저 · 깨끗하면 문서 막힘 — 로직 줄은 아직 옛 엔진 길이 씀 · L3 에서 걷음 · 조합 몫 = 문서로
- 자체 기계 등록 · 뺌이 수식 문서 목록에 저장 뒤 들어가는 것을 저장 검사가 미리 봄(Store_Cache.picks · Machine.relist)
- 옛 검사 본체(mf.check_logic · mcb.check_all · check_row)는 그대로 · 쓰지 않게 된 _Watch 만 걷음
- 시험: test_855_block 에 화면 답 = 새 길 · 저장 부름 닫힘 · 순환 · 요소 닫힘 · 넘긴 입력 단언 · test_m01_make 준비 = 수식 문서도 사본(새 로직 문서가 생김) · test_m01_cache 부르는 줄 다시 셈 = 문서 기준으로 고침(목록 = 문서 기준이라 로직 JSON 만 고치면 목록은 안 막힘 — 뜻한 바뀜 · 저장 검사는 옛 check_logics 가 로직 줄을 지킴)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 21:29:58 +09:00

288 lines
12 KiB
Python

"""M02 일위대가 조합 층 저장소(PLAN 27-2a) — 마스터 · 회사 · 개인 세 층 한 길.
층 자리 · 키
마스터 `resources/master_data/일위대가조합.json` · 키 UA(`_키대장.json`)
쓰기는 M01 조합 저장소(`M01_MasterData_Store_Combo` 의 검사 · 대장 그대로)
회사 `storage/{회사}/templates/일위대가조합.json` · 키 `UC{회사}-######`
개인 `storage/{회사}/{사용자}/templates/일위대가조합.json` · 키 `UP{사용자}-######`
회사 · 개인 파일 = 마스터와 같은 머리 · 열 한 벌 + 머리 `다음`(키 장부 · 지운 키는 다시 안 씀).
지금 층 = `store.at(층 폴더)`(`store.root()`) — 키 머리도 그 자리에서 셈 · 권한은 라우터 몫.
목록 `폴더` = [구분] · [구분, 상세구분](읽기만 · 나무 고침 · 붙여넣기 길은 39-2 에서 지움).
"""
from __future__ import annotations
import json
import re
from pathlib import Path
from typing import Any
from common_util.common_util_json import atomic_write_json
from common_util.common_util_time import kst_today
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MasterTemplete_Tree as tree
from M02_MasterTemplete import M02_Template_Layers as layers
mcb = combo_store.mcb
FILE = combo_store.FILE
OWNERS = combo_store.OWNERS
MASTER = mcb.TID # UA
_HEAD = re.compile(r"^U([CP])(\d+)-")
DEPTH = 2 # 구분 · 상세구분
def _m01(fn, *args):
"""M01 막힘은 M02 막힘으로 — 상태 · 까닭 그대로."""
try:
return fn(*args)
except m01.StoreError as e:
raise store.StoreError(e.status, e.detail) from e
# ── 자리 ──────────────────────────────────────────────────────────────
def heads() -> tuple[str, ...]:
"""지금 층이 쓸 수 있는 키 머리 — 마지막이 제 층 것(마스터 UA · 회사 UC · 개인 UP)."""
root = store.root().resolve()
if root == Path(store.FOLDER).resolve():
return (MASTER,)
try:
parts = root.relative_to(layers.storage_root()).parts
except ValueError:
parts = ()
if len(parts) == 2:
return (MASTER, f"UC{parts[0]}-")
if len(parts) == 3:
return (MASTER, f"UC{parts[0]}-", f"UP{parts[1]}-")
raise store.StoreError(400, "일위대가 조합 층 자리를 모름")
def _file(head: str) -> Path | None:
"""키 머리의 조합 파일 — 개인은 사용자 id 로 찾음(회사 폴더를 모름)."""
if head.startswith(MASTER):
return Path(m01.FOLDER) / FILE
got = _HEAD.match(head)
if not got:
return None
if got[1] == "C":
return layers.company_dir(got[2]) / FILE
pattern = f"*/{got[2]}/{layers.TEMPLATES_DIRNAME}/{FILE}"
return next(layers.storage_root().glob(pattern), None)
def _rows_at(path: Path | None) -> list[dict]:
if path is None or not path.is_file():
return []
return json.loads(path.read_bytes()).get("줄") or []
def find(key: str) -> dict[str, Any] | None:
"""어느 층 조합이든 키로 한 줄 — 없으면 None."""
key = str(key or "")
return next((r for r in _rows_at(_file(key)) if str(r.get("키")) == key), None)
def where(key: str) -> tuple[str, str | None] | None:
"""키의 층 · 주인 — ("system", None) · ("company", "7") · ("personal", "7/42") · 모르면 None."""
key = str(key or "")
got, path = _HEAD.match(key), _file(key)
if key.startswith(MASTER) or path is None or not got:
return ("system", None) if key.startswith(MASTER) else None
if got[1] == "C":
return ("company", got[2])
return ("personal", f"{path.parent.parent.parent.name}/{got[2]}") # {회사}/{사용자}/templates
def names() -> dict[str, str]:
"""지금 층이 쓸 수 있는 조합 키 → 이름(마스터 · 회사 · 개인)."""
out: dict[str, str] = {}
for head in heads():
for r in _rows_at(_file(head)):
out[str(r.get("키"))] = str(r.get("이름") or "")
return out
def _load() -> tuple[dict[str, Any], str]:
"""(지금 층 조합 표, 판) — 회사 · 개인 파일이 없으면 빈 표 · 판 빈 글."""
if heads()[-1] == MASTER:
return _m01(combo_store._read)
path = store.root() / FILE
if not path.is_file():
head = {"그룹": mcb.GROUP, "판": str(kst_today().year), "폴더": [], "다음": 1}
return {**head, "줄": []}, ""
raw = path.read_bytes()
return json.loads(raw), store.version_of(raw)
def rows() -> list[dict[str, Any]]:
return _load()[0].get("줄") or []
def _find(doc: dict, key: str) -> dict[str, Any]:
row = next((r for r in doc.get("줄") or [] if str(r.get("키")) == key), None)
if row is None:
raise store.StoreError(404, f"없는 조합 「{key}」")
return row
# ── 폴더(읽기만) ───────────────────────────────────────────────────────
def path_of(row: dict) -> list[str]:
"""조합의 폴더 — [구분] · [구분, 상세구분] · 구분이 없으면 뿌리."""
a, b = (str(row.get(k) or "").strip() for k in ("구분", "상세구분"))
return [a, b] if a and b else [a] if a else []
def folders_of(doc: dict) -> list[list[str]]:
"""폴더 전부 — 적어 둔 것 + 조합 자리 · 부모까지."""
out: list[list[str]] = []
written = [p for p in doc.get("폴더") or [] if isinstance(p, list)]
for path in [*written, *(path_of(r) for r in doc.get("줄") or [])]:
path = [str(x) for x in path][:DEPTH]
for at in range(1, len(path) + 1):
if path[:at] not in out:
out.append(path[:at])
return out
# ── 읽기 ──────────────────────────────────────────────────────────────
def _brief(whole, row: dict) -> dict[str, Any]:
problems = combo_store.problems_of(row)
return {
**{k: row.get(k) for k in mcb.COLS if k != "담은로직"},
"count": len(mcb.items(row)),
"blocked": bool(problems),
"reasons": problems,
}
def listing() -> dict[str, Any]:
"""지금 층 — `{판, 폴더, 줄}` · 줄 = 담은 로직 수 · 막힘 까닭(담은 로직 목록은 빼고)."""
doc, version = _load()
whole = m01.loaded()[1]
줄 = [_brief(whole, r) for r in doc.get("줄") or []]
return {"판": version, "폴더": folders_of(doc), "줄": 줄}
def one(key: str) -> dict[str, Any]:
"""조합 하나 — 담은 로직에 이름 · 단위를 붙여 줌."""
doc, version = _load()
row = _find(doc, key)
whole = m01.loaded()[1]
problems = combo_store.problems_of(row)
brief = combo_store._brief(whole, row)
return {
"판": version,
"combo": row,
"줄": brief,
"blocked": bool(problems),
"reasons": problems,
}
def pills(key: str) -> dict[str, Any]:
return combo_store.combo_pills(_find(_load()[0], key))
# ── 쓰기(회사 · 개인) ──────────────────────────────────────────────────
def _clean(row: Any, key: str, was: dict | None = None) -> dict[str, Any]:
"""서버가 잡는 칸 — 키 · 열 한 벌 · 소유 · 본뜬키는 있는 다른 조합(어느 층이든)."""
if not isinstance(row, dict):
raise store.StoreError(400, "조합 줄이 묶음 아님")
name = row.get("이름")
if not isinstance(name, str) or not name.strip():
raise store.StoreError(400, "조합 줄에 「이름」 이 없거나 글자 아님")
owner = row.get("소유") or (was or {}).get("소유") or OWNERS[0]
if owner not in OWNERS:
raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}")
origin = row.get("본뜬키", (was or {}).get("본뜬키"))
if origin is not None and (origin == key or find(origin) is None):
raise store.StoreError(400, f"본뜬키 「{origin}」 — 비었거나 있는 다른 조합 키여야 함")
one = {k: row.get(k) for k in mcb.COLS}
one.update({"키": key, "이름": name.strip(), "소유": owner, "본뜬키": origin})
one["출처"] = one["출처"] or "자체"
return one
def _name_errors(doc: dict, one: dict) -> list[str]:
name = one["이름"]
errors = [f"이름이 너무 김 — {mcb.MAX_이름}자까지"] if len(name) > mcb.MAX_이름 else []
if any(r.get("키") != one["키"] and str(r.get("이름", "")).strip() == name for r in doc["줄"]):
errors.append(f"「{name}」 이름의 조합이 이미 있음 — 다른 이름으로")
return errors
def _check(doc: dict, one: dict) -> None:
"""이름 길이 · 겹침 · 담은 로직(없는 키 · 두 번 · 빈 조합) — 막히면 422."""
if errors := _name_errors(doc, one) + combo_store.problems_of(one):
raise store.StoreError(422, {"errors": errors})
def _save(doc: dict, version: str) -> str:
path = store.root() / FILE
with store._LOCK:
have = store.version_of(path.read_bytes()) if path.is_file() else ""
if have != (version or ""):
raise store.StoreError(409, {"stale": [FILE], "판": have})
path.parent.mkdir(parents=True, exist_ok=True)
atomic_write_json(path, doc)
return store.version_of(path.read_bytes())
def _users(key: str) -> list[str]:
"""이 층 구조물 조합에서 이 조합을 쓰는 항목 이름."""
if heads()[-1] == MASTER:
return combo_store.combo_users(key)
return [
tree.name_of(tree.path_of(c)) or c["id"]
for c in store._structure_columns()
if c.get("일위대가") == key
]
def _refuse_used(keys: list[str]) -> None:
used = [u for key in keys for u in _users(key)]
if used:
msg = f"구조물 {len(used)} 곳이 쓰는 조합이라 못 지움 — {' · '.join(used)}"
raise store.StoreError(409, {"errors": [msg], "users": used})
def create(row: Any, version: str | None = None) -> dict[str, Any]:
"""새 조합 — 키 = 층 머리 + 「다음」 번호. `version` None = 지금 판(갈라 내기)."""
if heads()[-1] == MASTER:
owner = row.get("소유") if isinstance(row, dict) else None
done = _m01(combo_store.combo_new, row, owner or OWNERS[0])
return {"키": done["key"], "판": done["version"], "combo": done["combo"]}
doc, have = _load()
number = int(doc.get("다음") or 1)
fixed = _clean(row, f"{heads()[-1]}{number:06d}")
_check(doc, fixed)
doc = {**doc, "다음": number + 1, "줄": [*doc["줄"], fixed]}
return {
"키": fixed["키"],
"판": _save(doc, have if version is None else version),
"combo": fixed,
}
def edit(key: str, row: Any, version: str) -> dict[str, Any]:
if heads()[-1] == MASTER:
owner = row.get("소유") if isinstance(row, dict) else ""
done = _m01(combo_store.combo_edit, key, version, row, owner or "")
return {"키": key, "판": done["version"], "combo": done["combo"]}
doc, _ = _load()
fixed = _clean(row, key, _find(doc, key))
_check(doc, fixed)
doc = {**doc, "줄": [fixed if r.get("키") == key else r for r in doc["줄"]]}
return {"키": key, "판": _save(doc, version), "combo": fixed}
def delete(key: str, version: str) -> dict[str, Any]:
"""지우기 — 이 층 구조물 조합이 쓰면 409 + 항목 이름들(지우지 않음)."""
if heads()[-1] == MASTER:
return {"판": _m01(combo_store.combo_delete, key, version)["version"]}
doc, _ = _load()
_find(doc, key)
_refuse_used([key])
return {"판": _save({**doc, "줄": [r for r in doc["줄"] if r.get("키") != key]}, version)}