Files
Aislo/M01_MasterData/M01_MasterData_Store_Logic.py
T

268 lines
12 KiB
Python

"""M01 단가산출 기초 저장 — 수식 문서가 정본(PLAN 855 L3 ⓐ · 요구 898).
화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로.
- 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale}
- 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`)
- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장)
- 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`)
화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫.
"""
from __future__ import annotations
import copy
import os
from pathlib import Path
from common_util.common_util_time import kst_today
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
from M01_MasterData.M01_MasterData_Store_Shape import dump, keep_shape
md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm
#: 로직 줄 같이 쓰기 — M02 · B09 가 로직 줄을 더 안 읽게 되면(둘째 박자) 끄고 `mirror` 를 지움
WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0"
OWN = "로직_자체.json"
FIELDS = revise.FIELDS
CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음)
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, list, set]:
"""고침 · 더함 · 지움을 문서 파일 사본에 — (문서 파일 → 내용, 같이 쓰기 편집, 더한 키, 지운 키)."""
plan: dict[str, dict] = {}
edits, 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))
edits.append(("머리", key, doc_store.head_of(rows[at])))
elif op == "add":
if file != OWN:
raise store.StoreError(400, f"새 기초는 {OWN} 에만")
tid = mk.table_id("로직", "자체")
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))
edits.append(("더함", key, {"file": file, "row": head(row), "from": source}))
added.append({"file": file, "key": key})
else:
del rows[at]
gone.add(key)
edits.append(("지움", key, None))
return plan, edits, added, gone
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]
return out + store.cache.labor_errors(None, gone, keys)
def save(parts: list[dict], confirmed: bool = False) -> dict:
"""로직 파일 몫 저장 — {files: [{file, version}], added: [{file, key}], warnings}."""
revise.guard(parts, confirmed)
gone_used = {
k: used
for p in parts
for c in p.get("changes") or []
if c.get("op") == "delete" and (k := str(c.get("key") or ""))
and (used := doc_store.users(k))
}
if gone_used:
raise store.StoreError(409, {"쓰는곳": [x for v in gone_used.values() for x in v]})
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, edits, 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
mirror(edits)
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)
# ── 옛 로직 줄 같이 쓰기 — 로직 JSON 을 쓰는 단 한 자리(둘째 박자에서 지움) ──────────
def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None:
"""문서에 한 고침을 옛 로직 줄에도 — 머리(이름표 · 이름 · 결과단위 · 출처 · 부품 덮음) ·
더함(본뜬 로직 줄 셈 칸 / 빈 셈 칸) · 지움 · 기계 고르기 목록(`picks` = 더함 · 뺌).
검사 없음(문서가 정본) · 스위치 `WRITE` 가 꺼지면 아무것도 안 함."""
if not WRITE or (not edits and not picks):
return
with store._LOCK:
files = store.loaded()[0]
logic = {n: d for n, d in files.items() if d.get("그룹") == "로직"}
where = {str(r.get("키")): n for n, d in logic.items() for r in d.get("줄") or []}
after = {n: {**d, "줄": list(d.get("줄") or [])} for n, d in logic.items()}
touched: set[str] = set()
for op, key, what in edits:
if op == "더함":
name = what["file"]
if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦
after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []}
src = next((r for r in logic.get(where.get(what["from"], ""), {}).get("줄") or []
if str(r.get("키")) == what["from"]), None) # fmt: skip
calc = {k: copy.deepcopy(v) for k, v in (src or CALC).items() if k not in FIELDS}
after[name]["줄"].append(_ordered({**what["row"], **calc, "키": key}))
where[key] = name
elif (name := where.get(key)) is not None:
rows = after[name]["줄"]
at = _at(rows, key)
if at is None:
continue
if op == "지움":
del rows[at]
else:
rows[at] = _headed_row(rows[at], what)
else:
continue
touched.add(name)
if picks:
touched |= _picks(after, *picks)
for name in touched:
_write(name, logic.get(name), after[name])
store.cache.stale(touched)
def _ordered(row: dict) -> dict:
"""새 로직 줄 칸 차례 — `_틀.md` 2장(`mk.ROW_ORDER`) 다음 나머지."""
order = mk.ROW_ORDER["로직"]
return {**{k: row[k] for k in order if k in row}, **{k: v for k, v in row.items() if k not in order}}
def _headed_row(row: dict, head_: dict) -> dict:
"""로직 줄 머리를 문서 머리와 같게 — 있던 칸은 제자리 · 빠진 머리 칸은 뺌 · 새 칸은 끝(옛 [저장]과 같음)."""
out = {k: head_[k] if k in FIELDS else v for k, v in row.items() if k not in FIELDS or k in head_}
return {**out, **{k: v for k, v in head_.items() if k not in out}}
def _picks(after: dict, add: dict, drop: set) -> set[str]:
"""기계경비식 로직 줄 「기계」 고르기 목록에 더함 · 뺌(문서 `선택 목록` 과 같게 · 848-5)."""
touched = set()
for name, data in after.items():
if "건설기계" not in name:
continue
for at, row in enumerate(data["줄"]):
pick = next((i for i in row.get("입력") or [] if i.get("이름") == "기계" and "고르기" in i), None)
if pick is None:
continue
codes = [c for c in pick["고르기"] if str(c) not in drop]
codes += [c for c in add.get(str(row["키"]), []) if c not in codes]
if codes != pick["고르기"]:
new = copy.deepcopy(row)
next(i for i in new["입력"] if i.get("이름") == "기계")["고르기"] = codes
data["줄"][at] = new
touched.add(name)
return touched
def _write(name: str, before: dict | None, after: dict) -> None:
path = store.FOLDER / name
text = None
if before is not None and path.is_file():
text = keep_shape(path.read_bytes().decode("utf-8"), before, after, "줄")
_put(path, (text or dump(after)).encode("utf-8"))