- Store_Logic: WRITE · CALC · mirror · _ordered · _headed_row · _picks · _write 지움(로직 JSON 쓰는 곳 0) - Machine.register 의 mirror 줄 · Store_Save._logic_file · Store_Cache 「!= 로직」 표지 걷음 · labor_errors = 있는 기초 키(수식 문서)만(whole.logic 갈래 지움) - M01 Doc: _row · sync_tags · ensure · built · of_row · make 지움 · 읽기 「층바탕」(빌더 문서) 뺌 · 손고침 = 셈 칸을 고친 적 있는 기초(저장 전 문서와 다르면 붙음 · 한 번 붙으면 남음 · 브레인 정함) - M02 Doc_Sk.base_doc · Doc_Sk_Path 층바탕의 빌더 문서 갈래 지움(그 자리 = 지금 문서) - 화면 LogicRow 셈 칸 · [신규] 빈 셈 칸 · 안 쓰는 꼴 셋 지움 - 시험: 855_l3_doc_only = 옛 로직 파일 놓여도 안 읽고 안 씀 · 848_1 손고침 표지 · 848_10 빌더 층 시험 지움 · 파일만 복사한 프로젝트 층(바탕문서 없음) = 지금 문서를 따라감 · 854_2 복사 = 원본 문서 금액(옛 엔진 대조 뺌) · 848_5 · 855_l1 로직 줄 대조 뺌 · labor_errors 손님 셋 = 있는 키 묶음 - 서버 답 243 건 다름 0 · typecheck 0 · 관련 105 파일(717_2a 원래 실패 · 792_3 엔진 몸 일감 몫 빼고) 통과 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
185 lines
8.2 KiB
Python
185 lines
8.2 KiB
Python
"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898).
|
|
|
|
화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
|
|
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
|
|
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
|
|
- 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 ·
|
|
키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`)
|
|
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) · 로직 JSON 은 없음(855-E L3)
|
|
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import os
|
|
from pathlib import Path
|
|
|
|
from M01_MasterData import M01_MasterData_Doc as doc_store
|
|
from M01_MasterData import M01_MasterData_Store as store
|
|
from M01_MasterData import M01_MasterData_Store_Revise as revise
|
|
|
|
md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
|
|
|
|
OWN = "로직_자체.json"
|
|
FIELDS = revise.FIELDS
|
|
|
|
|
|
def is_logic(file: str) -> bool:
|
|
return file.startswith("로직_") and file.endswith(".json")
|
|
|
|
|
|
def head(row: dict) -> dict:
|
|
"""화면이 보낸 줄에서 쓸 칸 — 키 · 이름표 · 머리."""
|
|
return {k: row[k] for k in FIELDS if k in row}
|
|
|
|
|
|
def _doc_file(file: str) -> Path:
|
|
return doc_store.folder() / ml.file_of(file)
|
|
|
|
|
|
def _rows(data: dict) -> list[dict]:
|
|
return data.setdefault("줄", [])
|
|
|
|
|
|
def _at(rows: list[dict], key: str) -> int | None:
|
|
return next((i for i, d in enumerate(rows) if str(d.get("키")) == key), None)
|
|
|
|
|
|
def _fresh_doc(key: str, row: dict, base: dict | None) -> dict:
|
|
"""새 기초 문서 — 원본 문서 복제(본뜸) 또는 빈 문서(출처 = 결과단위 다음) · 이름표 · 머리 = 받은 줄."""
|
|
if base is None:
|
|
blank = md.blank(key, str(row.get("이름") or ""), str(row.get("결과단위") or "원"))
|
|
items = list(blank.items())
|
|
base = {**dict(items[:5]), "출처": row.get("출처"), **dict(items[5:])}
|
|
else:
|
|
base = {k: v for k, v in copy.deepcopy(base).items() if k != "손고침"}
|
|
base["키"] = key
|
|
return doc_store._headed(base, {**head(row), "키": key})
|
|
|
|
|
|
def _plan(parts: list[dict], book: dict) -> tuple[dict, list, set]:
|
|
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 더한 키, 지운 키)."""
|
|
plan: dict[str, dict] = {}
|
|
added, gone = [], set()
|
|
for part in parts:
|
|
file = str(part.get("file") or "")
|
|
path = _doc_file(file)
|
|
if path.name not in plan:
|
|
plan[path.name] = (
|
|
copy.deepcopy(ml.load_file(path))
|
|
if path.is_file()
|
|
else doc_store._new_file(path.name)
|
|
)
|
|
rows = _rows(plan[path.name])
|
|
for ch in part.get("changes") or []:
|
|
op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row")
|
|
if op not in ("edit", "add", "delete"):
|
|
raise store.StoreError(400, f"모르는 op 「{op}」")
|
|
at = None if op == "add" else _at(rows, key)
|
|
if op != "add" and at is None:
|
|
raise store.StoreError(404, f"{file} · 없는 키 「{key}」")
|
|
if op != "delete" and (
|
|
not isinstance(row, dict) or not str(row.get("이름") or "").strip()
|
|
):
|
|
raise store.StoreError(400, f"{file} · 줄에 「이름」 이 없음")
|
|
if op == "edit":
|
|
if str(row.get("키")) != key:
|
|
raise store.StoreError(400, f"{file} · 키는 바꾸지 않음 「{key}」")
|
|
rows[at] = doc_store._headed(rows[at], head(row))
|
|
elif op == "add":
|
|
where = doc_store.logic_files().get(file) or {"원문": "자체"}
|
|
tid = mk.table_id("로직", store._book(where))
|
|
number = str(row.get("원문번호") or "")
|
|
key = mk.issue(book, tid, store.ledger_label(book, tid, number, row), file)
|
|
source = str(ch.get("from") or "")
|
|
base = doc_store.docs().get(source) if source else None
|
|
rows.append(_fresh_doc(key, row, base))
|
|
added.append({"file": file, "key": key})
|
|
else:
|
|
del rows[at]
|
|
gone.add(key)
|
|
return plan, added, gone
|
|
|
|
|
|
def _combos(have: dict) -> list[str]:
|
|
"""일위대가 조합(실무문서)이 담은 기초가 문서에 없음 — `Store_Cache.combo_errors` 와 같은 글."""
|
|
rows = cm.mcb.rows(store.loaded()[0])
|
|
return [f"{n} · {x}" for n, row in rows for x in store.cache.mb.combo_row(row, have)]
|
|
|
|
|
|
def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]:
|
|
"""문서 검사 — 일위대가 · 사전조합 · 조합이 담은 기초가 빠짐 · 키 겹침 · 대장(저장 전에 있던 흠은 뺌)."""
|
|
have = dict(doc_store.logic_files())
|
|
after = dict(have)
|
|
for name, data in plan.items():
|
|
logic = str(data.get("로직파일") or "") or "로직_" + name.split("_", 1)[1]
|
|
after[logic] = {"그룹": "로직", "줄": data.get("줄") or []}
|
|
keys = {str(d.get("키")) for f in after.values() for d in f["줄"]}
|
|
old = set(cm.duplicate_keys(have, old_book))
|
|
out = [x for x in cm.duplicate_keys(after, book) if x not in old]
|
|
if gone:
|
|
docs = {k: d for k, d in doc_store.docs().items() if k not in gone}
|
|
docs |= {str(d.get("키")): d for data in plan.values() for d in data.get("줄") or []}
|
|
was = set(_combos(doc_store.docs()))
|
|
out += [x for x in _combos(docs) if x not in was]
|
|
mb, whole = store.cache.mb, store.loaded()[1] # 지운 기초를 부르던 문서
|
|
if callers := {k for k, d in docs.items() if mb.calls(d) & gone}:
|
|
was = set(mb.check_docs(doc_store.docs(), callers, whole))
|
|
out += [x for x in mb.check_docs(docs, callers, whole) if x not in was]
|
|
return out + store.cache.labor_errors(keys, gone)
|
|
|
|
|
|
def save(parts: list[dict], confirmed: bool = False) -> dict:
|
|
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
|
|
revise.guard(parts, confirmed)
|
|
with doc_store._LOCK:
|
|
stale = [
|
|
str(p.get("file")) for p in parts
|
|
if doc_store.file_version(str(p.get("file"))) != (p.get("version") or "")
|
|
] # fmt: skip
|
|
if stale:
|
|
raise store.StoreError(409, {"stale": stale})
|
|
book_path = store.FOLDER / mk.BOOK.name
|
|
book = mk.load_book(book_path)
|
|
old_book = {"키": dict(book["키"]), "다음": dict(book["다음"])}
|
|
plan, added, gone = _plan(parts, book)
|
|
mk.finish(book)
|
|
if bad := _errors(plan, gone, old_book, book):
|
|
raise store.StoreError(422, {"errors": bad})
|
|
paths = {n: doc_store.folder() / n for n in plan}
|
|
raw = {n: p.read_bytes() for n, p in paths.items() if p.is_file()}
|
|
book_raw = book_path.read_bytes() if book["다음"] != old_book["다음"] else None
|
|
try:
|
|
if book_raw is not None:
|
|
mk.save_book(book, book_path)
|
|
for name, data in plan.items():
|
|
doc_store.put(paths[name], data)
|
|
except BaseException:
|
|
_undo(paths, raw, book_path, book_raw)
|
|
raise
|
|
files = list(dict.fromkeys(str(p.get("file")) for p in parts))
|
|
return {
|
|
"files": [{"file": f, "version": doc_store.file_version(f)} for f in files],
|
|
"added": added,
|
|
"warnings": [],
|
|
}
|
|
|
|
|
|
def _undo(paths: dict, raw: dict, book_path: Path, book_raw: bytes | None) -> None:
|
|
"""쓰기 중간 실패 — 문서 파일 · 대장을 저장 전 글로(새로 만든 문서 파일은 지움)."""
|
|
for name, path in paths.items():
|
|
if name in raw:
|
|
_put(path, raw[name])
|
|
else:
|
|
path.unlink(missing_ok=True)
|
|
if book_raw is not None:
|
|
_put(book_path, book_raw)
|
|
doc_store._memo.clear()
|
|
|
|
|
|
def _put(path: Path, data: bytes) -> None:
|
|
tmp = path.with_name(f".{path.name}.tmp")
|
|
tmp.write_bytes(data)
|
|
os.replace(tmp, path)
|