From 7e6190f8d36139b53bdfd13d48b3726f3a28dfd1 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:37:53 +0900 Subject: [PATCH 1/2] =?UTF-8?q?refactor(855-E=20L3=E2=93=90):=20M01=20?= =?UTF-8?q?=EA=B8=B0=EC=B4=88=20=EC=A0=80=EC=9E=A5=20=C2=B7=20=EA=B2=80?= =?UTF-8?q?=EC=82=AC=20=C2=B7=20=EB=A7=89=ED=9E=98=20=EC=84=B8=EA=B8=B0=20?= =?UTF-8?q?=3D=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20=EA=B8=B0?= =?UTF-8?q?=EC=A4=80=20=C2=B7=20=EB=A1=9C=EC=A7=81=20=EC=A4=84=20=EC=93=B0?= =?UTF-8?q?=EA=B8=B0=20=3D=20Store=5FLogic.mirror=20=ED=95=9C=20=EC=9E=90?= =?UTF-8?q?=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 앞 세션 auto 커밋 cce57c298(Store_Logic 새 길 · /logic 답 머리만 · 판 = 문서 파일 지문 · 개정 = 문서 머리 대조 · 별칭 · 기계 등록 · [신규] · [삭제])에 이어 - Store_Cache: 막힘 세기(blocks · counted)를 문서 파일마다 · 저장 검사 logic_errors = 키 겹침 · 대장(요소 + 문서 키) · 연결 · 문서 막힘(check_logics 로직 줄 검사 걷음) · _docs_of = 문서 전부 · narrow 로직 갈래 걷음 · check_saved(부름 0) 지움 - Store_Save: 기초(로직 파일) 받지 않음(400) · gone · labor_errors(whole) 갈래 걷음 - Store_Logic: 정본 파일에도 새 기초(그 파일 표 키 — 옛 /save 와 같음) · 지움 검사에 조합 · 지운 기초를 부르던 문서 더함(옛 422 그대로) · 쓰는 곳 409 는 Doc.remove 로(옛 자리) - 시험(옛 /save 로 로직 줄 셈 칸 고침 · /logic 답 셈 칸을 붙든 것 = 죽은 길): 새 test_855_l3_doc_only(로직 파일 없음 + 같이 쓰기 끔 = 켬과 답 같음 · 목록 · 상세 · 저장 · 개정 409 · 판 409 · 별칭 · 신규 · 복사 · 삭제 · 기계 등록) · test_m01_cache 셈 칸 /save 검사 셋 · test_794_1 식 고침 /save 422 걷음(셈 칸 고침 = 문서 저장 몫 · /save 는 머리만 씀) · test_m01_make 「시험 계산에 돈다」 → 빈 문서로 열림 · test_m01_api · test_m01_text 옛 셈 길 시험은 로직 줄 사본에서 읽음 · test_854_2_m01_key_book 대장 끊김 = 인력 줄 + 기초 문서 쓰기 · test_794_1b · test_804_7 판 = 문서 파일 · test_802_3 문서 없는 키 = 404(빈 문서 안 지음) · test_826_2 좁힌 검사 = 판정만 견줌(기초 흠 글이 문서 꼴) · 로직 갈래 셋 뺌 · test_m01_copy 옛 시트 길 걷고 master_copy 왕복만 · test_854_2_m01_copy_doc 식 복사 → 기본정보 고친 복사 · test_713_1 · test_796_1 row_print 줄 뺌(row_print 지움) Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Doc.py | 9 +- M01_MasterData/M01_MasterData_Store_Cache.py | 100 +++----- M01_MasterData/M01_MasterData_Store_Logic.py | 66 +++-- M01_MasterData/M01_MasterData_Store_Make.py | 17 +- M01_MasterData/M01_MasterData_Store_Revise.py | 7 +- M01_MasterData/M01_MasterData_Store_Save.py | 25 +- resources/tester/test_713_1_revise.py | 9 +- resources/tester/test_794_1_m01_sheet.py | 53 +--- resources/tester/test_794_1b_flow_gone.py | 6 +- resources/tester/test_796_1_formula_model.py | 2 - resources/tester/test_802_3_doc_screen.py | 11 +- resources/tester/test_804_7_line_stack_fix.py | 6 +- resources/tester/test_826_2_machine_files.py | 47 +--- resources/tester/test_854_2_m01_copy_doc.py | 16 +- resources/tester/test_854_2_m01_key_book.py | 66 ++--- resources/tester/test_855_l3_doc_only.py | 150 +++++++++++ resources/tester/test_m01_api.py | 11 +- resources/tester/test_m01_cache.py | 65 +---- resources/tester/test_m01_copy.py | 241 +----------------- resources/tester/test_m01_make.py | 11 +- resources/tester/test_m01_text.py | 11 +- 21 files changed, 368 insertions(+), 561 deletions(-) create mode 100644 resources/tester/test_855_l3_doc_only.py diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index eec60ecf8..807cffc72 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -422,8 +422,13 @@ def drop(key: str) -> None: def remove(key: str, file: str, version: str, confirmed: bool) -> dict: - """로직 지우기 — 기초 저장 길(`Store_Logic` — 쓰는 곳 409 · 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" - from M01_MasterData import M01_MasterData_Store_Logic as logic_store # 그 파일이 이 파일을 부름 — 늦게 + """로직 지우기 — 쓰는 곳 있으면 409 {쓰는곳} · 기초 저장 길(`Store_Logic` — 개정 확인 · 판 · 검사 · 문서 지움 · 같이 쓰기).""" + from M01_MasterData import ( + M01_MasterData_Store_Logic as logic_store, + ) # 그 파일이 이 파일을 부름 — 늦게 + used = users(key) + if used: + raise store.StoreError(409, {"쓰는곳": used}) part = {"file": file, "version": version, "changes": [{"op": "delete", "key": key}]} return logic_store.save([part], confirmed) diff --git a/M01_MasterData/M01_MasterData_Store_Cache.py b/M01_MasterData/M01_MasterData_Store_Cache.py index 9af34c9dc..b6177a66b 100644 --- a/M01_MasterData/M01_MasterData_Store_Cache.py +++ b/M01_MasterData/M01_MasterData_Store_Cache.py @@ -67,17 +67,20 @@ def _stamps(folder: Path) -> dict[str, tuple]: return out -def _logic_files(files: dict[str, dict]): - for name, data in files.items(): - if data.get("그룹") == "로직": - yield name, data +def _doc_store(): + from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게 + + return doc_store def docs() -> dict[str, dict]: """저장 수식 문서 전부 {키: 문서}(`M01_MasterData_Doc.docs` · 파일 시각이 같으면 같은 묶음).""" - from M01_MasterData import M01_MasterData_Doc as doc_store # Doc 이 Store 를 부름 — 늦게 + return _doc_store().docs() - return doc_store.docs() + +def _logic_files(): + """단가산출 기초 = 수식 문서 파일(옛 로직 파일 이름 · `Doc.logic_files` · 855 L3 ⓐ).""" + return _doc_store().logic_files().items() def reasons(key: str, whole) -> list[str]: @@ -169,8 +172,8 @@ def loaded(folder: Path) -> tuple[dict[str, dict], object]: def blocks(folder: Path) -> dict[str, list[str]]: - """로직 키마다 막힘 까닭 — 미리 세어 둔 값. 요소 파일이 바뀌면 모든 로직을, - 로직 파일은 바뀐 그 파일과 그 로직을 부르던 줄만 다시 셈.""" + """로직 키마다 막힘 까닭 — 미리 세어 둔 값(수식 문서 파일마다). 요소 파일이 바뀌면 흔들린 자리를 보던 + 기초만 · 수식 문서가 바뀌면 통째로 다시 셈.""" with _FRESH: files, whole = loaded(folder) stamps = _INDEX["자국"] @@ -192,28 +195,16 @@ def blocks(folder: Path) -> dict[str, list[str]]: _BASE.clear() _BASE.update(base) _MARKED.clear() - moved, fresh = set(), set() # 바뀐 로직 파일의 키(옛것 · 새것) - names = {name for name, _ in _logic_files(files)} - for gone in [name for name in _BLOCK if name not in names]: # 파일째 사라진 것 - moved |= set(_BLOCK.pop(gone)[1]) - for name, data in _logic_files(files): - if _BLOCK.get(name, (None,))[0] == stamps[name]: - continue - got = {str(r.get("키")): _check(whole, r) for r in data.get("줄") or []} - moved |= set(_BLOCK.get(name, (None, {}))[1]) | set(got) - _BLOCK[name] = (stamps[name], got) - fresh.add(name) - for name, data in _logic_files(files): # 그 로직을 부르던 줄 · 바뀐 요소를 보던 줄 - if name in fresh: + for ( + name, + data, + ) in _logic_files(): # 문서가 그대로면 세어 둔 것 · 바뀐 요소를 보던 기초만 다시 + if name not in _BLOCK: + _BLOCK[name] = (None, {str(r.get("키")): _check(whole, r) for r in data["줄"]}) continue got = _BLOCK[name][1] - rows = {str(r.get("키")): r for r in data.get("줄") or []} - shaken = [ - k - for k, (_, calls, seen) in got.items() - if calls & moved or (marks and seen & marks) - ] - for key in shaken: + rows = {str(r.get("키")): r for r in data["줄"]} + for key in [k for k, (_, _c, seen) in got.items() if marks and seen & marks]: got[key] = _check(whole, rows[key]) return {key: why for _, got in _BLOCK.values() for key, (why, *_) in got.items()} @@ -230,47 +221,28 @@ def _rows_of(data: dict) -> list: def narrow(folder: Path, batch: list[dict], before: dict, after: dict): - """(검사할 로직 키, 안 보는 줄이 부르는 키, 요소도 고쳤는지) — 저장이 흔드는 줄만. + """(검사할 로직 키, 로직마다 부르는 키, 흔들린 자리) — 저장이 흔드는 줄만. - 로직 줄은 고친 줄과 **그 줄을 부르던 줄** · 요소·표 줄은 그 줄을 **보던 로직** - (키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔 지도 · 855 2-B3 부터 수식 문서 연결). + 요소·표 줄은 그 줄을 **보던 기초**(키 · 「ID:원문번호」 · 자재품목은 묶음 통째 — `_check` 가 적어 둔 + 수식 문서 연결 지도) · 기초(로직) 고침은 이 길로 안 옴(`Store_Logic` · 855 L3 ⓐ). """ counts = counted(folder) calls = {key: got[1] for key, got in counts.items()} - touched, gone, marks = set(), set(), set() + marks = set() for part in batch: name = part["file"] was, now = ({str(r.get("키")): r for r in _rows_of(side[name])} for side in (before, after)) keys = (set(now) - set(was)) | { str(c.get("key")) for c in part.get("changes") or [] if c.get("op") != "add" } - if after[name].get("그룹") == "로직": - touched |= keys - gone |= set(was) - set(now) - continue for key in keys | (set(was) - set(now)): # 지운 줄도 — 가리키던 자리가 끊김 marks |= {key, "#" + key[:2]} for side in (was, now): number = (side.get(key) or {}).get("원문번호") if number: marks.add(f"{key[:2]}:{number}") - only = touched | {key for key, called in calls.items() if called & touched} - only |= {key for key, got in counts.items() if got[2] & marks} - return only, {key: called for key, called in calls.items() if key not in gone}, marks - - -def check_saved(files: dict, changed: list[str], book: dict, narrowed=None) -> list[str]: - """저장 전 검사(M01) — 고친 파일의 틀 + 로직의 변수 · 키 + 조합. - - `files` = 폴더 전부(고친 뒤) · `book` = 키 대장 · `narrowed` = `narrow` 가 준 좁힘 - (None 이면 전부 검사 — 마스터 전체 검사는 `check_master` 몫). - """ - whole = cm.mf.Master(files) - out = [x for name in changed for x in cm.check_form(name, files[name])] - out += logic_errors(files, whole, book, narrowed and narrowed[:2]) - if narrowed and narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로) - out += cm.check_links(whole) - return out + combo_errors(files) + labor_errors(whole) + only = {key for key, got in counts.items() if got[2] & marks} + return only, calls, marks _PICKS: contextvars.ContextVar[tuple | None] = contextvars.ContextVar("m01_picks", default=None) @@ -286,11 +258,9 @@ def picks(add: dict, drop: set): _PICKS.reset(token) -def _docs_of(files: dict) -> dict[str, dict]: - """`files` 에 로직 줄이 있는 키의 수식 문서만 — 지운 로직은 문서가 아직 있어도 없는 것으로 · - 저장 중 기계 목록 고침(`picks`)은 사본에 얹음.""" - keys = {str(r.get("키")) for _, data in _logic_files(files) for r in data.get("줄") or []} - out = {k: d for k, d in docs().items() if k in keys} +def _docs_of() -> dict[str, dict]: + """수식 문서 전부(기초 정본 · 855 L3 ⓐ) — 저장 중 기계 목록 고침(`picks`)은 사본에 얹음.""" + out = dict(docs()) if pending := _PICKS.get(): from M01_MasterData import ( M01_MasterData_Machine as machine, @@ -304,17 +274,17 @@ def _docs_of(files: dict) -> dict[str, dict]: def logic_errors(files: dict, whole, book: dict | None, narrow=None) -> list[str]: - """저장 검사의 로직 몫 — 옛 로직 줄 검사(`check_master.check_logics` · 좁힌 줄 · 키 겹침 · 대장 · - 연결)가 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 문서 없는 새 줄은 안 봄 · - 요소 닫힘 · 문서 사이 순환) — 같은 흠을 두 번 안 적음. - ponytail: 로직 줄 몫 = 옛 `check_logic` 남음(로직 JSON 이 아직 옛 엔진 길에 쓰임) · L3 에서 걷음.""" - out = cm.check_logics(files, whole, book, narrow) - return out or mb.check_docs(_docs_of(files), narrow[0] if narrow else None, whole) + """저장 검사의 기초 몫(855 L3 ⓐ — 수식 문서가 정본) — 키 겹침 · 대장(요소 파일 + 문서 키) · + 좁힘 없으면 연결 · 준용이 먼저 · 그것이 깨끗하면 수식 문서 막힘(`narrow` 를 주면 그 키만 · 요소 닫힘 · + 문서 사이 순환) — 같은 흠을 두 번 안 적음.""" + view = {n: d for n, d in files.items() if d.get("그룹") != "로직"} | dict(_logic_files()) + out = cm.duplicate_keys(view, book) + ([] if narrow else cm.check_links(whole)) + return out or mb.check_docs(_docs_of(), narrow[0] if narrow else None, whole) def combo_errors(files: dict) -> list[str]: """일위대가 조합 전부(옛 `master_combo.check_all` 대신) — 로직이 있는지는 수식 문서로.""" - have = _docs_of(files) + have = _docs_of() return [f"{name} · {x}" for name, row in cm.mcb.rows(files) for x in mb.combo_row(row, have)] diff --git a/M01_MasterData/M01_MasterData_Store_Logic.py b/M01_MasterData/M01_MasterData_Store_Logic.py index 1683b2a09..76020539a 100644 --- a/M01_MasterData/M01_MasterData_Store_Logic.py +++ b/M01_MasterData/M01_MasterData_Store_Logic.py @@ -3,7 +3,8 @@ 화면 [저장](`/save` 의 로직 파일 몫) · [신규] · [본떠 만들기] · [복사/생성] · [삭제] · 별칭이 이 길로. - 판 = 문서 파일 글 지문(`Doc.file_version`) — 다르면 409 {stale} - 개정 확인 = 정본 문서 머리 대조(`Store_Revise.guard`) -- 키 = 대장(`_키대장.json` · 자체 GX 다음 번호) · 검사 = 문서(쓰는 곳 · 일위대가 담은 로직 · 키 겹침 · 대장) +- 키 = 대장(`_키대장.json` · 그 파일 표 다음 번호 · 자체 GX) · 검사 = 문서(일위대가 · 사전조합 · 조합이 담은 기초 · + 키 겹침 · 대장) · 쓰는 곳 409 는 [삭제](`Doc.remove`) - 쓰기 = 대장 → 문서(끊기면 둘 다 저장 전으로) → 옛 로직 줄 같이 쓰기(`mirror` 한 자리 · `WRITE`) 화면이 보낸 줄은 이름표(`md.TAGS`) + 머리(`Doc.HEAD`)만 씀 — 셈 칸은 문서(줄 쌓기 저장) 몫. """ @@ -26,7 +27,12 @@ md, ml, mk, cm = doc_store.md, doc_store.ml, store.mk, store.cm WRITE = os.environ.get("AISLO_LOGIC_WRITE", "1") != "0" OWN = "로직_자체.json" FIELDS = revise.FIELDS -CALC = {"입력": [], "중간": [], "호표": [], "끝수": None} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) +CALC = { + "입력": [], + "중간": [], + "호표": [], + "끝수": None, +} # 새 로직 줄 빈 셈 칸(옛 [신규] 줄과 같음) def is_logic(file: str) -> bool: @@ -71,7 +77,9 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: 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) + 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 []: @@ -91,9 +99,8 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: 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("로직", "자체") + 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 "") @@ -108,8 +115,14 @@ def _plan(parts: list[dict], book: dict) -> tuple[dict, list, list, set]: return plan, edits, 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(): @@ -118,21 +131,21 @@ def _errors(plan: dict, gone: set, old_book: dict, book: dict) -> list[str]: 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(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 @@ -202,7 +215,12 @@ def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None: if op == "더함": name = what["file"] if name not in after: # 자체 로직 파일이 없으면 머리만 두고 만듦 - after[name] = {"그룹": "로직", "원문": "자체", "판": str(kst_today().year), "줄": []} + 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} @@ -230,12 +248,17 @@ def mirror(edits: list[tuple], picks: tuple[dict, set] | None = None) -> None: 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}} + 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_} + 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}} @@ -246,7 +269,10 @@ def _picks(after: dict, add: dict, drop: set) -> set[str]: 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) + 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] diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 2eefbac48..e2f35209b 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -226,7 +226,11 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: for part in logic: for ch in part.get("changes") or []: row = ch.get("row") - if part.get("file") == OWN and isinstance(row, dict) and (ch.get("op") == "add" or not ch.get("key")): + if ( + part.get("file") == OWN + and isinstance(row, dict) + and (ch.get("op") == "add" or not ch.get("key")) + ): ch.update(op="add", key=None, row=_clean(row, str(row.get("소유") or OWNERS[0]))) files, added = [], [] if rest: @@ -234,11 +238,18 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) _keep_same(part) docs_too = machine.register(rest) # [새 기계] = 꼴 식 목록 등록(822-2 · 848-5 문서 정본) - before = {p["file"]: set(_file_keys(p["file"])) for p in rest} # 자재 3만 키 — 목록 찾기 금지 + before = { + p["file"]: set(_file_keys(p["file"])) for p in rest + } # 자재 3만 키 — 목록 찾기 금지 with store.cache.picks(*getattr(docs_too, "lists", ({}, set()))): files = store.save(rest) docs_too() - added = [{"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old] + added = [ + {"file": f, "key": k} + for f, old in before.items() + for k in _file_keys(f) + if k not in old + ] if logic: got = logic_store.save(logic, True) files, added = files + got["files"], added + got["added"] diff --git a/M01_MasterData/M01_MasterData_Store_Revise.py b/M01_MasterData/M01_MasterData_Store_Revise.py index 1c05a9926..50b519733 100644 --- a/M01_MasterData/M01_MasterData_Store_Revise.py +++ b/M01_MasterData/M01_MasterData_Store_Revise.py @@ -50,7 +50,12 @@ def changed(batch: list[dict]) -> list[dict]: for ch in part.get("changes") or []: op, key, row = ch.get("op"), str(ch.get("key") or ""), ch.get("row") old = have.get(key) - if op == "edit" and old is not None and isinstance(row, dict) and _head(row) == _head(old): + if ( + op == "edit" + and old is not None + and isinstance(row, dict) + and _head(row) == _head(old) + ): continue name = row.get("이름") if isinstance(row, dict) else None out.append( diff --git a/M01_MasterData/M01_MasterData_Store_Save.py b/M01_MasterData/M01_MasterData_Store_Save.py index 4222e3e69..f65c0f049 100644 --- a/M01_MasterData/M01_MasterData_Store_Save.py +++ b/M01_MasterData/M01_MasterData_Store_Save.py @@ -2,8 +2,8 @@ 전 = 기억(`Store_Cache.loaded`) · 후 = 고친 파일만 얕은 사본(줄 목록만 새로 · 줄은 바꿔 끼움만) — 폴더를 다시 읽지 않음. 검사 = 저장이 흔드는 것만: 로직은 `Store_Cache.narrow` · 틀은 고친 줄만 · -연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤거나 로직 줄이 빠질 때 · 일위대가 · 사전조합 -문서(모든 층 파일)는 로직 줄이 빠질 때 그 키만 · 키 겹침 · 대장 대조 · 돌고 도는 참조는 전체(가벼움). +연결 · 준용은 요소를 고쳤을 때 · 조합은 조합 파일을 고쳤을 때 · 키 겹침 · 대장 대조 · +돌고 도는 참조는 전체(가벼움) · 기초(로직) 저장은 `Store_Logic`(855 L3 ⓐ). 전 검사는 기억 색인(재료 고르기 찾기 기억이 데워져 있음) · 후 색인은 그 기억을 이어받음 (자재품목 줄이 바뀌면 그 줄이 걸리는 찾기만 버림). 저장 뒤 = 쓴 파일만 기억에 갈아 끼움. """ @@ -65,17 +65,20 @@ def _index(files: dict, whole, moved: list[dict]): return out -def _errors(files, whole, names, book, narrowed, keys, gone) -> list[str]: +def _errors(files, whole, names, book, narrowed, keys) -> list[str]: out = [x for name in names for x in cm.check_form(name, _only(name, files[name], keys[name]))] out += cache.logic_errors(files, whole, book, narrowed[:2]) # 수식 문서 기준(855 2-B3) if narrowed[2]: # 요소·표를 고쳤으면 연결 · 준용도 봄(로직 좁힘과 따로) out += cm.check_links(whole) - if cm.mcb.FILE in names or gone: + if cm.mcb.FILE in names: out += cache.combo_errors(files) return out def save(batch: list[dict]) -> list[dict]: + """요소 · 표 파일 저장 — 단가산출 기초(로직 파일 몫)는 받지 않음(`Store_Logic` · 855 L3 ⓐ).""" + if bad := [p.get("file") for p in batch if _logic_file(p.get("file", ""))]: + raise store.StoreError(400, f"기초는 기초 저장 길로 — {', '.join(bad)}") with store._LOCK: stale = [ p.get("file", "") for p in batch if store.version(p.get("file", "")) != p.get("version") @@ -92,7 +95,7 @@ def save(batch: list[dict]) -> list[dict]: for part in batch: store._apply(after[part["file"]], part.get("changes") or [], part["file"], book) mk.finish(book) - keys, gone, moved = {}, set(), [] + keys, moved = {}, [] for name in names: was, now = _rows(before[name]), _rows(after[name]) keys[name] = set(now) - set(was) @@ -103,17 +106,13 @@ def save(batch: list[dict]) -> list[dict]: for c in p.get("changes") or [] if c.get("op") != "add" } - if after[name].get("그룹") == "로직": - gone |= set(was) - set(now) moved += [s[k] for k in keys[name] for s in (was, now) if k[:2] == "MT" and k in s] # 저장이 흔드는 줄만 검사(고친 줄 · 그 줄을 부르던 줄 · 그 요소를 보던 줄) — # 마스터 전체 검사는 `check_master` 몫 narrowed = cache.narrow(store.FOLDER, batch, before, after) - old = set(_errors(before, whole, names, old_book, narrowed, keys, gone)) + old = set(_errors(before, whole, names, old_book, narrowed, keys)) fresh = _index(after, whole, moved) - new = _errors(after, fresh, names, book, narrowed, keys, gone) - # 일위대가 · 사전조합 문서가 담은 로직이 빠짐 — 빠지기 전엔 있던 키라 전 검사는 없음 - new = [x for x in new + cache.labor_errors(fresh, gone) if x not in old] + new = [x for x in _errors(after, fresh, names, book, narrowed, keys) if x not in old] if new: raise store.StoreError(422, {"errors": new}) # 대장(원자적) → 파일 · 중간에 끊기면 쓴 것 모두 저장 전으로(대장만 · 파일만 앞서가지 않게) @@ -135,6 +134,10 @@ def save(batch: list[dict]) -> list[dict]: return out +def _logic_file(name: str) -> bool: + return name.startswith("로직_") and name.endswith(".json") + + def _machine(name: str) -> bool: return name == mmf.NAME and mmf.here(store.FOLDER) # 기계 = 폴더(826-2) diff --git a/resources/tester/test_713_1_revise.py b/resources/tester/test_713_1_revise.py index 859b384c3..f2f8b3e83 100644 --- a/resources/tester/test_713_1_revise.py +++ b/resources/tester/test_713_1_revise.py @@ -1,11 +1,9 @@ """713-1 지킴 — 로직 정본 줄 고침 · 지우기 · 더하기는 「원문 개정 반영」 확인(`개정확인`) 없이는 409 · -요소 · 같은 줄 다시 보냄은 그대로 · 줄 바탕 지문(`Store_Revise.row_print`). 임시 사본 폴더만 씀.""" +요소 · 같은 줄 다시 보냄은 그대로 · 대조 = 문서 머리(855 L3 ⓐ). 임시 사본 폴더만 씀.""" from __future__ import annotations import shutil -from decimal import Decimal -from pathlib import Path import pytest from fastapi import FastAPI @@ -103,9 +101,6 @@ def test_요소_파일은_대상_밖(client: TestClient) -> None: assert client.post("/api/m01/save", json={"files": [part]}).status_code == 200 -def test_지문_수_꼴_같음() -> None: - a = {"이름": "가", "호표": [{"수량": Decimal("10.0")}], "끝수": 1} - b = {"이름": "나", "호표": [{"수량": 10}], "끝수": 1.0, "별칭": "x"} - assert revise.row_print(a) == revise.row_print(b) +def test_정본_파일_가름() -> None: assert revise.is_canon("로직_산림품셈_09장_토공.json") assert not revise.is_canon("로직_자체.json") and not revise.is_canon("인력.json") diff --git a/resources/tester/test_794_1_m01_sheet.py b/resources/tester/test_794_1_m01_sheet.py index 17fb32aed..141ce447b 100644 --- a/resources/tester/test_794_1_m01_sheet.py +++ b/resources/tester/test_794_1_m01_sheet.py @@ -1,14 +1,12 @@ # ruff: noqa: E501 -"""794-1 M01 로직 줄 식 고침 저장 — `/save`(개정 확인) 뒤 다시 셈 · 틀린 식 422 · 시스템 관리자만. +"""794-1 M01 저장 길 — 시스템 관리자만(로직 줄 식 고침 `/save` 시험은 855 L3 ⓐ 에서 걷음 — /save 는 기초 머리만 씀 · 셈 = 문서 저장). - 시트 서버 길(`/logic/sheet` · `/check`)은 화면 0 이라 853-1 에 걷음 — 남은 것은 살아 있는 `/save` · `/calc` -- 서버(사본 폴더): 공구손료 식 1 → 2 % 저장(개정 확인 409 → 200) 뒤 셈 51,802 · 틀린 식 저장 422 · 시스템 관리자가 아니면 403 +- 서버(사본 폴더): 시스템 관리자가 아니면 403 """ from __future__ import annotations -import copy -import hashlib import shutil from pathlib import Path @@ -19,18 +17,8 @@ from fastapi.testclient import TestClient from common_util.common_util_auth import require_system_admin, verify_session from M01_MasterData import M01_MasterData_Router as m01_router from M01_MasterData import M01_MasterData_Store as store -import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용) REAL = store.FOLDER -KEY = "GC000211" # 합판거푸집 설치 및 해체 -INPUTS = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님", - "폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0} # fmt: skip -TOOL_1 = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100" # 덧줄 첫 줄 엔진 식 -TOOL_2 = TOOL_1.replace("* 1 / 100", "* 2 / 100") - - -def _hashes(folder: Path) -> dict[str, str]: - return {p.name: hashlib.md5(p.read_bytes()).hexdigest() for p in sorted(folder.glob("*.json"))} # ── 서버 ───────────────────────────────────────────────────────────── @@ -45,43 +33,6 @@ def folder(tmp_path: Path, monkeypatch) -> Path: return master -@pytest.fixture -def client(folder: Path) -> TestClient: - app = FastAPI() - app.include_router(m01_router.router) - app.include_router(old_engine.router) - return TestClient(app) - - -def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict: - res = client.post(url, json=body) - assert res.status_code == want, res.text - return res.json() - - -def test_저장_길_개정_확인_다시_셈_틀린_식_422(client: TestClient, folder: Path) -> None: - real = _hashes(REAL) - one = client.get("/api/m01/logic", params={"key": KEY}).json() - row = copy.deepcopy(one["logic"]) - assert row["덧줄"][0]["식"] == TOOL_1 - row["덧줄"][0]["식"] = TOOL_2 - body = {"files": [{"file": one["file"], "version": one["version"], - "changes": [{"op": "edit", "key": KEY, "row": row}]}]} # fmt: skip - assert client.post("/api/m01/save", json=body).status_code == 409 # 정본 = 개정 확인 - _post(client, "/api/m01/save", {**body, "개정확인": True}) - saved = client.get("/api/m01/logic", params={"key": KEY}).json() - assert saved["logic"]["덧줄"][0]["식"] == TOOL_2 - sums = _post(client, "/api/m01/calc", {"key": KEY, "inputs": INPUTS})["sums"] - assert sums["계"] == 51802 and sums["경비"] == 765 # _분석_650-H2 4 장 공구손료 2 % - bad = copy.deepcopy(saved["logic"]) - bad["덧줄"][0]["식"] = "형틀목공 * 없는이름" - body = {"files": [{"file": saved["file"], "version": saved["version"], - "changes": [{"op": "edit", "key": KEY, "row": bad}]}], "개정확인": True} # fmt: skip - before = _hashes(folder) - assert client.post("/api/m01/save", json=body).status_code == 422 - assert _hashes(folder) == before and _hashes(REAL) == real - - def test_시스템_관리자가_아니면_403(folder: Path) -> None: app = FastAPI() app.include_router( diff --git a/resources/tester/test_794_1b_flow_gone.py b/resources/tester/test_794_1b_flow_gone.py index 7a038a109..ae87eac78 100644 --- a/resources/tester/test_794_1b_flow_gone.py +++ b/resources/tester/test_794_1b_flow_gone.py @@ -47,7 +47,11 @@ def test_흐름_길은_없고_표준_표는_남음(client: TestClient) -> None: def test_신규_로직은_시트_줄로_자체_GX(client: TestClient) -> None: - version = store.read(OWN)[1] if (store.FOLDER / OWN).is_file() else "" + version = next( + f["version"] + for f in client.get("/api/m01/groups/로직/files").json()["files"] + if f["file"] == OWN + ) # 판 = 문서 파일(855 L3 ⓐ) row = { "키": "", "이름": "sub3임시 새 로직", diff --git a/resources/tester/test_796_1_formula_model.py b/resources/tester/test_796_1_formula_model.py index e49a40451..298194f9f 100644 --- a/resources/tester/test_796_1_formula_model.py +++ b/resources/tester/test_796_1_formula_model.py @@ -25,7 +25,6 @@ mf = importlib.import_module("master_formula") mcut = importlib.import_module("master_cut") meq = importlib.import_module("master_equation") me = importlib.import_module("master_equation_edit") -revise = importlib.import_module("M01_MasterData.M01_MasterData_Store_Revise") REAL = store.FOLDER EXCAVATOR, AFRAME, FORM = "GF000089", "GC001140", "GC000211" @@ -188,7 +187,6 @@ def test_변수표_칸은_셈_안_바꿈(): row = dict(whole().logic(AFRAME)) row[meq.FIELD] = {"일운반회수": {"기호": "n", "아래": "d", "이름": "하루 운반 횟수"}} assert raw(AFRAME, row)["계"] == raw(AFRAME)["계"] - assert revise.row_print(row) == revise.row_print(whole().logic(AFRAME)) # M01 개정 배지 안 뜸 # ── ③ 고침 ──────────────────────────────────────────────────────────── diff --git a/resources/tester/test_802_3_doc_screen.py b/resources/tester/test_802_3_doc_screen.py index 8121b19e5..3191a3289 100644 --- a/resources/tester/test_802_3_doc_screen.py +++ b/resources/tester/test_802_3_doc_screen.py @@ -66,14 +66,11 @@ def test_읽기_미리셈_연결기록(client): assert other["셈"]["값"]["Q_조"] == other["셈"]["값"]["Q_4t^표"] > 0 -def test_없는문서_빈문서_없는키_404(client): - assert ( - _read(client, "GC000100")["새"] is False - ) # 802-2a 로 문서 넣음 — 임시 사본에서 지워 빈 문서 길을 봄 +def test_문서_없는_키_404(client): + """855 L3 ⓐ — 기초마다 문서가 늘 있음(만들 때 문서부터) · 문서가 없으면 로직 줄로 빈 문서를 짓지 않고 404.""" + assert _read(client, "GC000100")["새"] is False doc_screen.drop("GC000100") - fresh = _read(client, "GC000100") - assert fresh["새"] is True and fresh["문서"]["식"] == [] and fresh["문서"]["금액"] == [] - assert fresh["셈"]["셈됨"] is False and fresh["셈"]["계"] is None + assert client.get("/api/m01/logic/doc", params={"key": "GC000100"}).status_code == 404 assert client.get("/api/m01/logic/doc", params={"key": "GX999999"}).status_code == 404 diff --git a/resources/tester/test_804_7_line_stack_fix.py b/resources/tester/test_804_7_line_stack_fix.py index e90adcd4b..6c8d0bf0c 100644 --- a/resources/tester/test_804_7_line_stack_fix.py +++ b/resources/tester/test_804_7_line_stack_fix.py @@ -67,7 +67,11 @@ def _new_logic(c: TestClient, name: str) -> str: "호표": [], "끝수": None, } - ver = store.read("로직_자체.json")[1] if (store.FOLDER / "로직_자체.json").is_file() else "" + ver = next( + f["version"] + for f in c.get("/api/m01/groups/로직/files").json()["files"] + if f["file"] == "로직_자체.json" + ) # 판 = 문서 파일(855 L3 ⓐ) res = c.post( "/api/m01/save", json={ diff --git a/resources/tester/test_826_2_machine_files.py b/resources/tester/test_826_2_machine_files.py index 6ba1edb8c..0a5c710be 100644 --- a/resources/tester/test_826_2_machine_files.py +++ b/resources/tester/test_826_2_machine_files.py @@ -3,8 +3,10 @@ ① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜 ② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409 ③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움) -④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 오류 목록(견본 고침 스물) - 기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 로직 · 조합)마다 하나 이상 아홉(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1` +④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 판정(걸림 · 안 걸림 · 견본 고침 열일곱) + 기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 조합)마다 하나 이상 일곱(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1` + (855 L3 ⓐ — 기초 연결 흠 글은 수식 문서 기준이라 옛 로직 줄 글과 꼴이 다름 → 판정만 견줌 · 기초(로직 파일) 저장은 + `Store_Logic` 길이라 로직 갈래 셋은 `test_m01_make` · `test_855_l3_doc_only` 가 봄) """ from __future__ import annotations @@ -34,8 +36,6 @@ SAMPLE = { "인력 준용 끊김", "유가 값", "표 조건 틀림", - "로직 요소 끊김", - "로직 지움(일위대가 문서가 씀)", "조합 지움", } @@ -181,43 +181,12 @@ def _add(file: str, like: str, **cols) -> list[dict]: return [_part(file, {"op": "add", "row": row})] -def _logic_with_ref() -> tuple[str, str]: - for name, data in store._logic_files(store.loaded()[0]): - for row in data.get("줄") or []: - for item in row.get("호표") or []: - if isinstance(item.get("요소"), str) and item["요소"][:2] == "LB": - return name, str(row["키"]) - raise AssertionError("요소 줄 있는 로직 없음") - - -def _leaf() -> tuple[str, str]: - """아무도 안 부르고 조합에도 없는 로직 — 일위대가 문서만 쓰게 둠.""" - files = store.loaded()[0] - called = {k for _, calls, _ in cache.counted(store.FOLDER).values() for k in calls} - held = {k for _, row in cm.mcb.rows(files) for k in cm.mcb.logic_keys(row)} - for name, data in store._logic_files(files): - for row in data.get("줄") or []: - if str(row["키"]) not in called | held: - return name, str(row["키"]) - raise AssertionError("잎 로직 없음") - - def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) -> None: - leaf_file, leaf = _leaf() - doc = tmp_path / "labor.json" - doc.write_text(json.dumps({"담은로직": [{"로직": leaf}]}), encoding="utf-8") - monkeypatch.setattr(cache, "_labor_files", lambda: [("일위대가 시험", doc)]) + monkeypatch.setattr(cache, "_labor_files", lambda: []) # 층 일위대가 문서는 안 봄(임시 사본만) used = next(r["키"] for r in _rows(M) if r.get("원문번호") == "0201-0100") - ref_file, ref_logic = _logic_with_ref() combo = [r["키"] for r in _rows(cm.mcb.FILE)] table = next(n for n in store.loaded()[0] if n.startswith("계수_")) cell = _rows(table)[0]["키"] - called = "GC000268" # 317 줄이 부름 - called_file = next( - n - for n, d in store._logic_files(store.loaded()[0]) - if any(r["키"] == called for r in d["줄"]) - ) def bump(r): r["값"]["가격"] += 1 @@ -237,9 +206,6 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) ("인력 준용 끊김", lambda: _edit(LB, "LB000006", lambda r: r.update(준용="LB999999")), True), ("유가 값", lambda: _edit(MO, "MO000001", lambda r: r.update(값=r["값"] + 1)), False), ("표 조건 틀림", lambda: _edit(table, cell, lambda r: r["조건"].update(sub1="모름")), True), - ("로직 요소 끊김", lambda: _edit(ref_file, ref_logic, lambda r: next(i for i in r["호표"] if str(i.get("요소", ""))[:2] == "LB").update(요소="LB999999")), True), - ("로직 지움(부름 받음)", lambda: _delete(called_file, called), True), - ("로직 지움(일위대가 문서가 씀)", lambda: _delete(leaf_file, leaf), True), ("조합 이름 겹침", lambda: _edit(cm.mcb.FILE, combo[0], lambda r: r.update(이름=_rows(cm.mcb.FILE)[1]["이름"])), True), ("조합 지움", lambda: _delete(cm.mcb.FILE, combo[-1]), False), ("새 자재", lambda: _add(MT, "MT000008", 이름="sub1임시새자재"), False), @@ -251,5 +217,4 @@ def test_narrow_check_same_as_before(master: Path, tmp_path: Path, monkeypatch) batch = make() want = _old(batch) got = _new(batch) - assert sorted(got) == sorted(want), name - assert bool(want) == bad, (name, want[:3]) + assert bool(got) == bool(want) == bad, (name, got[:3], want[:3]) diff --git a/resources/tester/test_854_2_m01_copy_doc.py b/resources/tester/test_854_2_m01_copy_doc.py index a53e1a438..8144f7e9d 100644 --- a/resources/tester/test_854_2_m01_copy_doc.py +++ b/resources/tester/test_854_2_m01_copy_doc.py @@ -1,7 +1,7 @@ """M01 [로직 복사/생성] 이 수식 문서도 같이 지음(PLAN 854-2 · 요구 896) — 사본 폴더에서만. - 만들면 문서 있음 · 새 계산기 금액 = 옛 엔진 = 본뜬 로직 · 빌더가 다시 지어도 같은 글. -- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음. +- 지우면(`/logic/remove` · `/save` 지움) 문서도 없음 · [복사/생성] = 원본 문서 복제 + 기본정보(855 L3 ⓐ). """ from __future__ import annotations @@ -60,7 +60,7 @@ def _old(key: str) -> dict: """옛 엔진 금액(빌더 대조와 같은 길 · 기본 입력).""" builder = importlib.import_module("build_수식문서_802_2") whole = store.loaded()[1] - row = store.logic(key)["logic"] + row = whole.logic(key) # 옛 로직 줄(같이 쓰기 · `/logic` 답은 머리만 · 855 L3 ⓐ) return _money(builder.old_answer(whole, row, builder.cases_of(whole, row)[0][1])) @@ -92,16 +92,14 @@ def test_복사로_만든_로직은_수식_문서가_있고_금액이_옛_엔진 assert key not in doc_screen.docs() -def test_식_복사로_만든_로직도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None: - view = _get(client, "/api/m01/logic/formula", key=SAMPLE) - made = _post( - client, - "/api/m01/logic/formula/save", - {"로직": view["로직"], "별칭": view["별칭"], "본뜬키": SAMPLE, "이름": "sub5임시 식복사"}, - ) +def test_기본정보를_고쳐_복사해도_문서가_있고_save_지움이면_문서도_없다(client: TestClient) -> None: + more = {"이름": "sub7임시 복사", "원문번호": "13-4-9", "결과단위": "m3", "출처": "자체 시험"} + made = _post(client, "/api/m01/logic/copy", {"key": SAMPLE, **more}) # 855 L3 ⓐ [복사/생성] key = made["key"] assert made["수식문서"] is True and key in doc_screen.docs() assert _money(_get(client, "/api/m01/logic/doc", key=key)["셈"]) == _old(key) + head = _get(client, "/api/m01/logic", key=key)["logic"] + assert {k: head[k] for k in more} == more and head["키"] == key body = {"file": make.OWN, "version": made["version"], "changes": [{"op": "delete", "key": key}]} _post(client, "/api/m01/save", {"files": [body]}) diff --git a/resources/tester/test_854_2_m01_key_book.py b/resources/tester/test_854_2_m01_key_book.py index aa3c1a97a..5be8c3325 100644 --- a/resources/tester/test_854_2_m01_key_book.py +++ b/resources/tester/test_854_2_m01_key_book.py @@ -15,7 +15,7 @@ from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Save as save_mod REAL = store.FOLDER -OWN = "로직_자체.json" +LABOR_FILE = "인력.json" MACHINE = "EQ000002" LABOR = "LB000002" # 보통인부 @@ -36,37 +36,19 @@ def _bytes(folder: Path) -> dict[str, bytes]: return out -def _new_logic() -> dict: +def _new_labor() -> dict: + """새 인력 줄 — LB 키 발급 = 대장 바뀜(기초 저장은 `Store_Logic` 길 · 855 L3 ⓐ).""" + rows = json.loads((store.FOLDER / LABOR_FILE).read_text(encoding="utf-8"))["줄"] + seed = next(r for r in rows if r["키"] == LABOR) + row = {k: v for k, v in seed.items() if k != "키"} return { "op": "add", - "row": { - "원문번호": "", - "구분": "자체", - "상세구분": "", - "소유": "현장", - "이름": "sub5임시 대장 시험", - "결과단위": "원/㎡", - "출처": "자체", - "입력": [], - "중간": [], - "호표": [ - { - "종류": "인력", - "요소": LABOR, - "이름": "보통인부", - "단위": "인", - "수량": "1 / 7", - "비목": "노무비", - } - ], - "덧줄": [], - "끝수": None, - }, + "row": {**row, "원문번호": "9999", "이름": "sub7임시 인부", "출처": "자체"}, } def _batch() -> list[dict]: - """기계 한 대 고침(기계 폴더) + 자체 로직 새 줄(GX 키 발급 = 대장 바뀜).""" + """기계 한 대 고침(기계 폴더) + 인력 새 줄(LB 키 발급 = 대장 바뀜).""" machine = json.loads((store.FOLDER / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) machine["비고"] = "sub5임시" return [ @@ -75,7 +57,7 @@ def _batch() -> list[dict]: "version": store.version("기계.json"), "changes": [{"op": "edit", "key": MACHINE, "row": machine}], }, - {"file": OWN, "version": store.version(OWN), "changes": [_new_logic()]}, + {"file": LABOR_FILE, "version": store.version(LABOR_FILE), "changes": [_new_labor()]}, ] @@ -99,15 +81,37 @@ def test_파일_쓰기가_끊기면_대장과_파일이_저장_전_그대로( with pytest.raises(OSError): store.save(_batch()) after = _bytes(master) - assert after == before # 대장 · 기계 · 로직 파일 모두 저장 전 글 그대로 + assert after == before # 대장 · 기계 · 인력 파일 모두 저장 전 글 그대로 assert not list(master.glob(".*.tmp")) and not list((master / "기계").glob(".*.tmp")) def test_끊김_없으면_대장과_파일이_같이_간다(master: Path) -> None: - book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("GX", 1) + book_before = store.mk.load_book(master / store.mk.BOOK.name)["다음"].get("LB", 1) store.save(_batch()) book = store.mk.load_book(master / store.mk.BOOK.name) - keys = [r["키"] for r in json.loads((master / OWN).read_text(encoding="utf-8"))["줄"]] - assert f"GX{book_before:06d}" in keys and book["다음"]["GX"] == book_before + 1 + keys = [r["키"] for r in json.loads((master / LABOR_FILE).read_text(encoding="utf-8"))["줄"]] + assert f"LB{book_before:06d}" in keys and book["다음"]["LB"] == book_before + 1 machine = json.loads((master / "기계" / f"{MACHINE}.json").read_text(encoding="utf-8")) assert machine["비고"] == "sub5임시" + + +def test_기초_문서_쓰기가_끊기면_대장과_문서가_저장_전_그대로(master: Path, monkeypatch) -> None: + """855 L3 ⓐ — 새 기초 = 대장 GX 발급 → 자체 문서 파일 · 문서 쓰기가 끊기면 둘 다 저장 전 글.""" + from M01_MasterData import M01_MasterData_Doc as doc_store + from M01_MasterData import M01_MasterData_Store_Logic as logic_store + + shutil.copytree(REAL / "수식문서", master / "수식문서") + monkeypatch.setattr(doc_store.ml, "FOLDER", master / "수식문서") + doc_store._memo.clear() + before = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")} + + def broken(path, data): + raise OSError("디스크 흉내 실패") + + monkeypatch.setattr(doc_store, "put", broken) + row = {"키": "", "이름": "sub7임시 기초", "원문번호": "", "결과단위": "원", "출처": "자체"} + part = {"file": "로직_자체.json", "version": doc_store.file_version("로직_자체.json")} + with pytest.raises(OSError): + logic_store.save([{**part, "changes": [{"op": "add", "row": row}]}]) + after = _bytes(master) | {p.name: p.read_bytes() for p in (master / "수식문서").glob("*.json")} + assert after == before diff --git a/resources/tester/test_855_l3_doc_only.py b/resources/tester/test_855_l3_doc_only.py new file mode 100644 index 000000000..77d675ce2 --- /dev/null +++ b/resources/tester/test_855_l3_doc_only.py @@ -0,0 +1,150 @@ +"""855 L3 ⓐ 지킴 — M01 단가산출 기초가 수식 문서만으로 돎(로직 JSON 은 같이 쓰기만). + +마스터 사본 두 벌에서 같은 차례로 부름 — 켬(로직 파일 있음 · 같이 쓰기 켬) / 끔(로직 파일 없음 · +`Store_Logic.WRITE` 끔). 목록 · 상세 · 비고 [저장] · 개정 확인 409 · 판 409 · 별칭 · [신규] · +[복사/생성] · [삭제] · 기계 등록 답이 두 벌 같음. +다른 자리(둘째 박자에서 걷을 것) = `/logic/doc` 의 「층바탕」(빌더 문서 = 옛 로직 줄 변환)만 — 빼고 견줌. +""" + +from __future__ import annotations + +import json +import shutil +import sys +from pathlib import Path + +from fastapi import Depends, FastAPI +from fastapi.testclient import TestClient + +from common_util import common_util_auth as auth +from M01_MasterData import M01_MasterData_Alias as alias +from M01_MasterData import M01_MasterData_Doc as doc_store +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Logic as logic_store + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts")) +import master_doc_link as mdl # noqa: E402 + +REAL = store.FOLDER +CANON = "GF000219" # 산림 13-4-1 메쌓기(인력) — 정본 기초 +MACHINE, FAMILY = "기계.json", "GC000268" # [새 기계] = 꼴 식 고르기 목록 등록 + + +def _world(tmp: Path, monkeypatch, logic: bool) -> TestClient: + for path in REAL.glob("*.json"): + if path.name.startswith("로직_") and not logic: + continue + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp / path.name) + shutil.copytree(REAL / "기계", tmp / "기계") + shutil.copytree(REAL / "수식문서", tmp / "수식문서") + monkeypatch.setattr(store, "FOLDER", tmp) + monkeypatch.setattr(doc_store.ml, "FOLDER", tmp / "수식문서") + monkeypatch.setattr(mdl, "FOLDER", tmp / "수식문서") + monkeypatch.setattr(logic_store, "WRITE", logic) + doc_store._memo.clear() + store.cache.forget() # 앞 시험이 남긴 기억 없이 + app = FastAPI() + app.dependency_overrides[auth.verify_session] = lambda: { + "user_id": 1, "name": "시험", "role": "SYSTEM_ADMIN", "company_id": 1, + } # fmt: skip + deps = [Depends(auth.verify_session), Depends(auth.require_system_admin)] + app.include_router(router_module.router, dependencies=deps) + app.include_router(alias.router, dependencies=deps) + return TestClient(app) + + +def _run(client: TestClient) -> list: + out: list = [] + + def call(method: str, url: str, body=None, **params): + res = client.request(method, url, json=body, params=params or None) + got = res.json() + if isinstance(got, dict): + got.pop("층바탕", None) # 빌더 문서(옛 로직 줄 변환) — 둘째 박자에서 걷음 + out.append((method, url, res.status_code, got)) + return got + + def save(file: str, version: str, changes: list, ok: bool = True) -> dict: + body = {"files": [{"file": file, "version": version, "changes": changes}], "개정확인": ok} + return call("POST", "/api/m01/save", body) + + call("GET", "/api/m01/logics") + call("GET", "/api/m01/logics", q="메쌓기") + call("GET", "/api/m01/groups/로직/files") + one = call("GET", "/api/m01/logic", key=CANON) + call("GET", "/api/m01/logic/doc", key=CANON) + row = {**one["logic"], "비고": "sub7임시 비고"} + edit = [{"op": "edit", "key": CANON, "row": row}] + save(one["file"], one["version"], edit, ok=False) # 개정 확인 없음 = 409 + saved = save(one["file"], one["version"], edit) + save(one["file"], one["version"], edit) # 옛 판 = 409 + call("GET", "/api/m01/logic", key=CANON) + back = [{"op": "edit", "key": CANON, "row": one["logic"]}] + save(one["file"], saved["files"][0]["version"], back) + call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": "sub7임시별칭"}) + call("GET", "/api/m01/alias") + call("POST", "/api/m01/alias/save", {"키": CANON, "별칭": ""}) + call("GET", "/api/m01/logic", key=CANON) + + own = next( + f + for f in call("GET", "/api/m01/groups/로직/files")["files"] + if f["file"] == "로직_자체.json" + ) + new = {"키": "", "이름": "sub7임시 신규", "원문번호": "", "결과단위": "m3", "출처": "자체"} + made = save("로직_자체.json", own["version"], [{"op": "add", "row": new}]) + key = made["added"][-1]["key"] + call("GET", "/api/m01/logic", key=key) + call("GET", "/api/m01/logic/doc", key=key) + copied = call("POST", "/api/m01/logic/copy", {"key": CANON, "이름": "sub7임시 복사"}) + call("GET", "/api/m01/logic/doc", key=copied["key"]) + for gone in (key, copied["key"]): + info = call("GET", "/api/m01/logic", key=gone) + body = {"key": gone, "file": info["file"], "version": info["version"]} + call("POST", "/api/m01/logic/remove", body) + call("GET", "/api/m01/logics", q="sub7임시") + + seed = call("GET", "/api/m01/machine/row", key="EQ000022") + first = json.loads(json.dumps(seed["row"])) + machine = { + **first, + "키": "", + "원문번호": "9999-0855", + "이름": "sub7임시기계", + "출처": {}, + "단위": {}, + } + machine.pop("별칭", None) + save(MACHINE, seed["version"], [{"op": "add", "row": machine}]) + picks = call("GET", "/api/m01/logic/doc", key=FAMILY) + assert "9999-0855" in json.dumps(picks["문서"], ensure_ascii=False) + rows = store.read(MACHINE)[0]["줄"] + eq = next(r["키"] for r in rows if r.get("원문번호") == "9999-0855") + save(MACHINE, store.version(MACHINE), [{"op": "delete", "key": eq}]) + call("GET", "/api/m01/logic/doc", key=FAMILY) + return out + + +def test_로직_파일_없이_같이_쓰기_끄고도_답이_같음(tmp_path: Path, monkeypatch) -> None: + (tmp_path / "on").mkdir() + (tmp_path / "off").mkdir() + with monkeypatch.context() as m: + on = _run(_world(tmp_path / "on", m, logic=True)) + with monkeypatch.context() as m: + off = _run(_world(tmp_path / "off", m, logic=False)) + assert [c[2] for c in on] == [c[2] for c in off] + assert [c[2] for c in on].count(409) == 2 # 개정 확인 · 옛 판 + assert not [c for c in on if c[2] >= 400 and c[2] != 409], on + for a, b in zip(on, off, strict=True): + if a != b and isinstance(a[3], dict) and "logics" in a[3]: + x, y = a[3]["logics"], b[3]["logics"] + hit = next(((p, q) for p, q in zip(x, y) if p != q), (len(x), len(y))) + raise AssertionError((a[:3], hit)) + assert a == b, ( + a[:3], + json.dumps(a[3], ensure_ascii=False)[:300], + json.dumps(b[3], ensure_ascii=False)[:300], + ) + assert not list((tmp_path / "off").glob("로직_*.json")) # 끔 = 로직 파일을 만들지 않음 diff --git a/resources/tester/test_m01_api.py b/resources/tester/test_m01_api.py index 5082983d2..8439e568c 100644 --- a/resources/tester/test_m01_api.py +++ b/resources/tester/test_m01_api.py @@ -62,6 +62,12 @@ def _get(client: TestClient, url: str, **params) -> dict: return res.json() +def _row(file: str, key: str) -> dict: + """옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 셈 길 시험 몫.""" + rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"] + return next(r for r in rows if r["키"] == key) + + def _calc(client: TestClient, **inputs) -> dict: res = client.post( "/api/m01/calc", @@ -264,7 +270,8 @@ def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient) assert tables["items"] and all(x["값칸"] for x in tables["items"]) raw = (store.FOLDER / one["file"]).read_bytes() before = _calc(client)["sums"]["계"] - half = {**one["logic"], "호표": one["logic"]["호표"][:1]} # 보통인부 줄 뺌 + row = _row(one["file"], LOGIC_KEY) + half = {**row, "호표": row["호표"][:1]} # 보통인부 줄 뺌 res = client.post( "/api/m01/calc", json={"key": LOGIC_KEY, "inputs": LOGIC_INPUTS, "row": half}, @@ -390,7 +397,7 @@ def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> N 계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인).""" one = _get(client, "/api/m01/logic", key=key_of("GC000893")) cond = {"이름": "전력량요금", "계약종별": "입력"} - assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]} + assert "전력 계약종별" in {x["이름"] for x in _row(one["file"], one["logic"]["키"])["입력"]} with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"): store.cm.mf.element(store.cm.master(), cond, {}) value, source = store.cm.mf.element(store.cm.master(), cond, {"전력 계약종별": "주택용 저압"}) diff --git a/resources/tester/test_m01_cache.py b/resources/tester/test_m01_cache.py index 6c4501158..ecb45b30d 100644 --- a/resources/tester/test_m01_cache.py +++ b/resources/tester/test_m01_cache.py @@ -3,7 +3,7 @@ 목록(`/logics` · `/combos`)은 요청마다 마스터를 새로 읽지 않고 막힘도 미리 세어 둔 값을 씀. 여기서 보는 것 = ① 세어 둔 값이 줄마다 검사한 것과 같음 ② 파일이 바뀌면 바로 다시 읽음 ③ 저장 직후 목록에 바로 비침 ④ 다른 파일의 로직이 바뀌면 그것을 부르던 줄도 다시 셈 -⑤ 저장 검사를 고친 줄 둘레로 좁혀도 흠(없는 키 · 없는 요소 · 돌고 도는 참조)을 그대로 잡음. +⑤ 요소 저장 검사를 좁혀도 흠을 그대로 잡음(기초 셈 칸 고침 검사 = 문서 저장 몫 · 855 L3 ⓐ). """ from __future__ import annotations @@ -129,74 +129,11 @@ def test_부르는_로직이_바뀌면_다른_파일의_줄도_다시_센다( assert caller["blocked"] is True and any("입력 「지역」" in x for x in caller["reasons"]) -def _save(client: TestClient, key: str, spoil) -> object: - """그 로직 줄을 고쳐 저장 길로 보냄 — 저장 검사가 흠을 잡는지 보려고.""" - one = client.get("/api/m01/logic", params={"key": key}).json() - row = json.loads(json.dumps(one["logic"], ensure_ascii=False)) - spoil(row) - return client.post( - "/api/m01/save", - json={ - "files": [ - { - "file": one["file"], - "version": one["version"], - "changes": [{"op": "edit", "key": key, "row": row}], - } - ], - "개정확인": True, # 정본 줄 고침 = 개정 확인(713-1) - }, - ) - - def _errors(res) -> list[str]: assert res.status_code == 422, res.text return res.json()["detail"]["errors"] -def test_저장_검사를_좁혀도_흠을_잡는다(client: TestClient) -> None: - """고친 줄과 그 줄을 부르던 줄만 검사하지만 없는 키 · 없는 요소는 그대로 걸림.""" - _logics(client) # 미리 세어 둔 값이 선 평소 모양 - - def no_logic(row: dict) -> None: - at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "로직") - row["호표"][at]["요소"] = "로직(GC999999, 기계='5401-0017', 지역=지역)" - - def no_element(row: dict) -> None: - at = next(i for i, h in enumerate(row["호표"]) if h["종류"] == "인력") - row["호표"][at]["요소"] = "LB999999" - - for spoil, word in ((no_logic, "GC999999"), (no_element, "LB999999")): - assert any(word in x for x in _errors(_save(client, CALLER, spoil))) - - -def test_돌고_도는_참조도_저장이_막는다(client: TestClient) -> None: - _logics(client) - - def call_back(row: dict) -> None: - row.setdefault("호표", []).append( - { - "종류": "로직", - "요소": f"로직({CALLER}, 지반구분='토사', 크레인='2104-0010', 지역=지역)", - "이름": "되부르기", - "단위": "시간", - "수량": "1", - } - ) - - assert any("돌고 도는" in x for x in _errors(_save(client, CALLEE, call_back))) - - -def test_고친_줄을_부르던_줄이_깨지면_저장이_막힌다(client: TestClient) -> None: - """좁힌 검사가 「그 줄을 부르는 줄」 을 빠뜨리지 않는지 — 다른 파일에 있는 줄.""" - _logics(client) - - def add_input(row: dict) -> None: - row["입력"] = [*row.get("입력", []), {"이름": "새입력", "종류": "수"}] - - assert any("새입력" in x for x in _errors(_save(client, CALLEE, add_input))) - - def test_미리_읽어_두면_첫_목록이_기다리지_않는다(client: TestClient) -> None: store.cache.forget() thread = store.cache.warm(store.FOLDER) diff --git a/resources/tester/test_m01_copy.py b/resources/tester/test_m01_copy.py index fd3f0e380..68b656ed9 100644 --- a/resources/tester/test_m01_copy.py +++ b/resources/tester/test_m01_copy.py @@ -1,119 +1,21 @@ -"""M01 복사해서 만들기(PLAN 3-4) — 별칭 꼴 식 펴기 · 되돌려 자체 로직으로 저장. +"""master_copy 펴기 · 되돌리기 왕복(PLAN 3-4) — 로직 전부가 펴고 되돌리면 원래 식 글자 그대로. -계약 `resources/master_data/_화면_계약.md` 7장 · 규칙 `resources/master_data/ref/_설계_식_복사.md`. -못박는 것 - - 13-4-1 을 식으로 펴 아무것도 안 고치고 되돌려 저장하면 원본과 계산 결과가 같음. - - 12-4 처럼 같은 표를 다른 인자로 쓰는 로직은 별칭이 찾은 줄 값으로 갈림. - - 로직 전부(1,354줄)가 펴고 되돌리면 원래 식 글자 그대로 돌아옴. +M01 [복사/생성] 옛 시트 길(`/logic/formula*`)은 855 L3 ⓐ 에서 걷음(문서 복제 = `test_854_2_m01_copy_doc`) · +`master_copy` 는 M02 `Sangeun_Formula` · `master_text` 가 아직 씀 — 로직 JSON 을 걷는 둘째 박자에서 이 시험도 걷음. """ from __future__ import annotations -import shutil import sys -from decimal import Decimal from pathlib import Path -import pytest -from fastapi import FastAPI -from fastapi.testclient import TestClient - -from M01_MasterData import M01_MasterData_Router as router_module from M01_MasterData import M01_MasterData_Store as store sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "master_data/scripts")) import master_copy as mcp # noqa: E402 -import helper_855_old_engine_routes as old_engine # noqa: E402 — 옛 셈 길 몸(855 2-E1 · 시험 전용) REAL = store.FOLDER -STACK = "GF000219" # 13-4-1 메쌓기(인력) — 같은 표를 같은 인자로 두 번(별칭 하나로 합침) -FORM = "GF000160" # 12-4 합판거푸집 — 같은 표를 다른 인자로 일곱 번(번호로 갈림) - - -@pytest.fixture -def client(tmp_path: Path, monkeypatch) -> TestClient: - for path in REAL.glob("*.json"): - if not path.name.startswith("_") or path.name == store.mk.BOOK.name: - shutil.copy(path, tmp_path / path.name) - shutil.copytree(REAL / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) - monkeypatch.setattr(store, "FOLDER", tmp_path) - shutil.copytree(REAL / "수식문서", tmp_path / "수식문서") # 로직 목록 = 수식 문서(855 L2 ⓐ) - monkeypatch.setattr(store._docs().ml, "FOLDER", tmp_path / "수식문서") - app = FastAPI() - app.include_router(router_module.router) - app.include_router(old_engine.router) - return TestClient(app) - - -def _get(client: TestClient, url: str, **params) -> dict: - res = client.get(url, params=params) - assert res.status_code == 200, res.text - return res.json() - - -def _post(client: TestClient, url: str, body: dict, want: int = 200) -> dict: - res = client.post(url, json=body) - assert res.status_code == want, res.text - return res.json() - - -def _inputs(key: str) -> dict: - """그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`).""" - row = store.cm.master(REAL).logic(key) - return {k: str(v) for k, v in store.cm.시험입력(row).items()} - - -def _sums(client: TestClient, key: str, inputs: dict) -> dict: - got = _post(client, "/api/m01/calc", {"key": key, "inputs": inputs}) - assert got["ok"] is True, got - return got["sums"] - - -# ── 펴기 ────────────────────────────────────────────────────────────── -def test_별칭이_식에서_이름_하나로_보이고_원문은_뒤에_남는다(client: TestClient) -> None: - got = _get(client, "/api/m01/logic/formula", key=STACK) - names = {one["이름"]: one for one in got["별칭"]} - assert set(names) == {"메쌓기인력", "높이에대한증가율표"} - - hit = names["메쌓기인력"] - assert hit["참조"] == "QF000421" - assert hit["원문"] == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기)" - assert hit["자리"] == ["호표[0].수량", "호표[1].수량"] # 완전히 같은 부르기는 하나로 합침 - assert "석공" in hit["값칸"] - - 가로 = {one["자리"]: one["식"] for one in got["줄"]} - assert 가로["호표[0].수량"] == "메쌓기인력.석공 * (1 + 증가율 / 100)" # 값 칸은 그대로 둠 - assert "찾기(" not in 가로["중간[0].식"] - assert "높이에대한증가율표.증가율" in 가로["중간[0].식"] - - -def test_같은_표를_다른_인자로_쓰면_별칭이_찾은_줄_값으로_갈린다(client: TestClient) -> None: - got = _get(client, "/api/m01/logic/formula", key=FORM) - 형틀 = [one for one in got["별칭"] if one["참조"] == "QF000357"] - assert [one["이름"] for one in 형틀] == [ - f"합판거푸집_{n}" for n in ("합판", "각재", "철선", "못", "박리제", "형틀목공", "보통인부") - ] - assert [one["원문"] for one in 형틀][:2] == [ - "찾기(QF000357, 구분='합판')", - "찾기(QF000357, 구분='각재')", - ] - # 같은 표를 같은 인자로 두 번 쓰는 자리(QF000358)는 번호 없이 하나 - 한벌 = [one for one in got["별칭"] if one["참조"] == "QF000358"] - assert len(한벌) == 1 and 한벌[0]["자리"] == ["중간[0].식", "중간[1].식"] - - 가로 = {one["자리"]: one["식"] for one in got["줄"]} - assert 가로["호표[0].수량"] == "합판거푸집_합판.기준수량_1회사용 * 재료율" - assert 가로["호표[1].수량"] == "합판거푸집_각재.기준수량_1회사용 * 재료율" - - -def test_로직_부르기도_별칭으로_보인다(client: TestClient) -> None: - got = _get(client, "/api/m01/logic/formula", key="GC000994") - 부름 = [one for one in got["별칭"] if one["종류"] == "로직"] - assert 부름, got["별칭"] - assert all(one["원문"].startswith("로직(") for one in 부름) - 요소 = [one.get("요소") for one in got["줄"] if one["갈래"] == "호표"] - assert any(str(one) in {x["이름"] for x in 부름} for one in 요소) # 호표 요소도 별칭으로 def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() -> None: @@ -128,140 +30,3 @@ def test_로직_전부가_펴고_되돌리면_원래_식으로_돌아온다() -> bad += mcp.check(master, row) assert rows > 1000, rows assert not bad, bad[:5] - - -# ── 되돌려 저장 ──────────────────────────────────────────────────────── -def test_안_고치고_되돌려_저장하면_원본과_계산이_같다(client: TestClient) -> None: - inputs = _inputs(STACK) - was = _sums(client, STACK, inputs) - - view = _get(client, "/api/m01/logic/formula", key=STACK) - made = _post( - client, - "/api/m01/logic/formula/save", - {"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK, "이름": "메쌓기 복사본"}, - ) - key = made["key"] - assert key.startswith("GX"), made - assert made["logic"]["소유"] == "현장" and made["logic"]["구분"] == "자체" - assert f"{STACK} 를 본뜸" in made["logic"]["비고"] - - # 별칭은 저장되지 않음 — 식은 원문 그대로 - 식 = made["logic"]["호표"][0]["수량"] - assert 식 == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)" - assert Decimal(str(_sums(client, key, inputs)["계"])) == Decimal(str(was["계"])) - assert Decimal(str(was["계"])) > 0 - - # 원본은 그대로 - assert _get(client, "/api/m01/logic", key=STACK)["logic"]["호표"][0]["수량"] == 식 - - -def test_식을_고쳐_저장하면_그_값으로_계산된다(client: TestClient) -> None: - inputs = _inputs(FORM) - was = _sums(client, FORM, inputs) - - view = _get(client, "/api/m01/logic/formula", key=FORM) - row = view["로직"] - row["호표"][6]["수량"] = ( - "합판거푸집_형틀목공.기준수량_1회사용 * 인력율 * 2" # 형틀목공 품 두 배 - ) - made = _post( - client, - "/api/m01/logic/formula/save", - {"로직": row, "별칭": view["별칭"], "본뜬키": FORM}, - ) - saved = made["logic"]["호표"][6]["수량"] - assert saved == "찾기(QF000357, 구분='형틀목공').기준수량_1회사용 * 인력율 * 2" - - now = _sums(client, made["key"], inputs) - assert Decimal(str(now["노무비"])) > Decimal(str(was["노무비"])) - assert Decimal(str(now["재료비"])) == Decimal(str(was["재료비"])) - - -def test_별칭과_같은_이름의_사용자_변수를_만들면_저장을_막는다(client: TestClient) -> None: - """일감 15 — 교차 검증 어긋남 1건. 가림 못 하는 이름 겹침은 조용히 안 바꾸고 막음.""" - view = _get(client, "/api/m01/logic/formula", key=STACK) - row = view["로직"] - row["중간"].insert(0, {"이름": "메쌓기인력", "식": "1"}) # 별칭과 같은 이름 - for h in row["호표"]: - if h["이름"] == "석공": - h["수량"] = "메쌓기인력 * 2" - got = _post( - client, - "/api/m01/logic/formula/save", - {"로직": row, "별칭": view["별칭"], "본뜬키": STACK}, - want=400, - ) - assert "메쌓기인력" in str(got["detail"]) - # 미리보기 길도 같이 막힘 - got2 = _post( - client, "/api/m01/logic/formula/preview", {"로직": row, "별칭": view["별칭"]}, want=400 - ) - assert "메쌓기인력" in str(got2["detail"]) - - -def test_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None: - view = _get(client, "/api/m01/logic/formula", key=STACK) - marks = [{**one} for one in view["별칭"]] - marks[0]["원문"] = "1 + 1" - got = _post( - client, - "/api/m01/logic/formula/save", - {"로직": view["로직"], "별칭": marks}, - want=400, - ) - assert "찾기" in str(got["detail"]) - - -def test_미리보기는_저장_없이_원문으로_되돌린_로직과_지을_문서를_준다(client: TestClient) -> None: - """3-4 화면의 [시험 계산] 이 쓰는 길(855 2-B4) — 답의 `문서` 를 문서 셈(`/logic/doc/preview`) - 으로 · 금액 = 그 로직 수식 문서 금액(옵션을 바꿔도).""" - view = _get(client, "/api/m01/logic/formula", key=STACK) - before_keys = _get(client, "/api/m01/logics")["logics"] - preview = _post( - client, "/api/m01/logic/formula/preview", {"로직": view["로직"], "별칭": view["별칭"]} - ) - resolved = preview["logic"]["호표"][0]["수량"] - assert resolved == "찾기(QF000421, 뒷길이=뒷길이, 돌=돌, 쌓기=쌓기).석공 * (1 + 증가율 / 100)" - after_keys = _get(client, "/api/m01/logics")["logics"] - assert after_keys == before_keys # 아무것도 저장 안 함 - - def total(doc: dict, given: dict) -> Decimal: - got = _post(client, "/api/m01/logic/doc/preview", {"문서": doc, "입력": given}) - assert got["셈"]["셈됨"], got["셈"] - return Decimal(str(got["셈"]["계"])) - - saved = _get(client, "/api/m01/logic/doc", key=STACK)["문서"] - draft = {**preview["문서"], "키": "_새"} # 화면이 보내는 꼴(저장 전 = 빈 키) - picks = [total(saved, {})] - for given in ({}, {"돌": "견치돌", "쌓기": "켜쌓기", "뒷길이": 45}): - assert total(draft, given) == total(saved, given) - picks.append(total(saved, given)) - assert picks[0] != picks[-1] # 옵션이 금액을 바꿈(같음이 빈 대조가 아님) - - -def test_미리보기도_별칭_원문이_부르기가_아니면_막는다(client: TestClient) -> None: - view = _get(client, "/api/m01/logic/formula", key=STACK) - marks = [{**one} for one in view["별칭"]] - marks[0]["원문"] = "아무거나" - got = _post( - client, - "/api/m01/logic/formula/preview", - {"로직": view["로직"], "별칭": marks}, - want=400, - ) - assert "찾기" in str(got["detail"]) - - -def test_정본_로직은_이_길로도_안_바뀐다(client: TestClient) -> None: - """저장은 늘 새 자체 로직(`GX`) — 본뜬 원본 파일은 판본까지 그대로.""" - before = _get(client, "/api/m01/logic", key=STACK) - view = _get(client, "/api/m01/logic/formula", key=STACK) - _post( - client, - "/api/m01/logic/formula/save", - {"로직": view["로직"], "별칭": view["별칭"], "본뜬키": STACK}, - ) - after = _get(client, "/api/m01/logic", key=STACK) - assert after["version"] == before["version"] - assert after["logic"] == before["logic"] diff --git a/resources/tester/test_m01_make.py b/resources/tester/test_m01_make.py index 65c3ee71b..89fa80ee1 100644 --- a/resources/tester/test_m01_make.py +++ b/resources/tester/test_m01_make.py @@ -164,10 +164,15 @@ def test_모르는_소유는_400(client: TestClient) -> None: assert caught.value.status == 400 -def test_만든_자체_로직이_시험_계산에_돈다(client: TestClient) -> None: +def test_만든_자체_로직은_빈_문서로_열리고_목록에_든다(client: TestClient) -> None: + """855 L3 ⓐ — 새 기초 셈은 문서(줄 쌓기) 몫 · 받은 줄의 셈 칸은 안 씀(옛 「시험 계산에 돈다」 걷음).""" made = _new("공용") - got = _post(client, "/api/m01/calc", {"key": made["key"], "inputs": {}}) - assert got["ok"] is True and Decimal(str(got["sums"]["노무비"])) > 0 + got = _get(client, "/api/m01/logic/doc", key=made["key"]) + assert ( + got["새"] is False + and got["파일"] == "수식_자체.json" + and got["문서"]["이름"] == "시험 초안" + ) listed = _get(client, "/api/m01/logics", owner="공용")["logics"] assert made["key"] in [x["키"] for x in listed] diff --git a/resources/tester/test_m01_text.py b/resources/tester/test_m01_text.py index f16852931..0480448e6 100644 --- a/resources/tester/test_m01_text.py +++ b/resources/tester/test_m01_text.py @@ -6,6 +6,7 @@ from __future__ import annotations +import json import re import shutil import sys @@ -45,6 +46,12 @@ def client(tmp_path: Path, monkeypatch) -> TestClient: return TestClient(app) +def _row(file: str, key: str) -> dict: + """옛 로직 줄(같이 쓰기 사본) — `/logic` 답은 머리만(855 L3 ⓐ) · 옛 글 길 시험 몫.""" + rows = json.loads((store.FOLDER / file).read_text(encoding="utf-8"))["줄"] + return next(r for r in rows if r["키"] == key) + + def _inputs(key: str) -> dict: """그 로직의 일괄 시험 입력 한 벌(`check_master.시험입력`).""" row = store.cm.master(REAL).logic(key) @@ -166,7 +173,7 @@ def test_고른_값이_틀리면_그대로_막힘(client: TestClient) -> None: def test_끝수는_줄이_아니라_소계에_붙는다(client: TestClient) -> None: got = client.get("/api/m01/logic", params={"key": STACK}).json() - row = dict(got["logic"], 끝수={"대상": "계", "자리": 0, "방법": "버림"}) + row = dict(_row(got["file"], STACK), 끝수={"대상": "계", "자리": 0, "방법": "버림"}) body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]} cut = client.post("/api/m01/text", json=body).json() assert cut["ok"] is True @@ -301,7 +308,7 @@ def test_조각_로직_부르는_줄_990개_세_비목에_다_걸치고_계산_ 비목이 안 정해진 로직 부르는 줄은 세 비목에 다 걸쳐 보여야 하나, 이 견본(STACK)은 호표 둘 다 비목이 「노무비」로 정해진 인력 줄이라 한 비목에만 걸림 — 그 좁은 경우 확인.""" got = client.get("/api/m01/logic", params={"key": STACK}).json() - row = dict(got["logic"]) + row = dict(_row(got["file"], STACK)) row["호표"] = [dict(row["호표"][0], 요소="LB099999"), dict(row["호표"][1])] body = {"key": STACK, "inputs": _inputs(STACK), "row": row, "file": got["file"]} text = client.post("/api/m01/text", json=body) From 9e38ef0446cc7d830044bf88127eddcfdc654800 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 18 Nov 2026 08:37:59 +0900 Subject: [PATCH 2/2] =?UTF-8?q?refactor(855-E=20L3=E2=93=90):=20M01=20[?= =?UTF-8?q?=EB=A1=9C=EC=A7=81=20=EB=B3=B5=EC=82=AC/=EC=83=9D=EC=84=B1]=20?= =?UTF-8?q?=3D=20=EC=9B=90=EB=B3=B8=20=EC=88=98=EC=8B=9D=20=EB=AC=B8?= =?UTF-8?q?=EC=84=9C=20=EB=B3=B5=EC=A0=9C=20=E2=80=94=20=EC=98=9B=20?= =?UTF-8?q?=EB=B3=84=EC=B9=AD=20=EA=BC=B4=20=EC=8B=9C=ED=8A=B8=20=ED=99=94?= =?UTF-8?q?=EB=A9=B4=20=EA=B1=B7=EC=9D=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - [로직 복사/생성] 누름 = 기본정보 창(있는 askBasicInfo · 원본 값 채움) → /logic/copy 로 원본 문서를 새 자체 GX 문서로 복제 → 그 기초를 줄 쌓기로 엶 - 걷음: 화면 LogicLab_Copy.ts · Logic_Calc.ts(부르는 곳 = 서로뿐) · API fetchLogicFormula · saveLogicFormula · previewLogicFormula · 꼴 셋 · 글 키 · CSS m01copy (서버 길 /logic/formula · save · preview 는 앞 auto 커밋 cce57c298 에서 걷음 · openapi 뜻한 셋만 빠짐) - 시험: test_modal_top_and_add_word 복사 시트 창 줄 뺌(걷은 파일 · CSS 의 글자 대조 줄) Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_UI_LogicLab.ts | 40 +- .../M01_MasterData_UI_LogicLab_Basic.ts | 25 +- .../M01_MasterData_UI_LogicLab_Copy.ts | 373 ------------------ .../M01_MasterData_UI_LogicLab_Style.css | 12 - .../M01_MasterData_UI_LogicLab_Text.ts | 20 +- M01_MasterData/M01_MasterData_UI_Logic_Api.ts | 58 +-- .../M01_MasterData_UI_Logic_Calc.ts | 105 ----- .../M01_MasterData_UI_Logic_Text.ts | 8 - .../tester/test_modal_top_and_add_word.py | 6 +- 9 files changed, 54 insertions(+), 593 deletions(-) delete mode 100644 M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts delete mode 100644 M01_MasterData/M01_MasterData_UI_Logic_Calc.ts diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab.ts b/M01_MasterData/M01_MasterData_UI_LogicLab.ts index 8571dce69..20adf436f 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab.ts +++ b/M01_MasterData/M01_MasterData_UI_LogicLab.ts @@ -6,6 +6,7 @@ * 데이터 흐름(CLAUDE.md 5장) — 고친 것은 캐시(sessionStorage)에 쌓고 [저장] 한 번에 `POST /save`. * 409 = 그 사이 파일이 바뀜 · 422 = 검사 걸림(아무것도 안 씀) — 까닭은 서버 글 그대로 보임. * 머리 단추(804-7 · 요구 687-2) = [신규 로직] · [로직 복사/생성] · [로직 삭제] · [되돌림] · [저장] · 목록에선 [신규 로직]만(요구 693) + * [로직 복사/생성] = 기본정보 창(원본 값) → 원본 수식 문서를 새 자체 기초로 복제(`/logic/copy` · 855 L3 ⓐ) → 그 기초를 엶(줄 쌓기에서 고침) * [저장] = 기본정보 · 별칭(로직 줄 `/save`) + 수식(줄 쌓기 `/logic/doc/save`) 한 번에 · [되돌림] = 둘 다 저장 뒤 상태로 * [로직 삭제] = 확인 → 서버 정본에서 바로(`/logic/remove` — 로직 줄 + 수식 문서 · 부르는 곳 있으면 막고 까닭) → 로직 목록 * ========================================================================== */ @@ -21,6 +22,7 @@ import { } from "@ui/ui_template_elements"; import { ApiError, + copyLogic, fetchLogic, fetchLogicFiles, fetchLogics, @@ -37,7 +39,6 @@ import type { SideHandle } from "./M01_MasterData_UI_Side"; import { tx } from "./M01_MasterData_UI_Logic_Text"; import { buildLabDetail } from "./M01_MasterData_UI_LogicLab_Detail"; import { setLogicOpener } from "./M01_MasterData_UI_LogicLab_Modal"; -import { openCopyScreen } from "./M01_MasterData_UI_LogicLab_Copy"; import { tl } from "./M01_MasterData_UI_LogicLab_Text"; import { askBasicInfo } from "./M01_MasterData_UI_LogicLab_Basic"; import { saveRevised } from "./M01_MasterData_UI_LogicLab_Revise"; @@ -428,6 +429,32 @@ export async function mountM01LogicLab( } }; + /** [로직 복사/생성] — 저장된 원본 문서를 복제(고친 캐시는 안 따라감) · 새 기초를 줄 쌓기로 엶 */ + const onCopy = async (): Promise => { + const row = opened?.row; + if (!opened?.origKey || !row) return void showToast(tl("Copy_NeedOpen"), "info"); + const key = opened.origKey; + const units = [...new Set(allLogics.map((x) => x.결과단위).filter(Boolean))]; + const info = await askBasicInfo(units, { + 이름: row.이름, + 원문번호: row.원문번호 ?? "", + 결과단위: row.결과단위 ?? "", + 출처: row.출처 ?? "", + }); + if (!info || !(await leave())) return; + showLoadingOverlay(); + try { + const got = await copyLogic(key, info); + await reload(); + await open(logicId("자체", got.key), "자체", got.key); + showToast(tl("Copy_Done"), "success"); + } catch (error) { + failed(error); + } finally { + hideLoadingOverlay(); + } + }; + const saveButton = createButton({ label: tx("Bar_Save"), iconStart: "check", @@ -443,16 +470,7 @@ export async function mountM01LogicLab( label: tl("Copy_Open"), variant: "ghost", iconStart: "copy", - onClick: () => - opened?.origKey - ? void openCopyScreen({ - key: opened.origKey, - afterSave: async (newKey) => { - await reload(); - await open(logicId("자체", newKey), "자체", newKey); - }, - }) - : showToast(tl("Copy_NeedOpen"), "info"), + onClick: () => void onCopy(), }); const deleteButton = createButton({ label: tx("Bar_Delete"), diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Basic.ts b/M01_MasterData/M01_MasterData_UI_LogicLab_Basic.ts index e80b01fcf..3c54a83de 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab_Basic.ts +++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Basic.ts @@ -2,6 +2,7 @@ * M01_MasterData_UI_LogicLab_Basic.ts * 「신규 로직」 기본정보 칸 — 이름 · 원문번호 · 결과 단위 · 출처(구분 = 자체). 확인하면 값을 돌려줌 · 취소면 null * 저장은 하지 않음 — 부른 쪽이 빈 시트 줄로 캐시(drafts)에 넣고 [저장] 때 서버가 GX 새 키를 줌. + * [로직 복사/생성]도 이 창(원본 값을 채워 엶 · 855 L3 ⓐ) — 부른 쪽이 `/logic/copy` 로 문서를 복제. * ========================================================================== */ import { currentLanguageIndex } from "@ui/ui_template_locale"; @@ -10,6 +11,7 @@ import { openModal } from "@ui/ui_template_modal"; const TEXT = { Title: ["신규 로직", "New logic"], + CopyTitle: ["로직 복사/생성", "Copy / create logic"], Name: ["이름", "Name"], NamePh: ["예: 돌쌓기 메쌓기(인력)", "e.g. dry stone wall (labour)"], Number: ["원문번호", "Source number"], @@ -31,8 +33,8 @@ export interface BasicInfo { 출처: string; } -/** 기본정보 묻기 — units = 결과 단위 후보(마스터 로직의 결과단위) */ -export function askBasicInfo(units: string[]): Promise { +/** 기본정보 묻기 — units = 결과 단위 후보(마스터 로직의 결과단위) · start = 처음 값(복사 = 원본 값) */ +export function askBasicInfo(units: string[], start?: BasicInfo): Promise { return new Promise((resolve) => { let done = false; const finish = (v: BasicInfo | null): void => { @@ -40,22 +42,33 @@ export function askBasicInfo(units: string[]): Promise { done = true; resolve(v); }; - const name = createInputField({ label: tb("Name"), placeholder: tb("NamePh"), compact: true }); + const name = createInputField({ + label: tb("Name"), + placeholder: tb("NamePh"), + value: start?.이름 ?? "", + compact: true, + }); const number = createInputField({ label: tb("Number"), placeholder: tb("NumberPh"), + value: start?.원문번호 ?? "", compact: true, }); + if (start?.결과단위 && !units.includes(start.결과단위)) units = [start.결과단위, ...units]; const unit = createSelectField({ label: tb("Unit"), options: units.map((u) => ({ value: u, text: u })), - value: units[0] ?? "원", + value: start?.결과단위 || (units[0] ?? "원"), + compact: true, + }); + const source = createInputField({ + label: tb("Source"), + value: start?.출처 || "자체", compact: true, }); - const source = createInputField({ label: tb("Source"), value: "자체", compact: true }); const why = el("p", { className: "ui-text ui-text--muted", attrs: { role: "alert" } }); const modal = openModal({ - title: tb("Title"), + title: tb(start ? "CopyTitle" : "Title"), closeLabel: tb("Close"), beforeClose: () => { finish(null); diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts b/M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts deleted file mode 100644 index e0c99fda3..000000000 --- a/M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts +++ /dev/null @@ -1,373 +0,0 @@ -/* ============================================================================= - * M01_MasterData_UI_LogicLab_Copy.ts - * 복사해서 만들기(PLAN 3-4 · 계약 7장) — 정본·자체 로직을 별칭 꼴 식으로 펴 보이고 - * 줄을 고치거나 더한 뒤 자체 로직(GX)으로 저장. - * - * [본떠 만들기] → GET /logic/formula(별칭 폼) → 별칭 표 바꾸기·로직 부르기 갈래 고르기· - * 식 줄 고치기·더하기 → [시험 계산](POST /logic/formula/preview 가 원문으로 되돌린 줄을 수식 문서로 지어 줌 → - * 문서 셈 `/logic/doc/preview` · 855 2-B4 — 저장하면 지을 문서와 같은 변환) - * → [저장](POST /logic/formula/save) → afterSave 로 새 키를 알림(정본은 손대지 않음). - * ========================================================================== */ - -import { - createButton, - createInputField, - createSelectField, - el, - hideLoadingOverlay, - showLoadingOverlay, - showToast, -} from "@ui/ui_template_elements"; -import { - copyLogic, - fetchLogicFormula, - previewLogicFormula, - saveLogicFormula, - type FormulaAlias, - type FormulaLine, - type LogicRow, -} from "./M01_MasterData_UI_Logic_Api"; -import { buildCalc } from "./M01_MasterData_UI_Logic_Calc"; -import { fetchTables, type TableHead } from "./M01_MasterData_Api_Fetch"; -import { tx } from "./M01_MasterData_UI_Logic_Text"; -import { tl } from "./M01_MasterData_UI_LogicLab_Text"; -import type { FormulaDoc } from "../common_util/common_util_formula_doc"; -import "./M01_MasterData_UI_LogicLab_Style.css"; -import { createBadge } from "@ui/ui_template_badge"; -import { createText } from "@ui/ui_template_text"; -import { openModal } from "@ui/ui_template_modal"; - -const OWNERS = ["현장", "공용"] as const; -const TABLE_GROUPS = ["소요량", "계수"] as const; -const GROUP_LABEL: Record = { - 중간: "중간", - 호표: "호표", - 덧줄: "덧줄", - 결과: "결과", -}; - -export interface CopyOptions { - /** 본뜰 원본 키(정본·자체 둘 다) */ - key: string; - /** 저장 뒤 새 GX 키를 알림 — 밖(LogicLab)이 목록 새로고침·그 키 열기를 함 */ - afterSave: (newKey: string) => void | Promise; -} - -/** 자리표(`호표[0].수량` 등)로 로직 안 그 칸을 읽고 씀 — `master_copy.slots()` 와 같은 자리 */ -function field(row: LogicRow, place: string): { get: () => string; set: (v: string) => void } { - if (place === "결과.식") { - return { - get: () => row.결과?.식 ?? "", - set: (v) => { - if (row.결과) row.결과.식 = v; - }, - }; - } - const m = /^(호표|중간|덧줄)\[(\d+)\]\.(.+)$/.exec(place); - if (!m) return { get: () => "", set: () => {} }; - const [, group, idxStr, col] = m; - const idx = Number(idxStr); - const arr = row[group] as Record[] | undefined; - return { - get: () => (arr?.[idx] ? String(arr[idx][col] ?? "") : ""), - set: (v) => { - if (arr?.[idx]) arr[idx][col] = v; - }, - }; -} - -/** 별칭 원문의 키만 갈아 끼움 — 「찾기(QF000421, …)」 → 「찾기(QF999999, …)」(인자는 그대로) */ -function swapKey(raw: string, newKey: string): string { - return raw.replace(/^(찾기|로직)\(\s*[A-Za-z0-9]+/, `$1(${newKey}`); -} - -/** 표 바꾸기 모달 — 소요량·계수 두 그룹을 함께 찾음 */ -function openTablePick(onPick: (table: TableHead) => void): void { - const search = createInputField({ type: "search", placeholder: tl("Copy_PickSearch") }); - const list = el("div", { className: "m01-logic__pick-list" }); - // 모달 부품 — 제목줄 [닫기] · 바깥 누르기 · Esc · 위 고정 · 찾기 칸에 커서 - const { close } = openModal({ - title: tl("Copy_PickTitle"), - closeLabel: tl("Modal_Close"), - dialogClass: "m01-logic__pick", - backdropClass: "m01-logic__backdrop", - mount: (body) => body.append(search.root, list), - }); - - let timer: number | undefined; - let seq = 0; // 늦게 온 옛 응답은 버림(829-1) - const run = async (): Promise => { - const mine = ++seq; - const q = search.input.value.trim(); - const pages = await Promise.all( - TABLE_GROUPS.map((group) => fetchTables(group, "", "", q, 1, 20)), - ); - if (mine !== seq) return; - const hits = pages.flatMap((p) => p.tables); - list.replaceChildren( - ...(hits.length - ? hits.map((t) => { - const b = el("button", { - className: "m01-logic__pick-row ui-list-row ui-sidebar-row", - attrs: { type: "button", "data-size": "32" }, - children: [ - el("span", { text: `${t.이름 || t.키} · ${t.원문번호 || ""}` }), - el("span", { className: "ui-text ui-text--muted", text: t.키 }), - ], - }); - b.addEventListener("click", () => { - onPick(t); - close(); - }); - return b; - }) - : [el("p", { className: "ui-text ui-text--muted", text: tl("Copy_PickNone") })]), - ); - }; - search.input.addEventListener("input", () => { - window.clearTimeout(timer); - timer = window.setTimeout(() => void run(), 250); - }); - void run(); -} - -function aliasRow(a: FormulaAlias, onSwap: (raw: string) => void, sub: HTMLElement): HTMLElement { - const about = - a.종류 === "찾기" - ? [a.밑이름 || a.참조, Object.keys(a.값칸).join("·")].filter(Boolean).join(" · ") - : [a.밑이름 || a.참조, a.결과단위].filter(Boolean).join(" · "); - return el("div", { - className: "m01lab__box", - children: [ - el("div", { - className: "m01-logic__section-head", - children: [ - el("strong", { text: a.이름 }), - el("span", { className: "ui-text ui-text--muted", text: about }), - ], - }), - el("pre", { className: "m01lab__expr", text: a.원문 }), - sub, - ...(a.종류 === "찾기" - ? [ - createButton({ - label: tl("Copy_Alias_Swap"), - variant: "ghost", - onClick: () => openTablePick((t) => onSwap(swapKey(a.원문, t.키))), - }), - ] - : []), - ], - }); -} - -function logicAliasControls( - a: FormulaAlias, - onForked: (raw: string) => void, -): { root: HTMLElement } { - let forked = false; - const original = a.원문; - const status = el("span", { className: "ui-text ui-text--muted" }); - const refBtn = createButton({ - label: tl("Copy_Alias_Ref"), - variant: "ghost", - onClick: () => { - forked = false; - a.원문 = original; - refresh(); - }, - }); - const forkBtn = createButton({ - label: tl("Copy_Alias_Fork"), - variant: "ghost", - onClick: () => void doFork(), - }); - const refresh = (): void => { - refBtn.disabled = !forked; - forkBtn.disabled = forked; - status.textContent = forked ? tl("Copy_Alias_Forked") : ""; - }; - const doFork = async (): Promise => { - try { - const got = await copyLogic(a.참조); - forked = true; - a.원문 = swapKey(original, got.key); - onForked(a.원문); - refresh(); - } catch (error) { - showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error"); - } - }; - refresh(); - return { root: el("div", { children: [refBtn, forkBtn, status] }) }; -} - -function lineBox(row: LogicRow, line: FormulaLine, onChange: () => void): HTMLElement { - const f = field(row, line.자리); - const box = el("textarea", { className: "ui-input ui-input--sm m01-logic__input m01lab__qty" }); - box.value = f.get(); - box.rows = Math.max(1, Math.ceil(box.value.length / 60)); - box.addEventListener("input", () => { - f.set(box.value); - onChange(); - }); - const tag = [GROUP_LABEL[line.갈래], line.비목].filter(Boolean).join(" · "); - return el("div", { - className: "m01lab__box", - children: [ - el("div", { - className: "m01-logic__section-head", - children: [ - el("strong", { text: line.이름 || line.자리 }), - createBadge(tag, "accent"), - ...(line.단위 - ? [el("span", { className: "ui-text ui-text--muted", text: line.단위 })] - : []), - ], - }), - box, - ], - }); -} - -function addExtra(row: LogicRow, onChange: () => void, redraw: () => void): void { - row.덧줄 = row.덧줄 ?? []; - row.덧줄.push({ 이름: tl("Copy_ExtraName"), 식: "0", 비목: "재료비" }); - onChange(); - redraw(); -} - -/** 복사 화면을 전체 덮는 시트로 엶 */ -export async function openCopyScreen(opt: CopyOptions): Promise { - showLoadingOverlay(); - let got; - try { - got = await fetchLogicFormula(opt.key); - } catch (error) { - hideLoadingOverlay(); - showToast(error instanceof Error ? error.message : tx("Load_Failed"), "error"); - return; - } - hideLoadingOverlay(); - - const row: LogicRow = got.로직; - const marks: FormulaAlias[] = got.별칭; - const nameField = createInputField({ label: tl("Copy_Name"), value: `${row.이름} 복사본` }); - const ownerField = createSelectField({ - label: tl("Copy_Owner"), - options: OWNERS.map((o) => ({ - value: o, - text: o === "현장" ? tl("Copy_Site") : tl("Copy_Shared"), - })), - value: "현장", - }); - - const aliasHost = el("div", { className: "m01-logic__scroll" }); - const linesHost = el("div", { className: "m01-logic__scroll" }); - const calcHost = el("div", { className: "m01lab__calc" }); - const given: Record = {}; // 시험 계산에서 고른 옵션 — 줄을 고쳐도 남음 - let timer: number | undefined; - - const refreshCalc = (): void => { - window.clearTimeout(timer); - timer = window.setTimeout(() => void runPreview(), 300); - }; - const runPreview = async (): Promise => { - try { - // 답의 `문서` = 저장하면 지을 수식 문서(서버 변환 · 못 지음 = null) - const preview = (await previewLogicFormula(row, marks)) as { 문서?: FormulaDoc | null }; - buildCalc(calcHost, preview.문서 ?? null, given); - } catch (error) { - calcHost.replaceChildren(createText(error instanceof Error ? error.message : "", "error")); - } - }; - - const drawLines = (): void => { - linesHost.replaceChildren(...got.줄.map((line) => lineBox(row, line, refreshCalc))); - }; - const drawAliases = (): void => { - aliasHost.replaceChildren( - ...marks.map((a) => { - const sub = - a.종류 === "로직" ? logicAliasControls(a, refreshCalc).root : el("span", { text: "" }); - return aliasRow( - a, - (raw) => { - a.원문 = raw; - refreshCalc(); - }, - sub, - ); - }), - ); - }; - drawLines(); - drawAliases(); - refreshCalc(); - - let close = (): void => {}; - const onSave = async (): Promise => { - showLoadingOverlay(); - try { - const saved = await saveLogicFormula({ - 로직: row, - 별칭: marks, - owner: ownerField.select.value, - 이름: nameField.input.value.trim() || row.이름, - 본뜬키: opt.key, - }); - showToast(tl("Copy_Saved"), "success"); - close(); - await opt.afterSave(saved.key); - } catch (error) { - showToast(error instanceof Error ? error.message : tx("Save_Failed"), "error"); - } finally { - hideLoadingOverlay(); - } - }; - - // 모달 부품 — 제목줄 [취소] · 바깥 누르기 · Esc · 위 고정 · 폭만 복사 시트 곁값 - ({ close } = openModal({ - title: `${tl("Copy_Title")} — ${row.이름}(${opt.key})`, - closeLabel: tl("Copy_Cancel"), - dialogClass: "m01-logic__pick m01copy__sheet", - backdropClass: "m01-logic__backdrop", - mount: (body) => - body.append( - el("div", { - className: "m01copy__head", - children: [nameField.root, ownerField.root], - }), - el("section", { - className: "m01-logic__section", - children: [el("h3", { text: tl("Copy_Aliases") }), aliasHost], - }), - el("section", { - className: "m01-logic__section", - children: [ - el("div", { - className: "m01-logic__section-head", - children: [ - el("h3", { text: tl("Copy_Lines") }), - createButton({ - label: tl("Copy_AddExtra"), - variant: "ghost", - onClick: () => addExtra(row, refreshCalc, drawLines), - }), - ], - }), - linesHost, - ], - }), - el("section", { className: "m01-logic__section", children: [calcHost] }), - el("div", { - className: "m01-logic__pick-bar", - children: [ - el("span", {}), - el("span", {}), - createButton({ label: tl("Copy_Save"), onClick: () => void onSave() }), - ], - }), - ), - })); -} diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Style.css b/M01_MasterData/M01_MasterData_UI_LogicLab_Style.css index db6274746..a12ce5de0 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab_Style.css +++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Style.css @@ -50,18 +50,6 @@ display: none; } -/* 복사해서 만들기(3-4) — 별칭 꼴 식 시트 */ -.ui-modal.m01copy__sheet { - width: min(1040px, 94vw); - --modal-max: 90vh; -} - -.m01copy__head { - display: grid; - grid-template-columns: 2fr 1fr; - gap: var(--spacing-8); -} - .m01lab__own > :first-child { display: none; } diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Text.ts b/M01_MasterData/M01_MasterData_UI_LogicLab_Text.ts index d6002eea5..b76a5f8d9 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab_Text.ts +++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Text.ts @@ -29,25 +29,7 @@ const TEXT = { Pill_Back: ["← 단가산출 기초로 돌아가기", "← Back to unit-price logic"], Copy_Open: ["로직 복사/생성", "Copy / create logic"], Copy_NeedOpen: ["먼저 로직을 고르세요", "Pick a logic first"], - Copy_Title: ["복사해서 만들기", "Copy to edit"], - Copy_Name: ["새 이름", "New name"], - Copy_Owner: ["소유", "Owner"], - Copy_Site: ["현장", "Site"], - Copy_Shared: ["공용", "Shared"], - Copy_Aliases: ["부르는 표·로직", "Tables & logics used"], - Copy_Alias_Swap: ["표 바꾸기", "Change table"], - Copy_Alias_Ref: ["그대로 부르기", "Keep reference"], - Copy_Alias_Fork: ["같이 복사하기", "Copy along"], - Copy_Alias_Forked: ["복사됨", "Copied"], - Copy_Lines: ["식 줄 — 고치거나 더함", "Formula lines — edit or add"], - Copy_AddExtra: ["덧줄 추가", "Add extra line"], - Copy_ExtraName: ["새 덧줄", "New extra line"], - Copy_Save: ["저장(자체 로직)", "Save as mine"], - Copy_Cancel: ["취소", "Cancel"], - Copy_Saved: ["자체 로직으로 저장함", "Saved as your own logic"], - Copy_PickTitle: ["바꿀 표 찾기", "Find a table"], - Copy_PickSearch: ["표 이름·키로 찾기", "Search by table name or key"], - Copy_PickNone: ["찾는 표가 없음", "No matching tables"], + Copy_Done: ["복사해서 새 자체 로직을 만듦", "Copied to a new own logic"], } as const satisfies Record; export type LabTextKey = keyof typeof TEXT; diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts index 11adb2238..1397b2e94 100644 --- a/M01_MasterData/M01_MasterData_UI_Logic_Api.ts +++ b/M01_MasterData/M01_MasterData_UI_Logic_Api.ts @@ -234,60 +234,10 @@ export const removeLogic = ( 개정확인 = false, ): Promise => request("/logic/remove", { key, file, version, 개정확인 }); -/** 본떠 만들기 — 정본·자체 둘 다 본뜸 · 새 키(`GX…`)는 서버가 줌(계약 5장) */ +/** 본떠 만들기 = [복사/생성] — 원본 수식 문서를 새 자체 기초로 복제 · 새 키(`GX…`)는 서버가 줌(855 L3 ⓐ) · + * 이름 · 원문번호 · 결과단위 · 출처 = 기본정보 창 값(빈 글 = 원본 그대로) */ export const copyLogic = ( key: string, + info: { 이름: string; 원문번호: string; 결과단위: string; 출처: string }, ): Promise<{ file: string; version: string; key: string; logic: LogicRow }> => - request("/logic/copy", { key }); - -/** 복사해서 만들기(계약 7장) — 찾기·로직 부르기 한 덩이를 이름 하나(별칭)로 보임 */ -export interface FormulaAlias { - 이름: string; - 종류: "찾기" | "로직"; - 참조: string; - /** 되돌릴 원문 부르기 글 — 저장 때 이 글로 갈아 끼움 */ - 원문: string; - 밑이름: string; - 값칸: Record; - 결과단위: string; - 자리: string[]; -} -export interface FormulaLine { - 자리: string; - 갈래: "중간" | "호표" | "덧줄" | "결과"; - 차례: number; - 이름: string; - 단위: string; - 비목: string; - 식: string; - 출처: string; - 종류?: string; - 요소?: unknown; -} -export interface LogicFormula { - file: string; - version: string; - key: string; - 소유: string; - 로직: LogicRow; - 별칭: FormulaAlias[]; - 줄: FormulaLine[]; -} - -export const fetchLogicFormula = (key: string): Promise => - request(`/logic/formula?${query({ key })}`); - -export const saveLogicFormula = (body: { - 로직: LogicRow; - 별칭: FormulaAlias[]; - owner: string; - 이름?: string; - 본뜬키?: string; -}): Promise<{ file: string; version: string; key: string; logic: LogicRow }> => - request("/logic/formula/save", body); - -/** 저장 전 시험 계산용 — 별칭을 원문으로 되돌린 로직 줄만(저장 안 함) */ -export const previewLogicFormula = ( - 로직: LogicRow, - 별칭: FormulaAlias[], -): Promise<{ logic: LogicRow }> => request("/logic/formula/preview", { 로직, 별칭 }); + request("/logic/copy", { key, ...info }); diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts b/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts deleted file mode 100644 index 9642451d0..000000000 --- a/M01_MasterData/M01_MasterData_UI_Logic_Calc.ts +++ /dev/null @@ -1,105 +0,0 @@ -/* ============================================================================= - * M01_MasterData_UI_Logic_Calc.ts - * 시험 계산(로직 복사 화면 · 855 2-B4) — 저장하면 지을 수식 문서(`/logic/formula/preview` 의 `문서`)를 - * 문서 셈(`POST /m01/logic/doc/preview` · 줄 쌓기 화면과 같은 계산기)으로 셈 · 파일에 안 씀 - * 옵션 가로(`formula_doc_options`) · 합계 상자(`formula_doc_foot`) = 줄 쌓기 화면 부품 그대로 — 금액 = 그 로직 수식 화면 금액 - * 옵션을 바꾸면 바로 다시 셈(늦게 온 옛 답은 버림) - * ========================================================================== */ - -import { API_BASE_URL } from "@config/config_frontend"; -import { el } from "@ui/ui_template_elements"; -import { createText } from "@ui/ui_template_text"; -import type { FormulaDoc } from "../common_util/common_util_formula_doc"; -import type { DocAnswer } from "../common_util/common_util_formula_doc_calc"; -import { formatNumber } from "../common_util/common_util_money"; -import { docFoot } from "../A00_Common/formula_doc_foot"; -import { buildOptions } from "../A00_Common/formula_doc_options"; -import { hiddenByWork } from "../A00_Common/formula_doc_render"; -import "../A00_Common/line_stack.css"; -import { safeReason, tx } from "./M01_MasterData_UI_Logic_Text"; - -/** 그릇마다 셈 차례 — 줄을 고쳐 다시 그려도 늦게 온 옛 답을 버림 */ -const turns = new WeakMap(); - -async function previewDoc(문서: FormulaDoc, 입력: Record): Promise { - const r = await fetch(`${API_BASE_URL}/m01/logic/doc/preview`, { - method: "POST", - credentials: "include", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ 문서: { ...문서, 키: "_새" }, 입력 }), // 저장 전 = 빈 키(줄 쌓기와 같음) - }); - const data = (await r.json().catch(() => ({}))) as { 셈?: DocAnswer; detail?: unknown }; - if (!r.ok || !data.셈) - throw new Error(typeof data.detail === "string" ? data.detail : r.statusText); - return data.셈; -} - -function answerView(doc: FormulaDoc, a: DocAnswer): HTMLElement[] { - const stop = - !a.셈됨 && a.까닭 - ? [ - el("div", { - className: "ui-banner ui-banner--danger m01-logic__reasons", - children: [ - el("strong", { text: tx("Calc_Stopped") }), - el("div", { text: safeReason(a.까닭) }), - ], - }), - ] - : []; - if (!doc.결과) return [...stop, docFoot(a)]; // 줄 쌓기 아래 합계 상자와 같은 부품 - const value = - typeof a.결과 === "number" ? `${formatNumber(a.결과)} ${doc.결과단위 ?? ""}`.trim() : "—"; - return [ - ...stop, - el("dl", { - className: "m01-logic__sums", - children: [el("dt", { text: tx("Calc_Result") }), el("dd", { text: value })], - }), - ]; -} - -/** `doc` = 저장하면 지을 수식 문서(못 지음 = null) · `given` = 고른 옵션(다시 그려도 남음) */ -export function buildCalc( - host: HTMLElement, - doc: FormulaDoc | null, - given: Record, -): void { - const title = el("h3", { text: tx("Calc_Title") }); - const note = el("p", { className: "ui-text ui-text--muted", text: tx("Calc_Draft") }); - if (!doc) { - host.replaceChildren(title, createText(tx("Calc_NoDoc"), "error")); - return; - } - const run = async (): Promise => { - const mine = (turns.get(host) ?? 0) + 1; - turns.set(host, mine); - try { - const answer = await previewDoc(doc, given); - if (turns.get(host) !== mine) return; - const options = buildOptions( - doc, - given, - false, - (k, v, x) => { - // 고르기 글 → 목록 값 그대로(수 45 를 글 「45」 로 보내면 표 줄을 못 찾음 · 줄 쌓기 `usable` 과 같음) - const list = v.연결?.갈래 === "선택" ? (v.연결.목록 ?? []) : []; - given[k] = list.find((o) => String(o) === String(x)) ?? x; - void run(); - }, - undefined, - hiddenByWork(doc, answer), // 줄 쌓기와 같이 — 시간당 식 줄이 안 읽게 된 옵션은 숨김 - ); - host.replaceChildren( - title, - note, - ...(options.length ? [el("div", { className: "fdoc__options", children: options })] : []), - ...answerView(doc, answer), - ); - } catch (error) { - if (turns.get(host) !== mine) return; - host.replaceChildren(title, createText(error instanceof Error ? error.message : "", "error")); - } - }; - void run(); -} diff --git a/M01_MasterData/M01_MasterData_UI_Logic_Text.ts b/M01_MasterData/M01_MasterData_UI_Logic_Text.ts index e5b838867..9bb3a0290 100644 --- a/M01_MasterData/M01_MasterData_UI_Logic_Text.ts +++ b/M01_MasterData/M01_MasterData_UI_Logic_Text.ts @@ -36,14 +36,6 @@ const TEXT = { Head_Note: ["비고", "Note"], Head_Blocked: ["막힌 까닭", "Why blocked"], Formula: ["식", "Formula"], - Calc_Title: ["시험 계산", "Test calculation"], - Calc_Draft: ["고친 줄로 계산(저장 전)", "Using unsaved edits"], - Calc_NoDoc: [ - "수식 문서로 못 바꿈 — 고친 식을 확인하세요", - "Cannot build a formula document — check the edits", - ], - Calc_Stopped: ["멈춤", "Stopped"], - Calc_Result: ["결과", "Result"], Pick_Title: ["요소 찾기", "Find element"], Pick_Search: ["이름·키·원문번호", "Name · key · source no."], Pick_Close: ["닫기", "Close"], diff --git a/resources/tester/test_modal_top_and_add_word.py b/resources/tester/test_modal_top_and_add_word.py index f301e6dc7..84dc9881b 100644 --- a/resources/tester/test_modal_top_and_add_word.py +++ b/resources/tester/test_modal_top_and_add_word.py @@ -39,14 +39,10 @@ def test_공용_모달_위_고정(): def test_따로_둔_모달도_위_고정(): - # M01 고르기 · 복사 · 조달 창 = 모달 부품(553-5) — 위 고정은 공용 .ui-modal 이 냄 - assert "--modal-max: 90vh;" in _block( - _text("M01_MasterData/M01_MasterData_UI_LogicLab_Style.css"), ".ui-modal.m01copy__sheet" - ) + # M01 고르기 · 조달 창 = 모달 부품(553-5) — 위 고정은 공용 .ui-modal 이 냄(복사 시트 창은 855 L3 ⓐ 에서 걷음) for rel in ( "M01_MasterData/M01_MasterData_UI_Pick.ts", "M01_MasterData/M01_MasterData_UI_Logic_PickTable.ts", - "M01_MasterData/M01_MasterData_UI_LogicLab_Copy.ts", ): src = _text(rel) assert "openModal(" in src and "document.body.append(" not in src, rel