From 59d20ae4645f529d004f5a27bb2ab76df509fb58 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 16 Nov 2026 20:09:03 +0900 Subject: [PATCH] =?UTF-8?q?feat(848-5):=20=EA=B8=B0=EA=B3=84=20=EC=A0=95?= =?UTF-8?q?=EB=B3=B8=20=EC=A0=80=EC=9E=A5=20=EC=A0=84=20=EC=98=81=ED=96=A5?= =?UTF-8?q?=20=ED=99=95=EC=9D=B8=EC=B0=BD=20=C2=B7=20=EC=93=B0=EB=8A=94=20?= =?UTF-8?q?=EA=B3=B3=20=3D=20=EC=88=98=EC=8B=9D=20=EB=AC=B8=EC=84=9C=20?= =?UTF-8?q?=EA=B8=B0=EC=A4=80=20=C2=B7=20[=EC=83=88=20=EA=B8=B0=EA=B3=84]?= =?UTF-8?q?=20=EB=AA=A9=EB=A1=9D=20=EB=91=90=20=EB=B2=8C=20=EA=B0=99?= =?UTF-8?q?=EC=9D=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 쓰는 곳 색인(M01_MasterData_Machine_Uses) — 수식 문서 기계 고르기 목록 · 박힌 입력(집게 · 브레이커 포함) · EQ 요소 = 직접 · 기본 선택 · 부름 사슬 따로 · 655 대 조사 목록과 다름 0 - 단가산출 역색인 — 모든 층 + 프로젝트 사본 · 사본 단가 기계 · 바탕(원본 · 부름) · 덮음(② 내 고침 · ① 위덮음 848-1 계약) · 파일 자국 기억 · 파생 저장본(지워도 다시 지음) - 영향 셈(M01_MasterData_Machine_Impact) — 저장과 같은 손질 뒤 고친 기계를 얹은 얕은 복사 마스터로 영향 기초만 전 · 후 셈 · 바뀐 기초 수 · 크게 바뀐 다섯 · 정본 기억 안 건드림 - M01 페이지 [저장] 전 확인창 · 기계 상세 쓰는 곳 표시 새 꼴 · 내 기계 [저장] 전 확인창(이 층 쓰는 단가산출 · 따로 고친 곳) - [새 기계] 저장 = 로직 목록과 같은 더함 · 뺌을 수식 문서 기계 고르기 목록에도 - 옛 「쓰는 곳」(로직 JSON 입력 이름 「기계」 · 글자 찾기) 걷음 - 시험: test_848_5 새로 · test_821_2 · test_822_2 임시 폴더에 수식 문서도 복사(새 기계 저장이 문서 목록도 고쳐 정본 폴더에 쓰지 않게) · test_821_2 쓰는 곳 = 임시 storage Co-Authored-By: Claude Opus 5.5 --- M01_MasterData/M01_MasterData_Machine.py | 81 ++--- M01_MasterData/M01_MasterData_Machine_Api.ts | 50 +++- .../M01_MasterData_Machine_Impact.py | 166 +++++++++++ M01_MasterData/M01_MasterData_Machine_Uses.py | 279 ++++++++++++++++++ M01_MasterData/M01_MasterData_Router.py | 11 +- M01_MasterData/M01_MasterData_Store_Make.py | 5 +- M01_MasterData/M01_MasterData_UI_Machine.css | 8 + .../M01_MasterData_UI_MachineDetail.ts | 33 ++- .../M01_MasterData_UI_MachineImpact.ts | 97 ++++++ M01_MasterData/M01_MasterData_UI_Page.ts | 2 + M02_MasterTemplete/M02_MyMachine.css | 7 + M02_MasterTemplete/M02_MyMachine_Api.ts | 14 + M02_MasterTemplete/M02_MyMachine_Form.ts | 3 + M02_MasterTemplete/M02_MyMachine_Impact.py | 46 +++ M02_MasterTemplete/M02_MyMachine_Impact.ts | 53 ++++ M02_MasterTemplete/M02_MyMachine_Router.py | 15 +- resources/tester/test_821_2_machine_save.py | 7 + .../tester/test_822_2_machine_hourly_all.py | 3 + resources/tester/test_848_5_machine_impact.py | 259 ++++++++++++++++ 19 files changed, 1070 insertions(+), 69 deletions(-) create mode 100644 M01_MasterData/M01_MasterData_Machine_Impact.py create mode 100644 M01_MasterData/M01_MasterData_Machine_Uses.py create mode 100644 M01_MasterData/M01_MasterData_UI_MachineImpact.ts create mode 100644 M02_MasterTemplete/M02_MyMachine_Impact.py create mode 100644 M02_MasterTemplete/M02_MyMachine_Impact.ts create mode 100644 resources/tester/test_848_5_machine_impact.py 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_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/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_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 # 지우면 글 그대로