diff --git a/M01_MasterData/M01_MasterData_Doc.py b/M01_MasterData/M01_MasterData_Doc.py index 747e295e4..62c84cb3e 100644 --- a/M01_MasterData/M01_MasterData_Doc.py +++ b/M01_MasterData/M01_MasterData_Doc.py @@ -7,6 +7,8 @@ - 읽기 {키} → {문서, 셈, 연결, 파일, 새} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄) - 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음 - 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음) + · 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면 + 빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐) 권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4). """ @@ -20,6 +22,7 @@ from M01_MasterData import M01_MasterData_Store as store import master_doc as md # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤 import master_doc_calc as mc # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_doc_record as mr # noqa: E402 import master_equation_link as link # noqa: E402 @@ -103,9 +106,47 @@ def _file_for(key: str) -> str: return OWN_FILE +def built(key: str) -> dict | None: + """빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None.""" + import master_doc_convert as cv + + files, whole = store.loaded() + for data in files.values(): + if data.get("그룹") != "로직": + continue + for row in data.get("줄") or []: + if str(row.get("키")) == key: + try: + return cv.convert(whole, row)[0] + except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담) + return None + return None + + +def layered(doc: dict, key: str) -> dict: + """848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 · + 다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로.""" + links = ml.Links(store.loaded()[1], {**docs(), key: doc}) + try: + doc = mcv.prune_doc(doc, links) + except ValueError as e: + raise store.StoreError(400, str(e)) from e + cover = doc.get(mcv.COVER) + bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} + base = built(key) + hand = base is not None and ml._norm(bare) != ml._norm(base) + if base is not None and not hand: + bare = base + out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})} + if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례) + out["쌓기"] = out.pop("쌓기") + return out + + def save(doc: dict) -> dict: doc = _check(doc) key = str(doc["키"]).strip() + doc = layered(doc, key) name = _file_for(key) path = folder() / name data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []} diff --git a/M01_MasterData/M01_MasterData_Machine.py b/M01_MasterData/M01_MasterData_Machine.py index 51d3875d8..769fa2b7f 100644 --- a/M01_MasterData/M01_MasterData_Machine.py +++ b/M01_MasterData/M01_MasterData_Machine.py @@ -12,10 +12,8 @@ M01 에서 만든 기계(출처 모두 「자체」)를 지우면 그 번호 기 from __future__ import annotations import copy -import json -import re from decimal import Decimal -from typing import Any +from typing import Any, Callable import master_machine_coef as mc # noqa: E402 (`store` 가 scripts 를 길에 둠) import master_machine_crew as mcrew # noqa: E402 @@ -25,8 +23,7 @@ from M01_MasterData import M01_MasterData_Store as store FILE = "기계.json" OWN_SOURCE = "자체" HOUR_PARTS = ("시간환산", "상여계수", "휴지계수") # 조종원 노임 1/8 × 16/12 × 25/20(CC000336) -_EQ = re.compile(r"EQ\d{6}") -_cache: dict[str, Any] = {"ver": None, "hourly": {}, "uses": None} +_cache: dict[str, Any] = {"ver": None, "hourly": {}} def _rows() -> list[dict]: @@ -37,7 +34,7 @@ def _fresh() -> None: """마스터를 다시 읽었으면(저장 뒤) 셈 보관을 비움.""" ver = id(store.loaded()[1]) if _cache["ver"] != ver: - _cache.update(ver=ver, hourly={}, uses=None) + _cache.update(ver=ver, hourly={}) def _plain(v): @@ -131,15 +128,16 @@ def _family_files() -> dict[str, str]: } -def register(batch: list[dict]) -> None: +def register(batch: list[dict]) -> Callable[[], None]: """[새 기계] 저장 = 꼴 식 「기계」 목록에 그 원문번호 더함 · M01 에서 만든 기계(출처 모두 「자체」)를 - 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길).""" + 지우면 같은 번호 기계가 더 없을 때 목록에서 뺌 — 로직 파일 고침을 같은 저장 묶음에 붙임(정본 저장 길) · + 돌려준 함수 = 저장 뒤 수식 문서 기계 고르기 목록에도 같은 더함 · 뺌(848-5 · 두 목록 한 벌).""" from M02_MasterTemplete import M02_Machine_Hourly as mh # M02 가 M01 을 부름 — 늦게 from M02_MasterTemplete import M02_MyMachine as mym part = next((p for p in batch if p.get("file") == FILE), None) if part is None: - return + return lambda: None rows = _rows() gone = {str(c.get("key")) for c in part.get("changes") or [] if c.get("op") == "delete"} add: dict[str, list[str]] = {} @@ -163,7 +161,7 @@ def register(batch: list[dict]) -> None: ): drop.add(code) if not add and not drop: - return + return lambda: None files = _family_files() for name in dict.fromkeys(files.values()): changes = [] @@ -180,54 +178,29 @@ def register(batch: list[dict]) -> None: changes.append({"op": "edit", "key": logic["키"], "row": new}) if changes: batch.append({"file": name, "version": store.read(name)[1], "changes": changes}) + return lambda: _register_docs(add, drop) -# ── 쓰는 곳 ───────────────────────────────────────────────────────── -def _logic_index() -> tuple[dict[str, list[str]], dict[str, list[str]]]: - """(원문번호 → 로직 「키 이름」 · 기계 키 → 로직) — 기계 고르기 · 식 안 EQ 키.""" - _fresh() - if _cache["uses"] is None: - by_code: dict[str, list[str]] = {} - by_key: dict[str, list[str]] = {} - for data in store.loaded()[0].values(): - if data.get("그룹") != "로직": - continue - for row in data.get("줄") or []: - label = f"로직 {row.get('키')} {row.get('이름') or ''}".strip() - for i in row.get("입력") or []: - if i.get("이름") == "기계": - for c in i.get("고르기") or []: - by_code.setdefault(str(c), []).append(label) - text = json.dumps(row, ensure_ascii=False, default=str) - for k in set(_EQ.findall(text)): - by_key.setdefault(k, []).append(label) - _cache["uses"] = (by_code, by_key) - return _cache["uses"] +def _register_docs(add: dict[str, list[str]], drop: set[str]) -> None: + """수식 문서의 「기계」 고르기 목록에 로직 목록과 같은 더함 · 뺌 — 바뀐 파일만 다시 씀.""" + import master_doc_link as ml # noqa: E402 + + for path in sorted(ml.FOLDER.glob("수식_*.json")): + data, hit = ml.load_file(path), False + for doc in data.get("줄") or []: + for v in doc.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") != "선택" or v.get("이름") != "기계": + continue + codes = [c for c in link.get("목록") or [] if str(c) not in drop] + codes += [c for c in add.get(str(doc.get("키")), []) if c not in codes] + if codes != link.get("목록"): + link["목록"], hit = codes, True + if hit: + path.write_text(ml.dump(data), encoding="utf-8", newline="\n") -def uses(key: str) -> list[str]: - """그 기계를 쓰는 곳 — 로직(기계 고르기 · 식) · M02 단가산출(사본 · 줄에 키).""" - from M02_MasterTemplete import M02_Template_Layers as layers # M02 가 M01 을 부름 — 늦게 - - row = next((r for r in _rows() if r.get("키") == key), None) - if row is None: - raise store.StoreError(404, f"없는 기계 「{key}」") - by_code, by_key = _logic_index() - code = str(row.get("원문번호") or "") - out = list(dict.fromkeys([*(by_code.get(code, []) if code else []), *by_key.get(key, [])])) - mark = f'"{key}'.encode() - for where, path in layers.layer_files("sangeun"): - try: - raw = path.read_bytes() - except OSError: - continue - if mark in raw: - try: - name = json.loads(raw).get("이름") or path.stem - except ValueError: - name = path.stem - out.append(f"M02 단가산출 {where} {name}") - return out +# ── 쓰는 곳 = `M01_MasterData_Machine_Uses`(수식 문서 기준 · 848-5) ────────────── # ── 비슷한 기계 찾기 · 한 줄 ───────────────────────────────────────── diff --git a/M01_MasterData/M01_MasterData_Machine_Api.ts b/M01_MasterData/M01_MasterData_Machine_Api.ts index b86155c3a..6273a0b39 100644 --- a/M01_MasterData/M01_MasterData_Machine_Api.ts +++ b/M01_MasterData/M01_MasterData_Machine_Api.ts @@ -1,12 +1,13 @@ /* ============================================================================= * M01_MasterData_Machine_Api.ts - * M01 기계 화면 서버 호출(PLAN 821-2) — 양식 목록 · 시간당 경비 · 쓰는 곳 · 비슷한 기계 찾기 · 한 줄. + * M01 기계 화면 서버 호출(PLAN 821-2) — 양식 목록 · 시간당 경비 · 쓰는 곳 · 저장 전 영향(848-5) · + * 비슷한 기계 찾기 · 한 줄. * 서버 = `M01_MasterData_Machine.py` · 시스템 관리자만. * ========================================================================== */ import { API_BASE_URL } from "@config/config_frontend"; import type { MachinePick } from "../common_util/common_util_machine_sheet"; -import type { Row } from "./M01_MasterData_Api_Fetch"; +import type { FileChanges, Row } from "./M01_MasterData_Api_Fetch"; export interface MachineLists { fuels: MachinePick[]; @@ -47,8 +48,49 @@ export const fetchMachineLists = (fresh = false): Promise => { export const fetchMachineHourly = (keys: string[]): Promise> => keys.length ? get("/hourly", { keys: keys.join(",") }) : Promise.resolve({}); -export const fetchMachineUses = async (key: string): Promise => - (await get<{ uses: string[] }>("/uses", { key })).uses; +/** 단가산출 층별 수(이름 없음 — 남의 층 이름 안 냄) */ +export type LayerCounts = Record<"마스터" | "회사" | "개인" | "프로젝트", number>; + +/** 쓰는 곳(848-5 · 수식 문서 기준) — uses = 직접 쓰는 기초 글 */ +export interface MachineUses { + uses: string[]; + 직접: number; + 기본: number; + 사슬: number; + 고침: { 기초: number; 단가산출: number; 위층: number }; + 단가산출: LayerCounts; +} + +export const fetchMachineUses = (key: string): Promise => get("/uses", { key }); + +/** 저장 전 영향(848-5) — 기계마다 수 · 금액 바뀐 기초 수 · 크게 바뀐 다섯 */ +export interface MachineImpact { + 기계: { + 키: string; + 이름: string; + 규격: string; + 칸: string[]; + 직접: number; + 사슬: number; + 고침: { 기초: number; 단가산출: number; 위층: number }; + 단가산출: LayerCounts; + }[]; + 바뀜: number; + 셈: number; + 위: { 키: string; 이름: string; 단위: string; 전: number | null; 후: number | null }[]; +} + +export async function fetchMachineImpact(files: FileChanges[]): Promise { + const res = await fetch(`${API_BASE_URL}/m01/machine/impact`, { + method: "POST", + credentials: "include", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ files }), + }); + const body = (await res.json()) as MachineImpact & { detail?: unknown }; + if (!res.ok) throw new Error(String(body.detail ?? `HTTP ${res.status}`)); + return body; +} export const findMachines = async (q: string): Promise => (await get<{ rows: Row[] }>("/find", { q })).rows; diff --git a/M01_MasterData/M01_MasterData_Machine_Impact.py b/M01_MasterData/M01_MasterData_Machine_Impact.py new file mode 100644 index 000000000..c7a587f78 --- /dev/null +++ b/M01_MasterData/M01_MasterData_Machine_Impact.py @@ -0,0 +1,166 @@ +"""M01 기계 저장 전 영향 목록(PLAN 848-5 · 요구서 889 6 장) — [저장] 전에 확인창이 부름 · 쓰기 없음. + +몸 = 페이지 [저장] 묶음 그대로(`/save` 와 같은 꼴) — 기계 파일의 고침 줄만 봄(새 기계 · 지움 = 영향 없음). +고친 줄은 저장 때와 같은 손질(`Machine.fix` — 계수 다시 셈)을 거친 값으로 셈. 값 칸이 같으면 그 기계 뺌. +기계마다 = 쓰는 기초 직접 · 부름 사슬 · 그 칸을 따로 고쳐 둔 곳(기초 · 단가산출 ② 내 고침 · 위 층 ① 따로) · +쓰는 단가산출 층별 수 +(프로젝트 사본 = 안 바뀜 · 따로 셈). +금액 = 고친 기계를 얹은 마스터(얕은 복사 — 정본 기억은 안 건드림)로 영향 기초(직접 + 부름 사슬)만 +기본 옵션으로 전 · 후 다시 셈(`master_doc_calc.calc`) → 바뀐 기초 수 · 가장 크게(비율) 바뀐 다섯. +""" + +from __future__ import annotations + +import copy +from decimal import Decimal +from typing import Any + +import master_doc_calc as mc # noqa: E402 (`store` 가 scripts 를 길에 둠) +import master_doc_link as ml # noqa: E402 + +from M01_MasterData import M01_MasterData_Machine as machine +from M01_MasterData import M01_MasterData_Machine_Uses as mu +from M01_MasterData import M01_MasterData_Store as store + +TOP = 5 +_BASE: dict[str, Any] = {} +LINE_FIELDS = { + "인력": "조종원", + **{k: "조종원" for k in ("조종원", "조종원직종")}, + "잡재료율": "잡품", +} + + +def same(a: Any, b: Any) -> bool: + """값 같음 — 수는 수로(10000 = 10000.0) · 묶음 · 목록은 칸마다.""" + if isinstance(a, dict) and isinstance(b, dict): + return a.keys() == b.keys() and all(same(a[k], b[k]) for k in a) + if isinstance(a, list) and isinstance(b, list): + return len(a) == len(b) and all(same(x, y) for x, y in zip(a, b)) + num = (int, float, Decimal) + if isinstance(a, num) and isinstance(b, num) and not isinstance(a, bool): + return Decimal(str(a)) == Decimal(str(b)) + return a == b + + +def changed_fields(old: dict, new: dict) -> list[str]: + """값 칸 가운데 다른 것.""" + a, b = old or {}, new or {} + return [k for k in dict.fromkeys([*a, *b]) if not same(a.get(k), b.get(k))] + + +def cover_hits(covers: dict[str, list[str]], names: tuple[str, ...], fields: list[str]) -> bool: + """덮음 {입력 글: 칸} 이 그 기계(`names` = 원문번호 · 키)의 바뀐 칸을 덮는지.""" + want = {LINE_FIELDS.get(f, f) for f in fields} + return any(want & set(covers.get(n) or ()) for n in names) + + +def _edits(batch: list[dict]) -> dict[str, dict]: + """기계 고침 줄 {키: 손질한 줄} — 저장과 같은 `fix`(묶음은 복사본).""" + part = next((p for p in batch if p.get("file") == machine.FILE), None) + if not part: + return {} + part = copy.deepcopy(part) + part["changes"] = [ + c + for c in part.get("changes") or [] + if c.get("op") == "edit" and isinstance(c.get("row"), dict) + ] + machine.fix(part) + return {str(c["key"]): c["row"] for c in part["changes"]} + + +def _patched(whole, rows: dict[str, dict]): + """고친 기계 줄을 얹은 마스터 — 색인 묶음만 새로(줄 · 다른 색인은 같이 씀).""" + eq, nums = dict(whole.index.get("EQ") or {}), dict(whole.numbers.get("EQ") or {}) + for key, row in rows.items(): + old = eq.get(key) + eq[key] = row + code = str(row.get("원문번호") or "") + if code and nums.get(code) is old: + nums[code] = row + out = copy.copy(whole) + out.index = {**whole.index, "EQ": eq} + out.numbers = {**whole.numbers, "EQ": nums} + return out + + +def _amount(doc: dict, links, memo: dict): + got = mc.calc(doc, links, {}, memo=memo) + return got.get("계") if "계" in got else got.get("결과") + + +def impact(batch: list[dict]) -> dict[str, Any]: + """{기계: [{키, 이름, 규격, 칸, 직접, 사슬, 고침{기초, 단가산출}, 단가산출{층: 수}}], 바뀜, 셈, 위}.""" + whole = store.loaded()[1] + stored = whole.index.get("EQ") or {} + rows, out = {}, [] + idx = mu.doc_index() + for key, row in _edits(batch).items(): + old = stored.get(key) + fields = changed_fields((old or {}).get("값"), row.get("값")) if old else [] + if not fields: + continue + rows[key] = {**row, "값": store._dec(row["값"])} + code = str(old.get("원문번호") or "") + direct = idx["직접"].get(code, set()) + reach = mu.chain(direct, idx["부름"]) + names = (code, key) + sks = mu.sk_users(key, code, set()) + out.append( + { + "키": key, + "이름": old.get("이름"), + "규격": old.get("규격"), + "칸": fields, + "직접": len(direct), + "사슬": len(reach - direct), + "고침": { + "기초": sum(1 for c in idx["덮음"].values() if cover_hits(c, names, fields)), + "단가산출": sum(1 for r in sks if cover_hits(r["덮음"], names, fields)), + "위층": sum(1 for r in sks if cover_hits(r["위덮음"], names, fields)), + }, + "영향": reach, + "단가산출키": (key, code), + } + ) + if not out: + return {"기계": [], "바뀜": 0, "셈": 0, "위": []} + docs = idx["docs"] + reach = set().union(*(m.pop("영향") for m in out)) + if _BASE.get("docs") is not docs or _BASE.get("whole") is not whole: # 「전」 셈 = 판마다 한 번 + _BASE.clear() + _BASE.update(docs=docs, whole=whole, links=ml.Links(whole, docs), memo={}, amount={}) + after, memo_b = ml.Links(_patched(whole, rows), docs), {} + moved = [] + for k in sorted(reach): + if k not in _BASE["amount"]: + _BASE["amount"][k] = _amount(docs[k], _BASE["links"], _BASE["memo"]) + a, b = _BASE["amount"][k], _amount(docs[k], after, memo_b) + if a != b: + rate = ( + abs(b - a) / abs(a) + if isinstance(a, Decimal) and isinstance(b, Decimal) and a + else Decimal(1) + ) + moved.append((rate, k, a, b)) + moved.sort(key=lambda m: (-m[0], m[1])) + changed = {m[1] for m in moved} + for m in out: # 쓰는 단가산출 = 사본 · 덮음 · 바탕이 금액 바뀐 기초 + key, code = m.pop("단가산출키") + m["단가산출"] = mu.layer_counts(mu.sk_users(key, code, changed)) + return { + "기계": out, + "바뀜": len(moved), + "셈": len(reach), + "위": [ + { + "키": k, + "이름": docs[k].get("이름"), + "단위": docs[k].get("결과단위"), + "전": a, + "후": b, + } + for _rate, k, a, b in moved[:TOP] + ], + } diff --git a/M01_MasterData/M01_MasterData_Machine_Uses.py b/M01_MasterData/M01_MasterData_Machine_Uses.py new file mode 100644 index 000000000..63cbfa6e6 --- /dev/null +++ b/M01_MasterData/M01_MasterData_Machine_Uses.py @@ -0,0 +1,279 @@ +"""기계 쓰는 곳 색인(PLAN 848-5 · 요구서 889 6 장) — 수식 문서 기준 · 단가산출 역색인 · 덮음 세기. + +기초(수식 문서) 색인 — 문서 파일 자국 · M01 판이 같으면 다시 안 셈(프로세스 기억 · 1 초 안): + 직접 = 기계 고르기 목록에 듦 · 부름 입력 값에 박힘(`'0201-0020'` — 입력 이름 무관 · 집게 · 브레이커) · + EQ 요소 키 + 기본 = 직접 가운데 기본 선택(고르기 `값`) · 박힌 입력 · EQ 요소 — 그 기계를 기본으로 탐 + 사슬 = 직접 문서를 부르는 문서(거슬러 닫힘 · 직접 뺌 · 고름에 달림 = 상한) + 덮음 = 기초 `기계덮음` 의 기계 입력 글 → 덮은 칸 +단가산출(SK) 색인 — 모든 층 + 프로젝트 사본 · 파일 자국이 같으면 기억 그대로(SK 저장 = 자국 바뀜 = + 그 파일만 다시 읽음) · 파생 저장본 storage `_derived/m01_machine_uses/`(지워도 다시 지음): + 기계 = 사본 단가 줄의 EQ 키(그 SK 가 지금 고름으로 실제 쓰는 기계 · 내 기계 EQP 도) + 바탕 = 원본 키 · 바탕 로직 · 부름 문서 · 문서의 단가산출 연결 키(기초 → 단가산출 역색인) + 덮음 = `COVERS` 길마다 기계 입력 글 → 덮은 칸 — 덮음(② 내 고침 `수식.문서.기계덮음`) · + 위덮음(① 위 층 고침 `수식.위덮음` · 848-1 계약) — 「따로 고쳐 둔 곳」 = ② 만 · ① 은 따로 셈 +덮은 칸 이름 = 값 칸 이름 · 줄 묶음(조종원 · 잡품 · 그 밖 덮음 머리 칸). +읽기만 — 기계 · 문서 · SK 를 고치지 않음. 이름은 기초만 냄 — 단가산출은 층별 수만(남의 층 이름 안 냄). +""" + +from __future__ import annotations + +import json +import os +import re +import threading +from pathlib import Path +from typing import Any + +from common_util.common_util_derived_store import derived_dir, file_stamp, read_derived +from common_util.common_util_json import atomic_write_json +from M01_MasterData import M01_MasterData_Doc as docmod +from M01_MasterData import M01_MasterData_Store as store + +COVER = "기계덮음" +COVERS: dict[str, tuple[str, ...]] = { # SK 안 덮음 칸 길(848-1 계약) + "덮음": ("수식", "문서", COVER), # ② 내 고침 + "위덮음": ("수식", "위덮음"), # ① 위 층 고침(기초에서 고친 것) +} +PRICE_PARTS = ("수식", "사본") # 사본 단가 줄이 든 칸(수식 길 · 옛 칸) +KIND, SHAPE = "m01_machine_uses", 2 # 기록 꼴이 바뀌면 올림 +_EQ = re.compile(r"EQ\d{6}") +_LOCK = threading.RLock() +_DOC: dict[str, Any] = {} +_SK: dict[str, Any] = {} + + +# ── 기초 색인 ───────────────────────────────────────────────────────── +def _machines(whole) -> dict[str, list[str]]: + """원문번호 → 기계 키(번호 겹침 = 여럿).""" + out: dict[str, list[str]] = {} + for key, row in (whole.index.get("EQ") or {}).items(): + out.setdefault(str(row.get("원문번호") or ""), []).append(key) + return out + + +def cover_of(doc: Any) -> dict[str, list[str]]: + """덮음 묶음 {기계 입력 글: {값?: {칸}, 조종원?, 잡품?, …}} → {입력 글: 덮은 칸 이름}.""" + out: dict[str, list[str]] = {} + if not isinstance(doc, dict): + return out + for text, one in doc.items(): + if not isinstance(one, dict): + continue + names = [*(one.get("값") or {})] + [k for k in one if k != "값"] + if names: + out[str(text).strip("'")] = names + return out + + +def _scan(doc: dict, codes: dict[str, str]) -> tuple[set[str], set[str], set[str]]: + """문서 하나 → (직접 원문번호, 기본 원문번호, 부르는 문서 키) — `codes` = 원문번호 · 키 → 원문번호.""" + direct: set[str] = set() + default: set[str] = set() + calls: set[str] = set() + for v in doc.get("변수") or []: + link = v.get("연결") or {} + kind = link.get("갈래") + if kind == "선택": + for x in link.get("목록") or []: + if isinstance(x, str) and x in codes: + direct.add(codes[x]) + if str(link.get("값")) == x: + default.add(codes[x]) + elif kind == "요소" and _EQ.fullmatch(str(link.get("키") or "")): + key = str(link["키"]) + code = codes.get(key, key) + direct.add(code) + default.add(code) + elif kind == "단가산출": + if link.get("키"): + calls.add(str(link["키"])) + for t in (link.get("입력") or {}).values(): + t = str(t).strip("'") + if t in codes: + direct.add(codes[t]) + default.add(codes[t]) + return direct, default, calls + + +def doc_index() -> dict[str, Any]: + """{직접: {원문번호: {문서}}, 기본: …, 부름: {문서: {부르는 문서}}, 덮음: {문서: {입력 글: 칸}}, 문서}.""" + docs, whole = docmod.docs(), store.loaded()[1] + with _LOCK: + if _DOC.get("docs") is docs and _DOC.get("whole") is whole: + return _DOC + numbers = _machines(whole) + codes = {c: c for c in numbers} | {k: c for c, ks in numbers.items() for k in ks} + direct: dict[str, set[str]] = {} + default: dict[str, set[str]] = {} + callers: dict[str, set[str]] = {} + covers: dict[str, dict[str, list[str]]] = {} + for key, doc in docs.items(): + d, b, calls = _scan(doc, codes) + for c in d: + direct.setdefault(c, set()).add(key) + for c in b: + default.setdefault(c, set()).add(key) + for target in calls: + callers.setdefault(target, set()).add(key) + if got := cover_of(doc.get(COVER)): + covers[key] = got + _DOC.clear() + _DOC.update(docs=docs, whole=whole, 직접=direct, 기본=default, 부름=callers, 덮음=covers) + return _DOC + + +def chain(seed: set[str], callers: dict[str, set[str]]) -> set[str]: + """`seed` 를 (거슬러) 부르는 문서 전부 — `seed` 포함.""" + seen, todo = set(seed), list(seed) + while todo: + for c in callers.get(todo.pop(), ()): + if c not in seen: + seen.add(c) + todo.append(c) + return seen + + +# ── 단가산출 색인 ───────────────────────────────────────────────────── +def _sk_files() -> list[tuple[str, Path]]: + """(층, 파일) — 마스터 · 회사 · 개인 + 프로젝트 사본(`<회사>/<사용자>/<프로젝트>/templates/sangeun`).""" + from M02_MasterTemplete import M02_Template_Layers as layers # M02 가 M01 을 부름 — 늦게 + + out = [(where.split()[0], path) for where, path in layers.layer_files("sangeun")] + for company in _dirs(layers.storage_root(), digits=True): # glob 은 storage 를 다 훑어 느림 + for user in _dirs(company, digits=True): + for project in _dirs(user): + folder = project / layers.TEMPLATES_DIRNAME / "sangeun" + if folder.is_dir(): + out += [("프로젝트", p) for p in sorted(folder.glob("[!._]*.json"))] + return out + + +def _dirs(folder: Path, digits: bool = False) -> list[Path]: + try: + return [ + Path(e.path) + for e in os.scandir(folder) + if e.is_dir() and (e.name.isdigit() or not digits and not e.name.startswith(("_", "."))) + ] + except OSError: + return [] + + +def sk_record(sk: dict) -> dict[str, Any]: + """SK 하나 → {키, 이름, 기계, 바탕, 덮음, 위덮음}.""" + form = sk.get("수식") if isinstance(sk.get("수식"), dict) else {} + machines = { + str(row.get("키")) + for part in PRICE_PARTS + for row in (sk.get(part) or {}).get("단가") or [] + if str(row.get("키") or "").startswith("EQ") + } + base = { + str((sk.get("바탕") or {}).get("로직") or ""), + str((form.get("원본") or {}).get("키") or ""), + } + base |= {str(k) for k in form.get("부름") or {}} + for v in (form.get("문서") or {}).get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") == "단가산출" and link.get("키"): + base.add(str(link["키"])) + covers: dict[str, dict[str, list[str]]] = {} + for name, route in COVERS.items(): + node: Any = sk + for step in route: + node = node.get(step) if isinstance(node, dict) else None + covers[name] = cover_of(node) + return { + "키": sk.get("키"), + "이름": sk.get("이름"), + "기계": sorted(machines), + "바탕": sorted(base - {""}), + **covers, + } + + +def sk_index() -> list[dict[str, Any]]: + """[{층, 파일, 키, 이름, 기계, 바탕, 덮음, 위덮음}] — 자국이 같은 파일은 기억 그대로.""" + from M02_MasterTemplete import M02_Template_Layers as layers + + root = layers.storage_root() + with _LOCK: + if _SK.get("root") != root: + got = read_derived(root, KIND, f"sk{SHAPE}") + _SK.update(root=root, files=dict((got or {}).get("value") or {})) + files: dict[str, list] = _SK["files"] + out, seen, dirty = [], set(), False + for layer, path in _sk_files(): + text, stamp = str(path), file_stamp(path) + seen.add(text) + hit = files.get(text) + if not (isinstance(hit, list) and len(hit) == 2 and hit[0] == stamp): + try: + hit = [stamp, sk_record(json.loads(path.read_bytes()))] + except (OSError, ValueError, AttributeError): + hit = [stamp, None] + files[text], dirty = hit, True + if hit[1]: + out.append({"층": layer, "파일": text, **hit[1]}) + for text in [t for t in files if t not in seen]: + del files[text] + dirty = True + if dirty: + try: + atomic_write_json( + derived_dir(root, KIND) / f"sk{SHAPE}.json", + {"key": f"sk{SHAPE}", "value": files}, + ) + except OSError: # 파생 저장본 — 못 써도 다음에 다시 셈 + pass + return out + + +def layer_counts(rows: list[dict]) -> dict[str, int]: + out = {"마스터": 0, "회사": 0, "개인": 0, "프로젝트": 0} + for r in rows: + out[r["층"]] = out.get(r["층"], 0) + 1 + return out + + +def sk_users(key: str, code: str, docs: set[str]) -> list[dict]: + """그 기계를 쓰는 SK — 사본 단가에 키 · 덮음에 입력 글 · 바탕이 `docs` 에 듦.""" + return [ + r + for r in sk_index() + if key in r["기계"] + or any(n in r.get(c) or {} for c in COVERS for n in (code, key)) + or docs & set(r["바탕"]) + ] + + +# ── 쓰는 곳 ───────────────────────────────────────────────────────── +def uses(key: str) -> dict[str, Any]: + """M01 기계 상세 「쓰는 곳」 — {uses: 직접 기초 글, 직접, 기본, 사슬, 고침{기초, 단가산출}, 단가산출{층: 수}}.""" + whole = store.loaded()[1] + row = (whole.index.get("EQ") or {}).get(key) + if row is None: + raise store.StoreError(404, f"없는 기계 「{key}」") + code = str(row.get("원문번호") or "") + idx = doc_index() + direct = idx["직접"].get(code, set()) + default = idx["기본"].get(code, set()) + docs = idx["docs"] + reach = chain(direct, idx["부름"]) + sks = sk_users(key, code, direct) + return { + "uses": [ + f"기초 {k} {docs[k].get('이름') or ''}".strip() + (" · 기본" if k in default else "") + for k in sorted(direct) + ], + "직접": len(direct), + "기본": len(default), + "사슬": len(reach - direct), + "고침": { + "기초": sum(1 for c in idx["덮음"].values() if code in c or key in c), + "단가산출": sum(1 for r in sks if code in r["덮음"] or key in r["덮음"]), + "위층": sum(1 for r in sks if code in r["위덮음"] or key in r["위덮음"]), + }, + "단가산출": layer_counts(sks), + } diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index cc47eac9a..1adce2350 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -15,6 +15,8 @@ from pydantic import BaseModel from M01_MasterData import M01_MasterData_Doc as doc_screen from M01_MasterData import M01_MasterData_Equation as equation from M01_MasterData import M01_MasterData_Machine as machine +from M01_MasterData import M01_MasterData_Machine_Impact as machine_impact +from M01_MasterData import M01_MasterData_Machine_Uses as machine_uses from M01_MasterData import M01_MasterData_Parts as parts from M01_MasterData import M01_MasterData_Sheet as line_sheet from M01_MasterData import M01_MasterData_Store as store @@ -274,7 +276,14 @@ def get_machine_hourly(keys: str) -> dict: @router.get("/machine/uses") def get_machine_uses(key: str) -> dict: - return {"uses": _call(machine.uses, key)} + """쓰는 곳 — 수식 문서 기준 직접 · 기본 · 부름 사슬 · 고침 · 단가산출 층별 수(848-5).""" + return _call(machine_uses.uses, key) + + +@router.post("/machine/impact") +def post_machine_impact(body: SaveBody) -> dict: + """[저장] 전 영향 목록 — 몸 = /save 묶음 · 쓰기 없음(848-5).""" + return _call(machine_impact.impact, [f.model_dump() for f in body.files]) @router.get("/machine/find") diff --git a/M01_MasterData/M01_MasterData_Store_Make.py b/M01_MasterData/M01_MasterData_Store_Make.py index 86b3eb86a..b0284bbec 100644 --- a/M01_MasterData/M01_MasterData_Store_Make.py +++ b/M01_MasterData/M01_MasterData_Store_Make.py @@ -294,7 +294,9 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: row.update(별칭=text) if text else row.pop("별칭") machine.fix(part) # 기계 줄 = 계수 서버 재계산 · 단위 · 출처 채움(821-2) _keep_same(part) - machine.register(batch) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침) + docs_too = machine.register( + batch + ) # [새 기계] = 꼴 식 목록 등록(822-2 · 개정확인 밖 — 자동 고침) fresh = False for part in batch: if part.get("file") != OWN: @@ -314,6 +316,7 @@ def save(batch: list[dict], confirmed: bool = False) -> dict: if fresh: _own_path().unlink(missing_ok=True) raise + docs_too() # 수식 문서 기계 고르기 목록도 같게(848-5) added = [ {"file": f, "key": k} for f, old in before.items() for k in _file_keys(f) if k not in old ] diff --git a/M01_MasterData/M01_MasterData_UI_Machine.css b/M01_MasterData/M01_MasterData_UI_Machine.css index 9e6d2deec..c7498e470 100644 --- a/M01_MasterData/M01_MasterData_UI_Machine.css +++ b/M01_MasterData/M01_MasterData_UI_Machine.css @@ -80,3 +80,11 @@ table.m01-master__grid.m01-machine__grid { color: var(--color-text-muted); opacity: 0.6; } + +/* 저장 전 영향 확인창(848-5) — 기계마다 묶음 · 표 */ +.m01-machine-impact, +.m01-machine-impact__one { + display: flex; + flex-direction: column; + gap: var(--spacing-8); +} diff --git a/M01_MasterData/M01_MasterData_UI_MachineDetail.ts b/M01_MasterData/M01_MasterData_UI_MachineDetail.ts index e398dcde7..44f689d12 100644 --- a/M01_MasterData/M01_MasterData_UI_MachineDetail.ts +++ b/M01_MasterData/M01_MasterData_UI_MachineDetail.ts @@ -29,6 +29,7 @@ import { fetchMachineUses, findMachines, type MachineLists, + type MachineUses, } from "./M01_MasterData_Machine_Api"; import type { Pick } from "./M01_MasterData_UI_Side"; @@ -237,15 +238,31 @@ async function build(host: HTMLElement, opts: MachineDetailOptions, alive: () => }; paintMeta(); - /* --- 쓰는 곳 --- */ + /* --- 쓰는 곳(848-5 · 수식 문서 기준) --- */ const usesBox = el("section", { className: "m01-machine-detail__uses" }); - let uses: string[] = []; + let uses: MachineUses | null = null; + const usedCount = (): number => { + const sk = uses?.단가산출; + return uses && sk ? uses.직접 + uses.사슬 + sk.마스터 + sk.회사 + sk.개인 + sk.프로젝트 : 0; + }; + const usesLines = (u: MachineUses): string[] => { + const sk = u.단가산출; + return [ + `기초 직접 ${u.직접}(기본 선택 ${u.기본}) · 부름 사슬 ${u.사슬}`, + `단가산출 마스터 ${sk.마스터} · 회사 ${sk.회사} · 개인 ${sk.개인} · 프로젝트 ${sk.프로젝트}`, + `따로 고쳐 둔 곳 — 기초 ${u.고침.기초} · 단가산출 내 고침 ${u.고침.단가산출} · 위 층 고침 ${u.고침.위층}`, + ]; + }; + const usesText = (u: MachineUses): string => usesLines(u).join("\n"); const paintUses = (): void => { usesBox.replaceChildren( - el("strong", { text: `${L("M01_MachineUses")} ${uses.length}` }), - uses.length - ? el("ul", { children: uses.map((u) => el("li", { text: u })) }) - : createText(L("M01_MachineNoUses")), + el("strong", { text: `${L("M01_MachineUses")} ${usedCount()}` }), + ...(uses && usedCount() + ? [ + ...usesLines(uses).map((t) => createText(t)), + el("ul", { children: uses.uses.map((u) => el("li", { text: u })) }), + ] + : [createText(L("M01_MachineNoUses"))]), ); }; if (key) @@ -272,8 +289,8 @@ async function build(host: HTMLElement, opts: MachineDetailOptions, alive: () => }); const del = createButton({ label: L("M01_MachineDelete"), variant: "danger-ghost" }); del.addEventListener("click", async () => { - const ask = L("M01_MachineDeleteAsk").replace("{value}", String(uses.length)); - if (!(await showConfirmDialog(uses.length ? `${ask}\n${uses.join("\n")}` : ask))) return; + const ask = L("M01_MachineDeleteAsk").replace("{value}", String(usedCount())); + if (!(await showConfirmDialog(uses && usedCount() ? `${ask}\n${usesText(uses)}` : ask))) return; if (key) toggleDelete(file, version, key); else if (addAt !== null) removeAdd(file, addAt); setLeaveGuard(null); diff --git a/M01_MasterData/M01_MasterData_UI_MachineImpact.ts b/M01_MasterData/M01_MasterData_UI_MachineImpact.ts new file mode 100644 index 000000000..89a57a125 --- /dev/null +++ b/M01_MasterData/M01_MasterData_UI_MachineImpact.ts @@ -0,0 +1,97 @@ +/* ============================================================================= + * M01_MasterData_UI_MachineImpact.ts + * M01 기계 정본 저장 전 영향 확인창(PLAN 848-5 · 요구서 889 6 장) — 페이지 [저장] 이 저장 전에 부름. + * 기계 줄 값 고침이 없으면 묻지 않음 · 서버가 셈(`/m01/machine/impact` — 쓰기 없음): + * 쓰는 기초(직접 · 부름 사슬) · 그 칸을 따로 고쳐 두어 안 바뀌는 곳 · 쓰는 단가산출(프로젝트 안 = 안 바뀜) + * · 금액이 바뀌는 기초 수 · 가장 크게 바뀌는 다섯(전 → 후) → [저장] / [취소]. + * 부품 = 확인창(`askConfirm` detail) · 값 목록 · 표 · 글. + * ========================================================================== */ + +import { createDataTable } from "@ui/ui_template_data_table"; +import { createKv } from "@ui/ui_template_kv"; +import { askConfirm } from "@ui/ui_template_modal"; +import { createText } from "@ui/ui_template_text"; +import { el } from "@ui/ui_template_elements"; +import type { FileChanges } from "./M01_MasterData_Api_Fetch"; +import { fetchMachineImpact, type MachineImpact } from "./M01_MasterData_Machine_Api"; + +const MACHINE_FILE = "기계.json"; +const n = (v: number): string => v.toLocaleString("ko-KR"); + +/** 저장해도 되면 true — 기계 값 고침이 없거나 [저장] 을 누름 */ +export async function confirmMachineImpact(files: FileChanges[]): Promise { + const part = files.find((f) => f.file === MACHINE_FILE); + if (!part?.changes.some((c) => c.op === "edit")) return true; + let got: MachineImpact; + try { + got = await fetchMachineImpact([part]); + } catch (error) { + return askConfirm({ + title: "기계 정본 고침", + message: `영향을 셀 수 없음 — ${error instanceof Error ? error.message : ""} · 그래도 저장`, + okLabel: "저장", + }); + } + if (!got.기계.length) return true; + return askConfirm({ + title: "기계 정본 고침 — 영향 확인", + message: "이 기계 값은 쓰는 모든 곳에 걸림 — 아래를 보고 저장", + okLabel: "저장", + cancelLabel: "취소", + detail: impactView(got), + }); +} + +function impactView(got: MachineImpact): HTMLElement { + const machines = got.기계.map((m) => { + const sk = m.단가산출; + const all = sk.마스터 + sk.회사 + sk.개인 + sk.프로젝트; + return el("div", { + className: "m01-machine-impact__one", + children: [ + el("strong", { text: `${m.이름} ${m.규격 ?? ""} — 바뀐 칸: ${m.칸.join(" · ")}` }), + createKv([ + { + label: "쓰는 기초", + value: `${n(m.직접 + m.사슬)} 개(직접 ${n(m.직접)} · 부름 사슬 ${n(m.사슬)})`, + }, + { + label: "따로 고쳐 두어 안 바뀌는 곳", + value: `${n(m.고침.기초 + m.고침.단가산출 + m.고침.위층)} 곳(기초 ${n(m.고침.기초)} · 단가산출 내 고침 ${n(m.고침.단가산출)} · 위 층 고침 ${n(m.고침.위층)})`, + }, + { + label: "쓰는 단가산출", + value: `${n(all)} 개(프로젝트 안 ${n(sk.프로젝트)} 개는 안 바뀜)`, + }, + ]), + ], + }); + }); + const table = createDataTable({ + caption: "가장 크게 바뀌는 기초", + columns: [ + { key: "키", label: "기초", width: 72 }, + { key: "이름", label: "이름", width: 170 }, + { key: "단위", label: "단위", width: 70 }, + { key: "전", label: "전", kind: "number", width: 80 }, + { key: "후", label: "후", kind: "number", width: 80 }, + { key: "율", label: "바뀜 %", kind: "number", decimals: 2, width: 60 }, + ], + rows: got.위.map((r) => ({ + ...r, + 율: r.전 && r.후 !== null ? ((r.후 - r.전) / Math.abs(r.전)) * 100 : null, + })), + empty: "-", + }); + return el("div", { + className: "m01-machine-impact", + children: [ + ...machines, + createText( + `금액이 바뀌는 기초 ${n(got.바뀜)} 개(기본 옵션으로 ${n(got.셈)} 개 다시 셈)`, + got.바뀜 ? "warning" : "muted", + ), + ...(got.위.length ? [table.root] : []), + ], + }); +} diff --git a/M01_MasterData/M01_MasterData_UI_Page.ts b/M01_MasterData/M01_MasterData_UI_Page.ts index 05ccf90c7..efe9b1c63 100644 --- a/M01_MasterData/M01_MasterData_UI_Page.ts +++ b/M01_MasterData/M01_MasterData_UI_Page.ts @@ -35,6 +35,7 @@ import { buildHeadBar, buildHeadFilters } from "./M01_MasterData_UI_Head"; import { renderRows } from "./M01_MasterData_UI_Rows"; import { renderMachines } from "./M01_MasterData_UI_Machine"; import { openMachineDetail } from "./M01_MasterData_UI_MachineDetail"; +import { confirmMachineImpact } from "./M01_MasterData_UI_MachineImpact"; import "./M01_MasterData_UI_Machine.css"; import { renderRateRows } from "./M01_MasterData_UI_RateSheet"; import { @@ -244,6 +245,7 @@ function buildPage(): HTMLElement { save.addEventListener("click", async () => { save.disabled = true; try { + if (!(await confirmMachineImpact(payload()))) return; // 기계 정본 = 영향 보고 저장(848-5) const result = await saveFiles(payload()); if (result.status === 200 && "files" in result) { discard(result.files.map((f) => f.file)); diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index 958323c18..2e0a2a2b7 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -6,7 +6,8 @@ {판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 자원 줄], ← 값 사본(`M02_Sangeun_Copy` 꼴) 부름 {키: 문서}(닫힌 묶음 — 연결 · [재생성] 때 새로) · SK 만: 문서(이 SK 문서 · 사용자 고침) · 끊음 {키: 문서}(이 사본 안에 굳힌 부름 · 고칠 수 있음) · - 따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음)} + 따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) · + 위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)} 셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) · [단가 갱신] = 자원 단가 줄만 지금 M01(`skc.refresh`) · 문서 그대로 · [재생성] = 지금 M01 문서로. 부름 문서 = 값 사본 줄이 지금 M01 줄과 같으면 M01 문서(`수식문서/`) · 다르면(만든 때 옛 줄) 그 줄을 @@ -36,6 +37,7 @@ import master_auto as mau # noqa: E402 import master_doc as md # noqa: E402 import master_doc_calc as mc # noqa: E402 import master_doc_convert as cv # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_doc_work as mw # noqa: E402 @@ -158,10 +160,23 @@ def docs_of(copy: dict) -> dict[str, dict]: return {**(copy.get("부름") or {}), **(copy.get("끊음") or {})} +def cover_of(copy: dict, doc: dict | None = None) -> dict: + """셈 cover(848-1) — ① `위덮음` 위에 ② 문서 `기계덮음` · ① 없음 = 문서 칸 그대로.""" + return mcv.merge_layers( + copy.get(mcv.UPPER), mcv.cover_of(copy.get("문서") if doc is None else doc) + ) + + +def upper_calls(copy: dict) -> list[str]: + """① 위 층 덮음의 시간당 작업량 식 · 굳은 기계 식 문서 키(부름 닫힌 묶음에 더함 · 848-1).""" + return mw.cover_calls({mcv.COVER: copy.get(mcv.UPPER) or {}}) + + def run(doc: dict, copy: dict, given: dict | None = None, whole: Any = None) -> dict: - """문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저).""" + """문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저) · cover = ① + ②(`cover_of`).""" try: - return mc.calc(doc, ml.Links(whole or over(copy), docs_of(copy)), given) + links = ml.Links(whole or over(copy), docs_of(copy)) + return mc.calc(doc, links, given, cover=cover_of(copy, doc)) except _ERR as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로 return {"셈됨": False, "표지": [{"갈래": "셈 틀림", "글": str(e)}], **dict.fromkeys(COSTS)} diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index 1e20667d3..fbe8b4653 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -52,7 +52,7 @@ def gaps(copy: dict) -> list[str]: return [] seen = _Seen(dc.over(copy)) try: - dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy))) + dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)), cover=dc.cover_of(copy)) except dc._ERR: pass have = _have(copy) diff --git a/M02_MasterTemplete/M02_Doc_Screen.py b/M02_MasterTemplete/M02_Doc_Screen.py index c1801479e..58b0a4357 100644 --- a/M02_MasterTemplete/M02_Doc_Screen.py +++ b/M02_MasterTemplete/M02_Doc_Screen.py @@ -32,7 +32,7 @@ def record(copy: dict) -> dict[str, Any]: rec = mr.Rec(dc.ml.Links(dc.over(copy), dc.docs_of(copy))) try: rec.prefetch(copy["문서"]) - dc.mc.calc(copy["문서"], rec) + dc.mc.calc(copy["문서"], rec, cover=dc.cover_of(copy)) # ① + ②(848-1) except dc._ERR: # 셈 틀림 = 셈 답 표지(`dc.run`) — 기록은 모은 데까지 pass return rec.out() diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index d971df7f3..295590e3c 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -11,6 +11,9 @@ SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 · SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 사전조합 · 구조물 조합이 이 값을 씀. 가져온 식 SK(807-1) = `M02_Doc_Import` 문서(파생 = 가져온 줄 + SK 고침에서 지음 · 따로 = 저장본) · 셈 = 단가기준(엑셀 = 엑셀 값 · 우리 = 연결 값) · 바탕 참조 SK = 옛 길(값 사본 없음). +위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) — + 프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 · + 파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임). """ from __future__ import annotations @@ -29,7 +32,10 @@ from M02_MasterTemplete import M02_Sangeun_Copy as skc from M02_MasterTemplete import M02_Sangeun_Doc as sd from M02_MasterTemplete import M02_Sk_AutoRenew as renew +import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc + KEY = dc.KEY +UPPER = mcv.UPPER OLD_FIELDS = ( "바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침", "고름", "자재표시", "켜쌓기율", @@ -88,7 +94,7 @@ def derive(sk: dict, ctx: tuple) -> dict: same = False plain = dc.doc_of(whole, base_key) if same else None if plain is not None: - doc = cp.deepcopy(plain) + doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1) _set_values(doc, given) elif not (row.get("호표") or row.get("덧줄") or row.get("결과")): doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or "")) @@ -112,6 +118,30 @@ def seed(sk: dict) -> dict | None: return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))} +def with_upper(sk: dict, got: dict) -> dict: + """① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 · + ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함.""" + key = str((sk.get("바탕") or {}).get("로직") or "") + live = dc.folder().get(key) if key else None + if live is None: + return got + cover = mcv.cover_of(live) + if not cover: + return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got + out = {**got, UPPER: cp.deepcopy(cover)} + have = dc.docs_of(out) + if need := [k for k in dc.upper_calls(out) if k not in have]: + out["부름"] = {**(out.get("부름") or {}), **dc.closure(dc.over(out), need, have)} + return out + + +def upper(sk: dict, got: Any) -> Any: + """셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1).""" + if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk): + return got + return with_upper(sk, got) + + def copy_of(sk: dict, ctx: tuple | None) -> dict | None: """셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 옛 칸으로 다시 지은 문서(부름은 있던 것 먼저) · `OLD` 켬(옮기기 대조 · 시험) = 옛 길.""" @@ -120,7 +150,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None: got = sk.get(KEY) if dc.has(sk) else seed(sk) if got is None: return None - got = renew.form(sk, got) # M01 자동 따라옴(836-2) + got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1) if got.get("따로") or ctx is None: return got if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎) @@ -137,7 +167,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None: values = dc.values_of(sk[skc.KEY]) if skc.has(sk) else dc.values_of(got) # 서버가 정한 값 values = renew.rows(values) if renew.is_sk(sk) else values # 836-2 whole = dc.over(values) - calls = dc.closure(whole, dc.calls(root), got.get("부름")) + calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름")) base = str((sk.get("바탕") or {}).get("로직") or "") seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지) origin = {"원본": {"키": base, "판": dc.fp(seen)}} if seen else {} @@ -194,7 +224,9 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: return {**out, KEY: norm(mine["사본"])} file = stored(out.get("키")) or {} have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None) - have = renew.form(out, have) if have else have # 836-2 — 바뀐 항목 고침 지움 · 저장 때 굳음 + have = ( + upper(out, renew.form(out, have)) if have else have + ) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음 if have and have.get("따로") and job != skc.REGEN: if file and old_fp(file) != old_fp(out): raise sd.DocError( @@ -216,6 +248,10 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": calls} if job != skc.REGEN and (have or {}).get("끊음"): # 안 바뀐 항목 고침 = 그대로(836-2) first["끊음"] = have["끊음"] + if (have or {}).get( + UPPER + ): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1) + first[UPPER] = have[UPPER] copy = copy_of({**out, KEY: first}, box[-1] if box else None) if ( copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy)) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 398f34b4e..79a0f516c 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -10,6 +10,8 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} 가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음 (형제 SK 는 셈 때 읽음) · 단가갱신 = 문서 그대로 · 바탕 참조 SK = 값 사본 없음(400). 저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`). +위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② · + 저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`). """ from __future__ import annotations @@ -89,6 +91,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: ) body = { "문서": copy["문서"], + "위덮음": copy.get(dsk.UPPER) or {}, "부름": copy.get("부름") or {}, "끊음": copy.get("끊음") or {}, "셈": got, @@ -152,8 +155,9 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: calls = [ *dc.calls(out["문서"]), *(c for d in out.get("끊음", {}).values() for c in dc.calls(d)), + *dc.upper_calls(out), # ① 위 층 덮음 식(848-1) ] - try: # 기계 덮음(836-1) — 몸 검사 · 원본과 같은 칸 · 안 부르는 기계 뺌(가져온 식 = 검사만) + try: # 기계 덮음(836-1) — 몸 검사 · 위 층과 같은 칸 · 문서 밖 기계 뺌(가져온 식 = 검사만) if dim.is_imported(sk): got = mcv.clean(out["문서"].get(mcv.COVER)) rest = {k: v for k, v in out["문서"].items() if k != mcv.COVER} @@ -163,7 +167,8 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: if not dim.is_imported(sk): out["부름"] = dc.closure(dc.over(out), calls, copy.get("부름")) try: - out["문서"] = mcv.prune_doc(out["문서"], dc.ml.Links(dc.over(out), dc.docs_of(out))) + links = dc.ml.Links(dc.over(out), dc.docs_of(out)) + out["문서"] = mcv.prune_doc(out["문서"], links, out.get(dsk.UPPER)) # ② 대 ① + 정본 except ValueError as e: raise _bad(str(e)) from e out = gap.fill(out) # 셈이 읽은 줄 가운데 사본 없는 것 = 지금 값으로 박음(822-1) diff --git a/M02_MasterTemplete/M02_Item_Sangeun.py b/M02_MasterTemplete/M02_Item_Sangeun.py index 5aec58da5..9d5b7e2d1 100644 --- a/M02_MasterTemplete/M02_Item_Sangeun.py +++ b/M02_MasterTemplete/M02_Item_Sangeun.py @@ -86,13 +86,21 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]: if got["켜쌓기율"] is not None: frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"]) if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02 - frozen["수식"] = doc["수식"] + frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것 out[rid] = frozen for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)): out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken) return out +def _upper(doc: dict) -> dict: + """SK `수식` — ① 위 층 덮음을 굳힐 때 기초 것으로(848-1 · 가져온 식 · 기초 문서 없음 = 저장본).""" + from M02_MasterTemplete import M02_Doc_Import as dim + from M02_MasterTemplete import M02_Doc_Sk as dsk + + return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"]) + + def _patched(doc: Any) -> list[int]: """일위대가(SC) 사본의 덮개 줄(로직 줄 + `패치` · 740-1 SK 넣기 꼴) 차례.""" if not isinstance(doc, dict) or doc.get("종류") != refs.TITLE["precombo"]: diff --git a/M02_MasterTemplete/M02_MyMachine.css b/M02_MasterTemplete/M02_MyMachine.css index 97e76bde3..10cadbcac 100644 --- a/M02_MasterTemplete/M02_MyMachine.css +++ b/M02_MasterTemplete/M02_MyMachine.css @@ -14,3 +14,10 @@ margin: var(--spacing-4) 0 0; padding-left: var(--spacing-16); } + +/* 저장 전 영향 확인창(848-5) */ +.m02-mymach__impact { + display: flex; + flex-direction: column; + gap: var(--spacing-8); +} diff --git a/M02_MasterTemplete/M02_MyMachine_Api.ts b/M02_MasterTemplete/M02_MyMachine_Api.ts index 93fdb88f3..e2ecc0a17 100644 --- a/M02_MasterTemplete/M02_MyMachine_Api.ts +++ b/M02_MasterTemplete/M02_MyMachine_Api.ts @@ -120,6 +120,20 @@ export const updateMyMachine = ( ): Promise => call(at(owner, key(k)), { method: "PUT", body: JSON.stringify({ 줄: body }) }); +/** 저장 전 영향(848-5) — 바뀐 칸 · 이 층 쓰는 단가산출(그 칸을 따로 고쳐 둠?) · 쓰기 없음 */ +export interface MyMachineImpact { + 칸: string[]; + 쓰는곳: (Use & { 고침: boolean; 위층: boolean })[]; + 고침: number; + 위층: number; +} +export const impactMyMachine = ( + owner: string | null, + k: string, + body: MyMachineBody, +): Promise => + call(at(owner, `${key(k)}/impact`), { method: "POST", body: JSON.stringify({ 줄: body }) }); + export const deleteMyMachine = (owner: string | null, k: string): Promise<{ 쓰는곳: Use[] }> => call(at(owner, key(k)), { method: "DELETE" }); diff --git a/M02_MasterTemplete/M02_MyMachine_Form.ts b/M02_MasterTemplete/M02_MyMachine_Form.ts index 6eeab3f11..ac7b6d766 100644 --- a/M02_MasterTemplete/M02_MyMachine_Form.ts +++ b/M02_MasterTemplete/M02_MyMachine_Form.ts @@ -33,6 +33,7 @@ import { type MyMachineOne, type SimilarRow, } from "./M02_MyMachine_Api"; +import { confirmMyMachineImpact } from "./M02_MyMachine_Impact"; import { mt } from "./M02_MyMachine_Text"; import "./M02_MyMachine.css"; @@ -169,6 +170,8 @@ export async function mountMyMachineForm( if (!body || m01Same) return; saveBtn.disabled = true; try { + // 정본 고침 = 영향 보고 저장(848-5) + if (opt.key && !(await confirmMyMachineImpact(opt.owner, opt.key, body))) return; const got = opt.key ? await updateMyMachine(opt.owner, opt.key, body) : await createMyMachine(opt.owner, body, base); diff --git a/M02_MasterTemplete/M02_MyMachine_Impact.py b/M02_MasterTemplete/M02_MyMachine_Impact.py new file mode 100644 index 000000000..f5fc054c4 --- /dev/null +++ b/M02_MasterTemplete/M02_MyMachine_Impact.py @@ -0,0 +1,46 @@ +"""내 기계 저장 전 영향(PLAN 848-5 · 요구서 889 6 장) — 기계 보기 [저장] 전에 확인창이 부름 · 쓰기 없음. + +고친 줄 = 저장과 같은 손질(`M02_MyMachine.clean` — 틀리면 400) · 바뀐 칸 = 값 칸 · 방식 · 시간당. +쓰는 단가산출 = 이 층(`store.root()`) SK 가운데 사본 단가에 그 키 · 덮음에 「개인 키」 가 있는 것 +(색인 = `M01_MasterData_Machine_Uses.sk_index` — 파일 자국 기억) · 따로 고쳐 둔 곳 = 덮음이 바뀐 칸을 덮음 +(② 내 고침 · ① 위 층 고침 따로). 이름은 이 층 것만 냄. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +from M01_MasterData import M01_MasterData_Machine_Impact as mi +from M01_MasterData import M01_MasterData_Machine_Uses as mu +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_MyMachine as mym + + +def impact(key: str, raw: Any) -> dict[str, Any]: + """{칸, 쓰는곳: [{키, 이름, 고침, 위층}], 고침, 위층}.""" + old = next((r for r in mym.rows() if r["키"] == key), None) + if old is None: + raise store.StoreError(404, f"없는 내 기계 「{key}」") + new = mym.clean(raw) + fields = mi.changed_fields(old.get("값"), new.get("값")) + fields += [k for k in ("방식", "시간당") if not mi.same(old.get(k), new.get(k))] + here = (store.root() / "sangeun").resolve() + names = (f"{mym.NO}{key}", key) + used = [ + { + "키": r["키"], + "이름": r["이름"], + "고침": mi.cover_hits(r["덮음"], names, fields), + "위층": mi.cover_hits(r["위덮음"], names, fields), + } + for r in mu.sk_index() + if Path(r["파일"]).parent.resolve() == here + and (key in r["기계"] or any(n in r[c] for c in mu.COVERS for n in names)) + ] + return { + "칸": fields, + "쓰는곳": used, + "고침": sum(1 for u in used if u["고침"]), + "위층": sum(1 for u in used if u["위층"]), + } diff --git a/M02_MasterTemplete/M02_MyMachine_Impact.ts b/M02_MasterTemplete/M02_MyMachine_Impact.ts new file mode 100644 index 000000000..beb33828d --- /dev/null +++ b/M02_MasterTemplete/M02_MyMachine_Impact.ts @@ -0,0 +1,53 @@ +/* ============================================================================= + * M02_MyMachine_Impact.ts + * 내 기계 저장 전 영향 확인창(PLAN 848-5 · 요구서 889 6 장) — 기계 보기 [저장] 이 고침 저장 전에 부름. + * 바뀐 칸이 없거나 쓰는 단가산출이 없으면 묻지 않음 · 서버가 셈(`…/my-machines/{키}/impact` — 쓰기 없음): + * 이 층 쓰는 단가산출 목록(그 칸을 따로 고쳐 두어 안 바뀌는 것 표시) → [저장] / [취소]. + * 부품 = 확인창(`askConfirm` detail) · 표 · 글. + * ========================================================================== */ + +import { createDataTable } from "@ui/ui_template_data_table"; +import { askConfirm } from "@ui/ui_template_modal"; +import { createText } from "@ui/ui_template_text"; +import { el } from "@ui/ui_template_elements"; +import { impactMyMachine, type MyMachineBody } from "./M02_MyMachine_Api"; + +/** 저장해도 되면 true */ +export async function confirmMyMachineImpact( + owner: string | null, + key: string, + body: MyMachineBody, +): Promise { + const got = await impactMyMachine(owner, key, body); + if (!got.칸.length || !got.쓰는곳.length) return true; + const kept = got.고침 + got.위층; + const table = createDataTable({ + caption: "쓰는 단가산출", + columns: [ + { key: "키", label: "단가산출", width: 96 }, + { key: "이름", label: "이름", width: 240 }, + { key: "따로", label: "그 칸 따로 고침", width: 110 }, + ], + rows: got.쓰는곳.map((u) => ({ + 키: u.키, + 이름: u.이름, + 따로: u.고침 ? "내 고침 — 안 바뀜" : u.위층 ? "위 층 고침 — 안 바뀜" : "", + })), + }); + return askConfirm({ + title: "내 기계 고침 — 영향 확인", + message: `바뀐 칸: ${got.칸.join(" · ")} — 이 기계를 쓰는 단가산출 ${got.쓰는곳.length} 개에 걸림`, + okLabel: "저장", + cancelLabel: "취소", + detail: el("div", { + className: "m02-mymach__impact", + children: [ + createText( + `그 칸을 따로 고쳐 두어 안 바뀌는 곳 ${kept} 개(내 고침 ${got.고침} · 위 층 고침 ${got.위층})`, + kept ? "warning" : "muted", + ), + table.root, + ], + }), + }); +} diff --git a/M02_MasterTemplete/M02_MyMachine_Router.py b/M02_MasterTemplete/M02_MyMachine_Router.py index 25a9c78fd..31ee23219 100644 --- a/M02_MasterTemplete/M02_MyMachine_Router.py +++ b/M02_MasterTemplete/M02_MyMachine_Router.py @@ -2,7 +2,7 @@ GET 목록(줄마다 시간당 · 쓰는곳수) · GET `/{키}` 하나(+시간당 · 쓰는곳 · 같은이름) · POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에서 시작」)} · 만들기 · 고치기 = M01 과 같은 이름 · 규격 409(840-2) · -PUT `/{키}` 몸 {줄} · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · +PUT `/{키}` 몸 {줄} · POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) · POST `/draft` 몸 {줄, 키?, 본뜬?} = 단가산출 기계 창 [확인](827-1 · 쓰기 없음 · 층 쓰기 권한) → {줄, 셈값, 시간당}. 권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404). ⚠ 등록은 `main.py`(로그인만). @@ -18,6 +18,7 @@ from pydantic import BaseModel from common_util.common_util_auth import verify_session from M02_MasterTemplete import M02_MyMachine as mym from M02_MasterTemplete import M02_MyMachine_Draft as draft +from M02_MasterTemplete import M02_MyMachine_Impact as impact from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root router = APIRouter(prefix="/api/m02", tags=["M02 My Machine"]) @@ -80,6 +81,18 @@ def my_machine_update( return _call(_folder(session, layer, owner, True), mym.update_own, key, body.줄) +@router.post(PATH + "/{key}/impact") +def my_machine_impact( + layer: str, + key: str, + body: MachineBody, + owner: str | None = None, + session: Session = Depends(verify_session), +): + """[저장] 전 영향 — 쓰는 단가산출 · 따로 고쳐 둔 곳(848-5 · 쓰기 없음).""" + return _call(_folder(session, layer, owner), impact.impact, key, body.줄) + + @router.delete(PATH + "/{key}") def my_machine_delete( layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session) diff --git a/common_util/common_util_formula_doc_cover.ts b/common_util/common_util_formula_doc_cover.ts index ffed83f1b..23fb406f8 100644 --- a/common_util/common_util_formula_doc_cover.ts +++ b/common_util/common_util_formula_doc_cover.ts @@ -8,8 +8,12 @@ * 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음) * 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) · * 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째) + * 겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) → + * ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`mergeCover` · `mergeLayers` · `layeredCover` — 작업량 = 방식 · + * 식 · 변수 열쇠 · 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `putCover` 의 `upper`) · 위 층 값(`upperOf`) · + * 출처(`sourcesOf`) * 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py · - * test_842_3_machine_crew.py + * test_842_3_machine_crew.py · test_848_1_cover_layers.py * · 화면 · DOM · fetch 없음 * ========================================================================== */ @@ -22,10 +26,18 @@ import { type FormulaDoc, type MoneyLine, } from "./common_util_formula_doc"; -import { WORK, pruneWork, type WorkCover } from "./common_util_formula_doc_work"; +import { DAILY, HOURLY, WORK, type WorkCover } from "./common_util_formula_doc_work"; import { CREW, MISC, code as jobOf } from "./common_util_machine_crew"; export const COVER = "기계덮음"; +/** SK `수식` 칸 — ① 위 층 고침(848-1 · 꼴 = `기계덮음`) */ +export const UPPER = "위덮음"; +/** M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) */ +export const HAND = "손고침"; +/** 출처(`sourcesOf`) — 없는 칸 = 정본 */ +export const MINE = "나"; +export const ABOVE = "위"; +export type Source = typeof MINE | typeof ABOVE; /** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */ export const NOT_VALUE = ["조종원", "조종원직종", "잡재료율"]; const HOUR = "Q_시간환산"; @@ -224,36 +236,174 @@ const sameVal = (a: unknown, b: unknown): boolean => ? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b)) : String(a) === String(b); -/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) */ +/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) · + * 848-1 한 층의 작업량은 바꾼 칸만 담을 수 있음(`방식` 없음 = 위 층 방식) — 읽을 때는 `mergeLayers` 답을 봄 */ export type CoverEntry = MachineCover & { [WORK]?: WorkCover }; /** 원본 기본값 + 작업량 기본 변수(`workDefaults` · 없으면 변수 그대로) */ export type CoverBase = Required & { [WORK]?: Record }; +/** 위 층 값(`upperOf`) — 정본 기본 위에 ① · 작업량 = ① 층 그대로 */ +export type UpperValue = Required & { [WORK]?: WorkCover }; +/** 작업량 한 층(848-1) — 바꾼 칸만(방식 없음 = 위 층 방식) */ +export type WorkLayer = Partial; -/** 원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null */ -export function prune(entry: CoverEntry, base: CoverBase): CoverEntry | null { +/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null — + * `base` = 정본 기본(`defaultsOf` · 작업량 = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위) */ +export function prune( + entry: CoverEntry, + base: CoverBase, + upper?: CoverEntry | null, +): CoverEntry | null { + const up = upperOf(base, upper); const out: CoverEntry = {}; const vals = Object.entries(entry.값 ?? {}).filter( - ([k, v]) => - v !== null && v !== undefined && v !== "" && !(k in base.값 && sameVal(v, base.값[k])), + ([k, v]) => v !== null && v !== undefined && v !== "" && !(k in up.값 && sameVal(v, up.값[k])), ); if (vals.length) out.값 = Object.fromEntries(vals); - if (entry.조종원 && canon(entry.조종원) !== canon(base.조종원)) out.조종원 = entry.조종원; - if (entry.잡품 && canon(entry.잡품) !== canon(base.잡품)) out.잡품 = entry.잡품; - const work = pruneWork(entry[WORK], base[WORK] ?? null); - if (work) out[WORK] = work; + if (entry.조종원 && canon(entry.조종원) !== canon(up.조종원)) out.조종원 = entry.조종원; + if (entry.잡품 && canon(entry.잡품) !== canon(up.잡품)) out.잡품 = entry.잡품; + const work = pruneWorkLayer(entry[WORK], base[WORK] ?? null, upper?.[WORK] ?? null); + if (work) out[WORK] = work as WorkCover; return Object.keys(out).length ? out : null; } -/** 덮음 한 기계 고침 → 문서 칸(원본 대조로 정리 · 비면 칸 지움) */ +// ── 층(848-1) ───────────────────────────────────────────────────────── +const FIXED = ["기계", "키", "이름"] as const; +const fixedOf = (w: WorkLayer): WorkLayer => { + const out: WorkLayer = {}; + for (const k of FIXED) if (w[k]) out[k] = String(w[k]); + return out; +}; +const sameNum = (a: unknown, b: unknown): boolean => { + const x = Number(a); + const y = Number(b); + return a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y) + ? Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x)) + : String(a) === String(b); +}; + +/** 작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · `base` = 그 식 기본 변수 + * (`workDefaults`) · 일당 = 방식만 · 남는 것 없음 = null(위 층 없음 = `pruneWork` 와 같음) */ +export function pruneWorkLayer( + want: WorkLayer | null | undefined, + base: Record | null = null, + upper: WorkLayer | null = null, +): WorkLayer | null { + if (!want || typeof want !== "object") return null; + const up = upper ?? {}; + const upWay = up.방식 || DAILY; + const way = want.방식 || upWay; + const out: WorkLayer = way !== upWay ? { 방식: way } : {}; + if (way !== HOURLY) return Object.keys(out).length ? out : null; + const upForm = upWay === HOURLY ? String(up.식 ?? "") : ""; + const form = String(want.식 ?? "") || upForm; + if (form !== upForm) out.식 = form; + const held = { ...(base ?? {}), ...(form === upForm ? (up.변수 ?? {}) : {}) }; + const got = Object.entries(want.변수 ?? {}).filter( + ([k, v]) => v !== null && v !== undefined && v !== "" && !(k in held && sameNum(v, held[k])), + ); + if (got.length) out.변수 = Object.fromEntries(got); + const fix = fixedOf(want); + const upFix = upWay === HOURLY ? fixedOf(up) : {}; + if ( + Object.keys(fix).length && + (!Object.keys(upFix).length || fix.기계 !== upFix.기계 || fix.키 !== upFix.키) + ) + Object.assign(out, fix); + return Object.keys(out).length ? out : null; +} + +/** 작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) · + * 식을 바꾼 아래 층 = 위 층 변수 안 물려받음 */ +export function mergeWork( + top: WorkLayer | null | undefined, + low: WorkLayer | null | undefined, +): WorkLayer | null { + if (!top || !Object.keys(top).length) return low && Object.keys(low).length ? low : null; + if (!low || !Object.keys(low).length) return top; + let out: WorkLayer = { ...top }; + if (low.방식) out.방식 = low.방식; + if (low.식 && String(low.식) !== String(top.식 ?? "")) { + out.식 = low.식; + delete out.변수; + } + const vals = { ...(out.변수 ?? {}), ...(low.변수 ?? {}) }; + if (Object.keys(vals).length) out.변수 = vals; + if (low.기계) { + out = Object.fromEntries( + Object.entries(out).filter(([k]) => !(FIXED as readonly string[]).includes(k)), + ) as WorkLayer; + Object.assign(out, fixedOf(low)); + } + return out; +} + +/** ① 위 층 고침 위에 ② 내 고침(열쇠마다 `mergeCover`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로 */ +export function mergeLayers( + upper: Cover | null | undefined, + mine: Cover | null | undefined, +): Cover { + if (!upper || !Object.keys(upper).length) return mine ?? {}; + if (!mine || !Object.keys(mine).length) return upper; + const out: Cover = {}; + for (const k of [...Object.keys(upper), ...Object.keys(mine).filter((k) => !(k in upper))]) { + const got = mergeCover(upper[k], mine[k]); + if (got) out[k] = got; + } + return out; +} + +/** 화면 셈 cover — 문서 칸 `기계덮음`(②) 을 ① 위에 얹음(SK = 읽기 답 `위덮음` · M01 = 없음) */ +export const layeredCover = (doc: FormulaDoc, upper?: Cover | null): Cover => + mergeLayers(upper, coverOf(doc)); + +/** 위 층 값 — 정본 기본(`defaultsOf`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `workDefaults`) */ +export function upperOf(base: CoverBase, upper?: CoverEntry | null): UpperValue { + const { [WORK]: _, ...rest } = base; + const out: UpperValue = { ...rest }; + if (!upper) return out; + out.값 = { ...base.값, ...(upper.값 ?? {}) }; + if (upper.조종원) out.조종원 = upper.조종원; + if (upper.잡품) out.잡품 = upper.잡품; + if (upper[WORK]) out[WORK] = upper[WORK]; + return out; +} + +/** 칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · `작업량.방식` · + * `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계` */ +export function sourcesOf( + upper: CoverEntry | null | undefined, + mine: CoverEntry | null | undefined, +): Record { + let out: Record = {}; + const upForm = String((upper?.[WORK] as WorkLayer | undefined)?.식 ?? ""); + for (const [layer, tag] of [ + [upper, ABOVE], + [mine, MINE], + ] as const) { + const e = layer ?? {}; + for (const k of Object.keys(e.값 ?? {})) out[`값.${k}`] = tag; + if (e.조종원) out.조종원 = tag; + if (e.잡품) out.잡품 = tag; + const w = (e[WORK] ?? {}) as WorkLayer; + if (tag === MINE && w.식 && String(w.식) !== upForm) + out = Object.fromEntries(Object.entries(out).filter(([k]) => !k.startsWith("작업량.변수."))); + for (const k of ["방식", "식", "기계"] as const) if (w[k]) out[`작업량.${k}`] = tag; + for (const k of Object.keys(w.변수 ?? {})) out[`작업량.변수.${k}`] = tag; + } + return out; +} + +/** 덮음 한 기계 고침 → 문서 칸(위 층 대조로 정리 · 비면 칸 지움) — `upper` = ① 그 열쇠 칸(848-1 · SK) */ export function putCover( doc: FormulaDoc, machine: string, entry: CoverEntry, base: CoverBase, + upper?: CoverEntry | null, ): void { const box = doc as Holder; const all = { ...coverOf(doc) }; - const kept = prune(entry, base); + const kept = prune(entry, base, upper); if (kept) all[machine] = kept; else delete all[machine]; if (Object.keys(all).length) box[COVER] = all; @@ -388,17 +538,21 @@ export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): Machin return Object.keys(out).length ? out : null; } -/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */ +/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) · + * 작업량 = `mergeWork`(848-1) */ export function mergeCover( - base: MachineCover | null | undefined, - top: MachineCover | null | undefined, -): MachineCover | null { + base: CoverEntry | null | undefined, + top: CoverEntry | null | undefined, +): CoverEntry | null { if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null; if (!top || !Object.keys(top).length) return base; - const out: MachineCover = { ...base, ...top }; + const out: CoverEntry = { ...base, ...top }; const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) }; if (Object.keys(값).length) out.값 = 값; else delete out.값; + const work = mergeWork(base[WORK], top[WORK]); + if (work) out[WORK] = work as WorkCover; + else delete out[WORK]; return out; } diff --git a/resources/master_data/scripts/build_수식문서_802_2.py b/resources/master_data/scripts/build_수식문서_802_2.py index 42bf0dc92..5db158161 100644 --- a/resources/master_data/scripts/build_수식문서_802_2.py +++ b/resources/master_data/scripts/build_수식문서_802_2.py @@ -19,6 +19,8 @@ · 옛 로직 JSON 은 안 씀). - 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약). - 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`). +- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 · + `손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림. """ from __future__ import annotations @@ -36,6 +38,7 @@ import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만) import master_doc as md # noqa: E402 import master_doc_calc as mc # noqa: E402 import master_doc_convert as cv # noqa: E402 +import master_doc_cover as mcv # noqa: E402 import master_doc_link as ml # noqa: E402 import master_equation as meq # noqa: E402 import master_formula as mf # noqa: E402 @@ -184,9 +187,33 @@ def build(log=print) -> dict: "대조": runs, "저장": keep, "요약": summary, + "저장본": carried(), } +def carried() -> dict[str, dict]: + """이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}.""" + if not ml.FOLDER.exists(): + return {} + return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)} + + +def hand_kept(result: dict) -> list[str]: + """저장본 그대로 둔 `손고침` 문서 키(저장되는 것만).""" + have = result.get("저장본") or {} + return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"]) + + +def _out_doc(result: dict, key: str) -> dict: + """쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서.""" + have = (result.get("저장본") or {}).get(key) + if have and have.get(mcv.HAND): + return have + if have and have.get(mcv.COVER): + return {**result["문서"][key], mcv.COVER: have[mcv.COVER]} + return result["문서"][key] + + def _calls(doc: dict) -> set[str]: out = set() for v in doc.get("변수") or []: @@ -229,7 +256,7 @@ def files_of(result: dict) -> dict[str, str]: """저장 파일 이름 → 글.""" out = {} for name, keys in result["파일"].items(): - kept = [result["문서"][k] for k in keys if k in result["저장"]] + kept = [_out_doc(result, k) for k in keys if k in result["저장"]] body = {"그룹": "수식문서", "로직파일": name, "줄": kept} out[ml.file_of(name)] = ml.dump(body) return out @@ -323,6 +350,8 @@ def main() -> int: parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만") args = parser.parse_args() result = build() + if hand := hand_kept(result): + print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}") if args.check: bad = check(result) for line in bad: diff --git a/resources/master_data/scripts/master_doc_cover.py b/resources/master_data/scripts/master_doc_cover.py index 4fd71bfe3..d751f46b5 100644 --- a/resources/master_data/scripts/master_doc_cover.py +++ b/resources/master_data/scripts/master_doc_cover.py @@ -7,8 +7,11 @@ 덮음 없음 = 문서 그대로(금액 전후 같음). 기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) · 단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째). +겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) → + ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`merge` · `merge_layers` — 작업량 = 방식 · 식 · 변수 열쇠 · + 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `prune_doc` 의 `upper`) · 위 층 값(`upper_of`) · 출처(`sources`). 파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험 -`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py`. +`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py` · `test_848_1_cover_layers.py`. """ from __future__ import annotations @@ -23,6 +26,9 @@ import master_doc_work as mw import master_machine_crew as mcrew COVER = "기계덮음" +UPPER = "위덮음" # SK `수식` 칸 — ① 위 층 고침(848-1) +HAND = "손고침" # M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) +MINE, ABOVE = "나", "위" # 출처(`sources`) — 없는 칸 = 정본 NOT_VALUE = ( "조종원", "조종원직종", @@ -192,24 +198,136 @@ def _same(a, b) -> bool: return str(a) == str(b) -def prune(entry: dict, base: dict) -> dict | None: - """원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None.""" +def prune(entry: dict, base: dict, upper: dict | None = None) -> dict | None: + """위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None — + `base` = 정본 기본(`defaults_of` · `작업량` = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위).""" + up = upper_of(base, upper) out: dict = {} vals = { k: v for k, v in (entry.get("값") or {}).items() - if v not in (None, "") and not (k in base["값"] and _same(v, base["값"][k])) + if v not in (None, "") and not (k in up["값"] and _same(v, up["값"][k])) } if vals: out["값"] = vals for part in ("조종원", "잡품"): - if entry.get(part) is not None and _canon(entry[part]) != _canon(base[part]): + if entry.get(part) is not None and _canon(entry[part]) != _canon(up[part]): out[part] = entry[part] - if work := mw.prune_work(entry.get(mw.WORK), base.get(mw.WORK)): # 846-1 시간당 작업량 + work = prune_work_layer(entry.get(mw.WORK), base.get(mw.WORK), (upper or {}).get(mw.WORK)) + if work: # 846-1 시간당 작업량 out[mw.WORK] = work return out or None +# ── 층(848-1) ───────────────────────────────────────────────────────── +def _fixed(w: dict) -> dict: + return {k: str(w[k]) for k in mw.FIXED if w.get(k)} + + +def prune_work_layer(want, base: dict | None = None, upper: dict | None = None) -> dict | None: + """작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · + `base` = 그 식 기본 변수(`mw.defaults`) · 일당 = 방식만 · 남는 것 없음 = None(위 층 없음 = `mw.prune_work` 와 같음).""" + if not isinstance(want, dict): + return None + up = upper if isinstance(upper, dict) else {} + up_way = up.get("방식") or mw.DAILY + way = want.get("방식") or up_way + out: dict = {"방식": way} if way != up_way else {} + if way != mw.HOURLY: + return out or None + up_form = str(up.get("식") or "") if up_way == mw.HOURLY else "" + form = str(want.get("식") or "") or up_form + if form != up_form: + out["식"] = form + held = {**(base or {}), **((up.get("변수") or {}) if form == up_form else {})} + got = { + k: v + for k, v in (want.get("변수") or {}).items() + if v not in (None, "") and not (k in held and mw._same(v, held[k])) + } + if got: + out["변수"] = got + fix, up_fix = _fixed(want), (_fixed(up) if up_way == mw.HOURLY else {}) + if fix and ( + not up_fix + or [fix.get(k) for k in ("기계", "키")] != [up_fix.get(k) for k in ("기계", "키")] + ): + out |= fix + return out or None + + +def merge_work(top: dict | None, low: dict | None) -> dict | None: + """작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) · + 식을 바꾼 아래 층 = 위 층 변수 안 물려받음.""" + if not isinstance(top, dict) or not top: + return low if isinstance(low, dict) and low else None + if not isinstance(low, dict) or not low: + return top + out = dict(top) + if low.get("방식"): + out["방식"] = low["방식"] + if low.get("식") and str(low["식"]) != str(top.get("식") or ""): + out["식"] = low["식"] + out.pop("변수", None) + if vals := {**(out.get("변수") or {}), **(low.get("변수") or {})}: + out["변수"] = vals + if low.get("기계"): + out = {k: v for k, v in out.items() if k not in mw.FIXED} | _fixed(low) + return out + + +def merge_layers(upper: dict | None, mine: dict | None) -> dict: + """① 위 층 고침 위에 ② 내 고침(열쇠마다 `merge`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로.""" + if not isinstance(upper, dict) or not upper: + return mine if isinstance(mine, dict) else {} + if not isinstance(mine, dict) or not mine: + return upper + out = {} + for k in [*upper, *(k for k in mine if k not in upper)]: + if got := merge(upper.get(k), mine.get(k)): + out[k] = got + return out + + +def upper_of(base: dict, upper: dict | None) -> dict: + """위 층 값 — 정본 기본(`defaults_of`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `mw.defaults`).""" + out = {k: v for k, v in base.items() if k != mw.WORK} + if not upper: + return out + out["값"] = {**(base.get("값") or {}), **(upper.get("값") or {})} + for part in ("조종원", "잡품"): + if upper.get(part) is not None: + out[part] = upper[part] + if upper.get(mw.WORK): + out[mw.WORK] = upper[mw.WORK] + return out + + +def sources(upper: dict | None, mine: dict | None) -> dict[str, str]: + """칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · + `작업량.방식` · `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계`.""" + out: dict[str, str] = {} + up_form = str(((upper or {}).get(mw.WORK) or {}).get("식") or "") + for layer, tag in ((upper, ABOVE), (mine, MINE)): + e = layer if isinstance(layer, dict) else {} + for k in e.get("값") or {}: + out[f"값.{k}"] = tag + for part in ("조종원", "잡품"): + if e.get(part) is not None: + out[part] = tag + w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {} + if ( + tag == MINE and w.get("식") and str(w["식"]) != up_form + ): # 식을 바꿈 = 위 층 변수 안 물려받음 + out = {k: v for k, v in out.items() if not k.startswith("작업량.변수.")} + for k in ("방식", "식", "기계"): + if w.get(k): + out[f"작업량.{k}"] = tag + for k in w.get("변수") or {}: + out[f"작업량.변수.{k}"] = tag + return out + + # ── 셈 규칙 ─────────────────────────────────────────────────────────── def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str: have = {md.var_id(v) for v in doc.get("변수") or []} | { @@ -354,14 +472,17 @@ def row_entry(doc: dict, vals) -> dict | None: def merge(base: dict | None, top: dict | None) -> dict | None: - """바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만).""" + """바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) · + 작업량 = `merge_work`(848-1).""" if not base: return top or None if not top: return base - out = {**base, **{k: v for k, v in top.items() if k != "값"}} + out = {**base, **{k: v for k, v in top.items() if k not in ("값", mw.WORK)}} vals = {**(base.get("값") or {}), **(top.get("값") or {})} - return {**out, "값": vals} if vals else out + out = {**out, "값": vals} if vals else out + work = merge_work(base.get(mw.WORK), top.get(mw.WORK)) + return {**out, mw.WORK: work} if work else out def lists_of(links, given) -> dict: @@ -425,32 +546,66 @@ def clean(raw) -> dict: if part == "잡품" and not (r.get("줄") or r.get("키")): raise ValueError(f"{COVER} 「{key}」 잡품 줄 — 재료(키) 또는 줄 필요") one[part] = rows - if entry.get(mw.WORK) is not None: - one[mw.WORK] = mw.clean_work(entry[mw.WORK], f"{COVER} 「{key}」") + w = entry.get(mw.WORK) + if isinstance(w, dict) and not w.get("방식"): # 848-1 바꾼 칸만 담은 층(방식 = 위 층) + got = mw.clean_work({**w, "방식": mw.DAILY}, f"{COVER} 「{key}」") + got.pop("방식") + if got: + one[mw.WORK] = got + elif w is not None: + one[mw.WORK] = mw.clean_work(w, f"{COVER} 「{key}」") if one: out[str(key)] = one return out -def prune_doc(doc: dict, links) -> dict: - """서버 정리 — 덮음을 검사하고 원본과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로). - 원본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답).""" +def _quoted(text) -> set[str]: + return set(re.findall(r"'([^']*)'", str(text or ""))) + + +def listed(doc: dict) -> set[str]: + """문서 안 덮음 열쇠 후보(848-1) — 선택 목록 · 입력 값 · 따옴표 글(식 · 부름 입력 · 금액) · 변수 기호.""" + out: set[str] = set() + for v in doc.get("변수") or []: + out.add(md.var_id(v)) + link = v.get("연결") or {} + out |= {str(x) for x in link.get("목록") or []} + if isinstance(link.get("값"), str): + out.add(link["값"]) + for x in (link.get("입력") or {}).values(): + out |= _quoted(x) + for x in doc.get("식") or []: + out |= _quoted(x.get("식")) + for x in doc.get("금액") or []: + out |= _quoted(x.get("수량")) | _quoted(x.get("단가")) + return out + + +def prune_doc(doc: dict, links, upper: dict | None = None) -> dict: + """서버 정리 — 덮음을 검사하고 위 층과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로). + 정본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답 · 작업량 · 굳은 기계는 얹고 셈) · + `upper` = ① 위 층 고침(SK `수식.위덮음` · 848-1) · 이번 셈이 안 부른 열쇠 = 문서 안에 들면(`listed`) 그대로 남김.""" import master_doc_calc as mc cover = clean(doc.get(COVER)) rest = {k: v for k, v in doc.items() if k != COVER} if not cover: return rest + upper = upper if isinstance(upper, dict) else {} + both = merge_layers(upper, cover) + steer = {k: {mw.WORK: e[mw.WORK]} for k, e in both.items() if (e or {}).get(mw.WORK)} memo: dict = {} - top = mc.calc(rest, links, None, (), memo) - kept: dict = {} # 문서가 안 부르는 기계 덮음 = 뺌 + top = mc.calc(rest, links, None, (), memo, steer) + kept: dict = {} + seen: set[str] = set() # 값 · 조종원 · 잡품을 견준 열쇠 for (key, given), ans in memo.items(): m = machine_key(dict(given)) sub = links.doc(key) if m in cover and m not in kept else None if not sub or not is_machine(sub): continue + seen.add(m) base = defaults_of(sub, ans.get("값") or {}, row_entry(sub, lists_of(links, dict(given)))) - if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base): + if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base, upper.get(m)): kept[m] = one works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도 for a in (top, *memo.values()): @@ -460,11 +615,24 @@ def prune_doc(doc: dict, links) -> dict: if w.get("기호"): works.setdefault(w["기호"], w["기계"]) for m in sorted(set(works) & set(cover)): - want = cover[m].get(mw.WORK) - if want and ( - one := mw.prune_work(want, _work_base(links, want.get("기계") or works[m], want)) - ): + if not (want := cover[m].get(mw.WORK)): + continue + seen.add(f"{m}\n{mw.WORK}") + up = (upper.get(m) or {}).get(mw.WORK) or {} + eff = merge_work(up, want) or {} + if eff.get("방식") == mw.HOURLY and not eff.get("식"): + raise ValueError(f"{COVER} 「{m}」 작업량 — 시간당은 식 키 필요") + base = _work_base(links, eff.get("기계") or works[m], eff) + if one := prune_work_layer(want, base, up): kept[m] = {**kept.get(m, {}), mw.WORK: one} + names = listed(rest) | { + str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계") + } + for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로 + if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}): + kept[m] = {**vals, **kept.get(m, {})} + if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK): + kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]} return {**rest, COVER: kept} if kept else rest diff --git a/resources/tester/helper_848_1_cover_layers.cjs b/resources/tester/helper_848_1_cover_layers.cjs new file mode 100644 index 000000000..63f49b8e3 --- /dev/null +++ b/resources/tester/helper_848_1_cover_layers.cjs @@ -0,0 +1,36 @@ +/* 848-1 겹쳐 덮는 층 거울 헬퍼 — common_util_formula_doc_cover.ts 를 그 자리에서 트랜스파일해 Node 로 돌림. + * stdin = {경우: [{위, 나, 기본}]} + * stdout = {답: [{합침: mergeCover, 층: mergeLayers, 정리: prune, 위값: upperOf, 출처: sourcesOf}]} */ +const fs = require("fs"); +const path = require("path"); +const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript")); + +const cache = new Map(); +function load(at) { + if (cache.has(at)) return cache.get(at); + const js = ts.transpileModule(fs.readFileSync(at, "utf8"), { + compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }, + }).outputText; + const box = { exports: {} }; + cache.set(at, box.exports); + const need = (p) => + p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p); + new Function("exports", "module", "require", js)(box.exports, box, need); + return box.exports; +} +const cover = load(path.join(__dirname, "..", "..", "common_util", "common_util_formula_doc_cover.ts")); + +const input = JSON.parse(fs.readFileSync(0, "utf8")); +const out = { 답: [] }; +for (const one of input.경우 || []) { + const up = one.위 ?? null; + const me = one.나 ?? null; + out.답.push({ + 합침: cover.mergeCover(up, me), + 층: cover.mergeLayers(up ? { K: up } : null, me ? { K: me } : null), + 정리: me ? cover.prune(me, one.기본, up) : null, + 위값: cover.upperOf(one.기본, up), + 출처: cover.sourcesOf(up, me), + }); +} +process.stdout.write(JSON.stringify(out)); diff --git a/resources/tester/test_821_2_machine_save.py b/resources/tester/test_821_2_machine_save.py index 1cc972cdb..aae8b0fb9 100644 --- a/resources/tester/test_821_2_machine_save.py +++ b/resources/tester/test_821_2_machine_save.py @@ -25,6 +25,7 @@ sys.path.insert( 0, str(Path(__file__).resolve().parents[2] / "resources" / "master_data" / "scripts") ) import master_machine_coef as mc # noqa: E402 +import master_doc_link as mdl # noqa: E402 REAL = store.FOLDER MACHINE = "기계.json" @@ -36,7 +37,9 @@ def copy(tmp_path: Path, monkeypatch) -> Path: 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) + shutil.copytree(mdl.FOLDER, tmp_path / "수식문서") # [새 기계] = 문서 기계 목록도(848-5) monkeypatch.setattr(store, "FOLDER", tmp_path) + monkeypatch.setattr(mdl, "FOLDER", tmp_path / "수식문서") return tmp_path @@ -165,7 +168,11 @@ def test_기계_길은_시스템_관리자만() -> None: def test_쓰는_곳_찾기(copy: Path, monkeypatch) -> None: from M02_MasterTemplete import M02_Template_Layers as layers + from M01_MasterData import M01_MasterData_Machine_Uses as mu + monkeypatch.setattr(layers, "layer_files", lambda kind: []) # 공유 storage 안 읽음 + monkeypatch.setattr(layers, "storage_root", lambda: copy) # 프로젝트 사본 · 색인 저장본도 + monkeypatch.setattr(mu, "_SK", {}) uses = _app().get("/api/m01/machine/uses", params={"key": "EQ000022"}).json()["uses"] assert any("GC000267" in u for u in uses) assert _app().get("/api/m01/machine/uses", params={"key": "EQ999999"}).status_code == 404 diff --git a/resources/tester/test_822_2_machine_hourly_all.py b/resources/tester/test_822_2_machine_hourly_all.py index 2c0a2421b..e25894b49 100644 --- a/resources/tester/test_822_2_machine_hourly_all.py +++ b/resources/tester/test_822_2_machine_hourly_all.py @@ -34,6 +34,7 @@ ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT / "resources" / "master_data" / "scripts")) import master_machine_coef as mc # noqa: E402 import master_machine_crew as mcrew # noqa: E402 +import master_doc_link as mdl # noqa: E402 MACHINE, LOGIC = "기계.json", "로직_건설품셈_08장_건설기계.json" POWER, POWER_CREW, ONE_FUEL, DIRECT = "GC001196", "GC001197", "GC001198", "GC001199" @@ -107,7 +108,9 @@ def copy(tmp_path: Path, monkeypatch) -> Path: if not path.name.startswith("_") or path.name == m01.mk.BOOK.name: shutil.copy(path, tmp_path / path.name) shutil.copytree(m01.FOLDER / "기계", tmp_path / "기계") # 기계 = 폴더(826-2) + shutil.copytree(mdl.FOLDER, tmp_path / "수식문서") # [새 기계] = 문서 기계 목록도(848-5) monkeypatch.setattr(m01, "FOLDER", tmp_path) + monkeypatch.setattr(mdl, "FOLDER", tmp_path / "수식문서") return tmp_path diff --git a/resources/tester/test_848_1_cover_layers.py b/resources/tester/test_848_1_cover_layers.py new file mode 100644 index 000000000..6d900a91f --- /dev/null +++ b/resources/tester/test_848_1_cover_layers.py @@ -0,0 +1,362 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기. + +① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조). +㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 · + 문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) · + ㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전. +㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 · + ㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 · + ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도). +㉧ 기초 A 가 B 를 부를 때 A 의 고침만 A 셈에. +정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage. +""" + +import copy as cp +import importlib +import json +import os +import shutil +import subprocess +from decimal import Decimal as D + +import pytest + +from M01_MasterData import M01_MasterData_Doc as m01doc +from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠 +from M02_MasterTemplete import M02_Doc_Copy as dc +from M02_MasterTemplete import M02_Doc_Sk_Path as path +from M02_MasterTemplete import M02_Item_Prices as item_prices +from M02_MasterTemplete import M02_Item_Source as source +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Labor_SkRow as skrow +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +mc = importlib.import_module("master_doc_calc") +ml = importlib.import_module("master_doc_link") +mcv = importlib.import_module("master_doc_cover") +cv = importlib.import_module("master_doc_convert") +build = importlib.import_module("build_수식문서_802_2") + +HERE = os.path.dirname(os.path.abspath(__file__)) +COVER = mcv.COVER +BASE = "GC000088" # 터파기(기계) 보통토사 — 굴착기 줄 하나(TypeⅠ = 1.0㎥ · TypeⅢ = 0.6㎥) +NO, NO3 = "0201-0100", "0201-0060" +SYM = "P_굴착기무한궤" # 그 줄 단가 기호 = 작업량 덮음 열쇠(847-1) +TPL = "GC001147" # 굴착기 시간당 작업량 식 + +# ── ① 거울 ──────────────────────────────────────────────────────────── +BASE0 = {"값": {"가격": 100, "주연료": 10}, "조종원": [{"키": "LB:1", "인": 1}], + "잡품": [{"줄": "주연료", "율": 22}], "작업량": {"f": 0.7, "E": 0.5}} # fmt: skip +U1 = {"값": {"가격": 150}, "조종원": [{"키": "LB:1", "인": 2}], + "작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8}}} # fmt: skip +U2 = {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}} +MINES = [ + None, + {"값": {"가격": 150, "주연료": 20}}, + {"값": {"가격": 100}}, + {"조종원": [{"키": "LB:1", "인": 2}]}, + {"조종원": [{"키": "LB:1", "인": 1}]}, + {"잡품": []}, + {"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, + {"작업량": {"방식": "일당"}}, + {"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, + {"작업량": {"변수": {"E": 0.6}}}, + {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}}, + {"작업량": {"방식": "시간당", "식": "T1", "기계": NO, "이름": "굴착기 1.0㎥"}}, +] + + +def test_층_합침_정리_출처_손셈(): + p = mcv.prune + assert p({"값": {"가격": 150, "주연료": 20}}, BASE0, U1) == {"값": {"주연료": 20}} + assert p({"값": {"가격": 100}}, BASE0, U1) == {"값": {"가격": 100}} # 정본 값 = 위 층과 다름 + assert p({"값": {"가격": 100}}, BASE0) is None # 위 층 없음 = 지금과 같음 + assert p({"조종원": [{"키": "LB:1", "인": 2}]}, BASE0, U1) is None + assert ( + p({"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, BASE0, U1) + is None + ) + assert p({"작업량": {"방식": "일당"}}, BASE0, U1) == {"작업량": {"방식": "일당"}} + assert p({"작업량": {"방식": "일당"}}, BASE0) is None + want = {"작업량": {"식": "T2", "변수": {"f": 0.8}}} # 식 바꿈 = 위 층 변수 안 물려받음 + assert p({"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, BASE0, U1) == want + assert p({"작업량": {"변수": {"E": 0.6}}}, BASE0, U1) == {"작업량": {"변수": {"E": 0.6}}} + assert p(U2, BASE0, U2) is None and p(U2, BASE0) == U2 + assert mcv.merge(U1, {"작업량": {"식": "T2"}})["작업량"] == {"방식": "시간당", "식": "T2"} + assert mcv.merge(U1, {"작업량": {"방식": "일당"}})["작업량"]["방식"] == "일당" + assert mcv.merge(U2, {"작업량": {"기계": NO}})["작업량"] == { + "방식": "시간당", + "식": "T1", + "기계": NO, + } + got = mcv.sources(U1, {"값": {"주연료": 20}, "작업량": {"변수": {"E": 0.6}}}) + assert got == {"값.가격": "위", "조종원": "위", "작업량.방식": "위", "작업량.식": "위", + "작업량.변수.f": "위", "값.주연료": "나", "작업량.변수.E": "나"} # fmt: skip + assert mcv.sources(U1, {"작업량": {"식": "T2"}})["작업량.식"] == "나" + assert "작업량.변수.f" not in mcv.sources(U1, {"작업량": {"식": "T2"}}) + assert mcv.upper_of(BASE0, U1) == {"값": {"가격": 150, "주연료": 10}, "조종원": U1["조종원"], + "잡품": BASE0["잡품"], "작업량": U1["작업량"]} # fmt: skip + mine = {"개인 EQP000001": {"값": {"가격": 1}}} # 내 기계 열쇠 = 같은 꼴 + assert mcv.merge_layers(None, mine) is mine and mcv.merge_layers(mine, {}) is mine + assert mcv.merge_layers({"개인 EQP000001": U1}, mine)["개인 EQP000001"]["값"] == {"가격": 1} + + +def _same(a, b, where=""): + if isinstance(a, dict): + assert isinstance(b, dict) and set(a) == set(b), (where, a, b) + for k in a: + _same(a[k], b[k], f"{where}.{k}") + elif isinstance(a, list): + assert isinstance(b, list) and len(a) == len(b), (where, a, b) + for i, (x, y) in enumerate(zip(a, b)): + _same(x, y, f"{where}[{i}]") + elif isinstance(a, (int, float)) and not isinstance(a, bool): + assert float(a) == pytest.approx(b), (where, a, b) + else: + assert a == b, (where, a, b) + + +def test_거울_파이썬_TS_같은_답(): + cases = [{"위": u, "나": m, "기본": BASE0} for u in (None, U1, U2) for m in MINES] + want = [ + { + "합침": mcv.merge(c["위"], c["나"]), + "층": mcv.merge_layers( + {"K": c["위"]} if c["위"] else None, {"K": c["나"]} if c["나"] else None + ), + "정리": mcv.prune(c["나"], BASE0, c["위"]) if c["나"] else None, + "위값": mcv.upper_of(BASE0, c["위"]), + "출처": mcv.sources(c["위"], c["나"]), + } + for c in cases + ] + proc = subprocess.run( + ["node", os.path.join(HERE, "helper_848_1_cover_layers.cjs")], + input=json.dumps({"경우": cases}, ensure_ascii=False), + capture_output=True, + text=True, + encoding="utf-8", + check=True, + ) + got = json.loads(proc.stdout)["답"] + assert len(got) == len(want) == 36 + for i, (a, b) in enumerate(zip(want, got)): + _same(a, b, f"경우{i}") + + +# ── 임시 수식 문서 폴더(정본 파일 안 고침) ────────────────────────────── +@pytest.fixture +def docs_tmp(tmp_path, monkeypatch): + dst = tmp_path / "수식문서" + shutil.copytree(ml.FOLDER, dst) + load = ml.load_all + monkeypatch.setattr(ml, "FOLDER", dst) + monkeypatch.setattr(ml, "load_all", lambda folder=dst: load(folder)) + m01doc._memo.clear() + dc._FOLDER["자국"] = None + yield dst + m01doc._memo.clear() + dc._FOLDER["자국"] = None + + +def _json(v): + """화면 왕복(JSON 수).""" + return json.loads(json.dumps(ml._norm(v), ensure_ascii=False)) + + +def _norm(v): + return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, sort_keys=True)) + + +def _defaults() -> dict: + """정본 — BASE 기본 옵션 굴착기(NO)의 덮음 없는 기본값.""" + links = ml.Links(m01.loaded()[1]) + memo: dict = {} + doc = {k: v for k, v in links.doc(BASE).items() if k != COVER} + mc.calc(doc, links, None, (), memo) + for (key, given), ans in memo.items(): + if mcv.is_machine(sub := links.doc(key)) and mcv.machine_key(dict(given)) == NO: + lists = mcv.lists_of(links, dict(given)) + return mcv.defaults_of(sub, ans["값"], mcv.row_entry(sub, lists)) + raise AssertionError("굴착기 부름 없음") + + +def _upper(d: dict, rate=D("1.5")) -> dict: + """기초 고침 ① — 가격 · 조종원 · 작업량(시간당 + 변수 f).""" + return {NO: {"값": {"가격": float(D(str(d["값"]["가격"])) * rate)}, + "조종원": [{"키": d["조종원"][0]["키"], "인": 2}]}, + SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip + + +def _save_m01(cover: dict | None, edit=None) -> dict: + doc = _json(m01doc.read(BASE)["문서"]) + doc.pop(COVER, None) + if cover: + doc[COVER] = _json(cover) + if edit: + edit(doc) + return m01doc.save(doc) + + +def _calls(key: str) -> bool: + return any( + (v.get("연결") or {}).get("키") == "GC000267" for v in m01doc.docs()[key].get("변수") or [] + ) + + +def _mini(): + """빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}.""" + files, whole = m01.loaded() + name = next( + n + for n, d in files.items() + if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or []) + ) + rows = files[name]["줄"] + keys = [str(r["키"]) for r in rows] + result = { + "문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows}, + "파일": {name: keys}, + "저장": set(keys) & build.saved_keys(), + "저장본": build.carried(), + } + return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name) + + +def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp): + d = _defaults() + result, text, file = _mini() + orig = file.read_bytes() + assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본 + other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k)) + before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"] + price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] + # ㉠ 고침 저장 — 문서 밖 기계(9999) = 뺌 + want = _upper(d) + got = _save_m01({**want, "9999-9999": {"값": {"가격": 1}}}) + saved = ml.load_all()[BASE] + assert _norm(saved[COVER]) == _norm(want) and mcv.HAND not in saved + assert got["셈"]["계"] != before and m01doc.read(BASE)["셈"]["계"] == got["셈"]["계"] + assert m01doc.read(other)["셈"]["계"] == other_before # 다른 기초 그대로 + assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로 + line = next(x for x in got["셈"]["줄"] if x.get("작업량")) + assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8" + # ㉥ 빌더 — 덮음 얹음(글 = 저장본) + result, text, _ = _mini() + assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [] + + # ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음 + def qty(text_): + return lambda doc: doc["금액"][0].update({"수량": text_}) + + first = m01doc.read(BASE)["문서"]["금액"][0]["수량"] + _save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공")) + assert ml.load_all()[BASE].get(mcv.HAND) is True + result, text, _ = _mini() + assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE] + _save_m01(want, qty(first)) + assert mcv.HAND not in ml.load_all()[BASE] + # ㉣ 정본 값으로 되돌림 = 고침 0 · 바이트 = 고침 전 + back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]}, + SYM: {"작업량": {"방식": "일당"}}} # fmt: skip + got = _save_m01(back) + assert COVER not in got["문서"] and file.read_bytes() == orig + assert got["셈"]["계"] == before + + +def _sk(me) -> str: + with store.at(me): + body = skrow.logic_doc({"로직": BASE, "입력값": {}}, {}, m01.loaded()[1]) + return refs.create("sangeun", {**body, "이름": "sub2임시 848"})["이름"] + + +def _at(me, fn, *args): + with store.at(me): + return fn(*args) + + +def _mixed_sum(cover: dict) -> float: + """기초 문서(덮음 뗌)에 cover 를 얹은 셈 계 — SK 금액 대조.""" + links = ml.Links(m01.loaded()[1]) + doc = {k: v for k, v in links.doc(BASE).items() if k != COVER} + return float(mc.calc(doc, links, None, (), None, cover)["계"]) + + +def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world): + me = world["personal"] + d = _defaults() + upper = _upper(d) + _save_m01(upper) + base_sum = float(m01doc.read(BASE)["셈"]["계"]) + key = _sk(me) + got = _at(me, path.read, key) + # ㉡ ① = 위덮음 · 금액 = 기초 금액 · 파일에 굳음 + assert _norm(got["위덮음"]) == _norm(upper) and COVER not in got["문서"] + assert float(got["셈"]["계"]) == base_sum + with store.at(me): + file = store.read("sangeun", key)["문서"]["수식"] + assert _norm(file[mcv.UPPER]) == _norm(upper) + # SK 에서 한 칸 더 고침 → ② 에만(① 과 같은 가격 = 지움 · 작업량 = 바꾼 변수만) + doc = cp.deepcopy(got["문서"]) + doc[COVER] = {NO: {"값": {"가격": upper[NO]["값"]["가격"], "주연료": 20}}, + SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.9}}}} # fmt: skip + after = _at(me, path.save, key, {"문서": doc, "판": got["판"]}) + mine = {NO: {"값": {"주연료": 20}}, SYM: {"작업량": {"변수": {"f": 0.9}}}} + assert _norm(after["문서"][COVER]) == _norm(mine) and _norm(after["위덮음"]) == _norm(upper) + assert float(after["셈"]["계"]) == _mixed_sum(mcv.merge_layers(upper, mine)) != base_sum + assert mcv.sources(upper[NO], mine[NO]) == {"값.가격": "위", "조종원": "위", "값.주연료": "나"} + assert mcv.sources(upper[SYM], mine[SYM]) == { + "작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "나" + } # fmt: skip + # ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도) + with store.at(me): + here = refs.here() + ref = {"층": here[0], "주인": here[1], "키": key} + rows = source.labor_doc_rows( + {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} + ) + bundle = source.price_bundle(rows, me) + frozen = rows["참조사본"][refs.ref_id(ref)]["수식"] + assert _norm(frozen[mcv.UPPER]) == _norm(upper) + was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) + assert was == float(after["셈"]["계"]) + _save_m01(_upper(d, D(2))) # 기초 고침이 바뀜 + now = _at(me, path.read, key) + assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것 + assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것 + _save_m01(upper) + # ㉢ ② 를 위 층 값으로 = ② 0 + now = _at(me, path.read, key) + doc = cp.deepcopy(now["문서"]) + doc[COVER] = {NO: {"값": {"주연료": d["값"]["주연료"]}}, + SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip + back = _at(me, path.save, key, {"문서": doc, "판": now["판"]}) + assert COVER not in back["문서"] and float(back["셈"]["계"]) == base_sum + with store.at(me): + assert COVER not in store.read("sangeun", key)["문서"]["수식"]["문서"] + # ㉤ 옵션으로 기계를 바꿔 저장 = 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 + doc = cp.deepcopy(back["문서"]) + next(v for v in doc["변수"] if v["열쇠"] == "Type")["연결"]["값"] = "TypeⅢ" + doc[COVER] = {NO: {"값": {"주연료": 20}}, "9999-9999": {"값": {"가격": 1}}} + moved = _at(me, path.save, key, {"문서": doc, "판": back["판"]}) + assert moved["문서"][COVER] == {NO: {"값": {"주연료": 20}}} + line = next(x for x in moved["셈"]["줄"] if x.get("작업량")) + assert line["작업량"]["기계"] == NO3 # 셈은 바꾼 기계(앞 기계 고침은 안 걸림) + + +def test_A_가_B_를_부를_때_A_고침만(): + links = ml.Links(m01.loaded()[1]) + a, b, no = "GF000177", "GF000168", "0201-0070" + price = float(m01.loaded()[1].numbers["EQ"][no]["값"]["가격"]) + cover = {no: {"값": {"가격": price * 2}}} + given = {"기초잡석량": D(1)} # A(날개벽) 기초잡석 1 ㎥ = B(기초잡석) 부름 + plain_a = mc.calc(links.doc(a), links, given)["계"] + plain_b = mc.calc(links.doc(b), links)["계"] + assert plain_a > 0 + with_b = ml.Links(m01.loaded()[1], {**links.docs, b: {**links.doc(b), COVER: cover}}) + assert mc.calc(with_b.doc(a), with_b, given)["계"] == plain_a # B 의 고침 = A 셈에 안 걸림 + assert mc.calc(with_b.doc(b), with_b)["계"] != plain_b # B 를 맨 위로 열면 걸림 + mine = mc.calc({**links.doc(a), COVER: cover}, links, given)["계"] + assert mine > plain_a # A 고침 = B 안 기계 줄까지 diff --git a/resources/tester/test_848_5_machine_impact.py b/resources/tester/test_848_5_machine_impact.py new file mode 100644 index 000000000..11be143d6 --- /dev/null +++ b/resources/tester/test_848_5_machine_impact.py @@ -0,0 +1,259 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""848-5 기계 쓰는 곳 · 저장 전 영향 · 새 기계 목록 — 지킴 시험(정본 · 공유 storage 안 씀). + +① 쓰는 곳 = 수식 문서 기준(고르기 목록 · 박힌 입력 · EQ 요소) — 조사 889a 실측 수 · 사슬 상한 +② 영향 = 가격 +10 % → 금액 바뀌는 기초(기본 옵션) 38 · 42 · 8 · 정본 기억 그대로 · 같은 값 = 묻지 않음 +③ 따로 고쳐 둔 곳 = 바뀐 칸을 덮은 SK(② 내 고침 · ① 위 층 따로) · 프로젝트 사본 층 수 · 색인 다시 지음 +④ 내 기계 영향 = 이 층 쓰는 SK · 덮음 · 남의 층 안 보임 ⑤ 권한 ⑥ 로직 · 문서 기계 목록 한 벌 · 새 기계 = 둘 다 +""" + +from __future__ import annotations + +import json +import shutil +from pathlib import Path + +import pytest +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_Doc as docmod +from M01_MasterData import M01_MasterData_Machine as machine +from M01_MasterData import M01_MasterData_Machine_Impact as mi +from M01_MasterData import M01_MasterData_Machine_Uses as mu +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_MyMachine as mym +from M02_MasterTemplete import M02_MyMachine_Impact as myi +from M02_MasterTemplete import M02_Template_Layers as layers +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +ml = docmod.ml # 수식 문서 저장 자리(scripts 모듈) +DIG06, DIG02, DIG012 = "EQ000019", "EQ000017", "EQ000016" # 굴착기(무한궤도) 0.6 · 0.2 · 0.12㎥ + + +@pytest.fixture(autouse=True) +def _fresh(monkeypatch): + monkeypatch.setattr(mu, "_SK", {}) + + +def _row(key: str, **vals) -> dict: + row = json.loads(json.dumps(m01.loaded()[1].index["EQ"][key], default=float)) + row["값"] |= vals + return row + + +def _batch(key: str, **vals) -> list[dict]: + change = {"op": "edit", "key": key, "row": _row(key, **vals)} + return [{"file": machine.FILE, "version": m01.version(machine.FILE), "changes": [change]}] + + +def _price(key: str, rate: float = 1.1) -> list[dict]: + return _batch(key, 가격=float(m01.loaded()[1].index["EQ"][key]["값"]["가격"]) * rate) + + +def _app(role: str = "SYSTEM_ADMIN") -> TestClient: + app = FastAPI() + app.dependency_overrides[auth.verify_session] = lambda: { + "user_id": 1, "name": "시험", "role": role, "company_id": 1, + } # fmt: skip + deps = [Depends(auth.verify_session), Depends(auth.require_system_admin)] + app.include_router(router_module.router, dependencies=deps) + return TestClient(app) + + +# ① 쓰는 곳 ─────────────────────────────────────────────────────────── +@pytest.mark.parametrize( + ("key", "direct", "reach"), + [ + (DIG02, 68, 293), # 옛 코드 11 + (DIG06, 54, 293), # 옛 12 + ("EQ000031", 9, 134), # 대형 브레이커 0.2㎥ — 입력 이름 「브레이커」(옛 2) + ("EQ000436", 26, 132), # 부착용 집게 0.2㎥ — 입력 이름 「집게」(옛 1) + ("EQ000128", 106, 349), # 크레인(타이어) 10ton(옛 4) + ], +) +def test_uses_by_formula_docs(key, direct, reach, world): + got = mu.uses(key) + assert (got["직접"], got["직접"] + got["사슬"]) == (direct, reach) + assert len(got["uses"]) == direct and 0 < got["기본"] <= direct + assert got["단가산출"] == {"마스터": 0, "회사": 0, "개인": 0, "프로젝트": 0} # 빈 임시 storage + + +def test_uses_missing_machine(): + with pytest.raises(m01.StoreError): + mu.uses("EQ999999") + + +# ② 영향 ───────────────────────────────────────────────────────────── +@pytest.mark.parametrize(("key", "moved"), [(DIG06, 38), (DIG02, 42), (DIG012, 8)]) +def test_price_up_changes_docs(key, moved, world): + before = m01.loaded()[1].index["EQ"][key]["값"]["가격"] + got = mi.impact(_price(key)) + assert got["바뀜"] == moved and got["기계"][0]["칸"] == ["가격"] + top = got["위"] + assert len(top) == 5 and all(t["후"] > t["전"] for t in top) + assert m01.loaded()[1].index["EQ"][key]["값"]["가격"] == before # 정본 기억 그대로 + + +def test_same_value_or_meta_only_asks_nothing(world): + assert mi.impact(_batch(DIG06))["기계"] == [] + meta = _batch(DIG06) + meta[0]["changes"][0]["row"]["비고"] = "sub5임시" + assert mi.impact(meta)["기계"] == [] + + +# ③ 따로 고쳐 둔 곳 · 층 수 · 색인 ────────────────────────────────────── +def _put(folder: Path, name: str, body: dict) -> Path: + folder.mkdir(parents=True, exist_ok=True) + path = folder / f"{name}.json" + path.write_text(json.dumps({"키": name, "이름": f"sub5임시 {name}", **body}), encoding="utf-8") + return path + + +def _sks(world) -> Path: + me = world["personal"] / "sangeun" + code = "0201-0060" # 굴착기 0.6㎥ + _put( + me, + "SK-000001", + {"수식": {"단가": [{"키": DIG06}], "문서": {"기계덮음": {code: {"값": {"가격": 1}}}}}}, + ) + _put( + me, "SK-000002", {"수식": {"단가": [{"키": DIG06}], "위덮음": {code: {"값": {"가격": 2}}}}} + ) + _put( + me, + "SK-000003", + {"수식": {"단가": [{"키": DIG06}], "문서": {"기계덮음": {code: {"값": {"내용시간": 9}}}}}}, + ) + _put(me, "SK-000004", {"수식": {"단가": [{"키": "EQ000022"}]}}) + project = layers.storage_root() / "7" / "42" / "p-sub5" / "templates" / "sangeun" + _put(project, "SK-000001", {"사본": {"단가": [{"키": DIG06}]}}) + return me + + +def test_override_and_layers(world): + me = _sks(world) + m = mi.impact(_price(DIG06))["기계"][0] + assert m["고침"] == {"기초": 0, "단가산출": 1, "위층": 1} # 내용시간 덮음 = 가격과 무관 + assert m["단가산출"] == {"마스터": 0, "회사": 0, "개인": 3, "프로젝트": 1} + life = mi.impact(_batch(DIG06, 내용시간=12000))["기계"][0] + assert life["고침"]["단가산출"] == 1 and "내용시간" in life["칸"] + assert mu.uses(DIG06)["고침"] == {"기초": 0, "단가산출": 2, "위층": 1} + # 색인 = 파생 저장본 — 지워도 다시 지음 · SK 저장(자국 바뀜) = 그 파일만 다시 읽음 + shutil.rmtree(layers.storage_root() / "_derived") + mu._SK.clear() + assert mu.uses(DIG06)["단가산출"]["개인"] == 3 + _put(me, "SK-000004", {"수식": {"단가": [{"키": DIG06}]}}) + assert mu.uses(DIG06)["단가산출"]["개인"] == 4 + + +# ④ 내 기계 ─────────────────────────────────────────────────────────── +def test_my_machine_impact(world): + me = world["personal"] + with store.at(me): + made = mym.create({"이름": "sub5임시", "규격": "1㎾", "방식": "바로", + "값": {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유"}}) # fmt: skip + key, no = made["줄"]["키"], made["줄"]["원문번호"] + body = {**made["줄"], "값": {**made["줄"]["값"], "가격": 3000}} + _put(me / "sangeun", "SK-000001", {"수식": {"단가": [{"키": key}]}}) + _put( + me / "sangeun", + "SK-000002", + {"수식": {"단가": [{"키": key}], "문서": {"기계덮음": {no: {"값": {"가격": 9}}}}}}, + ) + _put(me / "sangeun", "SK-000003", {"수식": {"단가": [{"키": "EQ000022"}]}}) + other = layers.personal_dir(7, 43) / "sangeun" + _put(other, "SK-000009", {"수식": {"단가": [{"키": key}]}}) # 남의 층 — 안 보임 + with store.at(me): + got = myi.impact(key, body) + assert myi.impact(key, made["줄"])["칸"] == [] # 안 바꿈 + with pytest.raises(store.StoreError): + myi.impact("EQP42-9999", body) + assert got["칸"] == ["가격"] and got["고침"] == 1 and got["위층"] == 0 + assert [(u["키"], u["고침"]) for u in got["쓰는곳"]] == [ + ("SK-000001", False), + ("SK-000002", True), + ] + + +# ⑤ 권한 ───────────────────────────────────────────────────────────── +def test_only_system_admin(): + for role in ("USER", "COMPANY_ADMIN"): + client = _app(role) + assert client.get("/api/m01/machine/uses", params={"key": DIG06}).status_code == 403 + assert client.post("/api/m01/machine/impact", json={"files": []}).status_code == 403 + got = _app().post("/api/m01/machine/impact", json={"files": []}).json() + assert got == {"기계": [], "바뀜": 0, "셈": 0, "위": []} + + +# ⑥ 기계 목록 한 벌 ───────────────────────────────────────────────────── +def _pairs(logic_folder: Path, docs: dict) -> tuple[int, int]: + logic = {} + for path in logic_folder.glob("로직_*.json"): + for r in json.loads(path.read_text(encoding="utf-8")).get("줄") or []: + logic[str(r["키"])] = { + i["이름"]: i.get("고르기") for i in r.get("입력") or [] if i.get("고르기") + } + n = bad = 0 + for k, d in docs.items(): + picks = logic.get(k) or {} + for v in d.get("변수") or []: + link = v.get("연결") or {} + if link.get("갈래") == "선택" and v.get("이름") in picks: + n += 1 + bad += [str(x) for x in picks[v["이름"]]] != [str(x) for x in link["목록"]] + return n, bad + + +def test_logic_and_doc_lists_match(): + n, bad = _pairs(m01.FOLDER, ml.load_all()) + assert n > 2000 and bad == 0 + + +@pytest.fixture +def copy(tmp_path: Path, monkeypatch) -> Path: + for path in m01.FOLDER.glob("*.json"): + if not path.name.startswith("_") or path.name == m01.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + shutil.copytree(m01.FOLDER / "기계", tmp_path / "기계") + shutil.copytree(ml.FOLDER, tmp_path / "수식문서") + monkeypatch.setattr(m01, "FOLDER", tmp_path) + monkeypatch.setattr(ml, "FOLDER", tmp_path / "수식문서") + return tmp_path + + +def _text(path: Path) -> bytes: + return path.read_bytes().replace(b"\r\n", b"\n") # 체크아웃 줄끝(CRLF) = 문서 화면 저장(LF) + + +def test_new_machine_goes_to_both_lists(copy: Path): + client, docs_dir = _app(), copy / "수식문서" + before = {p.name: _text(p) for p in docs_dir.glob("*.json")} + row = { + **_row("EQ000022"), + "키": "", + "원문번호": "9999-0848", + "이름": "sub5임시", + "출처": {}, + "단위": {}, + } + row.pop("별칭", None) + + def save(changes): + version = client.get("/api/m01/machine/row", params={"key": "EQ000022"}).json()["version"] + body = {"files": [{"file": machine.FILE, "version": version, "changes": changes}]} + assert client.post("/api/m01/save", json=body).status_code == 200 + + save([{"op": "add", "row": row}]) + doc = ml.load_all(docs_dir)["GC000268"] + assert "9999-0848" in next(v for v in doc["변수"] if v["이름"] == "기계")["연결"]["목록"] + assert _pairs(copy, ml.load_all(docs_dir))[1] == 0 + key = next( + r["키"] for r in m01.loaded()[1].index["EQ"].values() if r["원문번호"] == "9999-0848" + ) + save([{"op": "delete", "key": key}]) + assert {p.name: _text(p) for p in docs_dir.glob("*.json")} == before # 지우면 글 그대로