feat(848-5): 기계 정본 저장 전 영향 확인창 · 쓰는 곳 = 수식 문서 기준 · [새 기계] 목록 두 벌 같이

- 쓰는 곳 색인(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 <noreply@anthropic.com>
This commit is contained in:
2026-11-16 20:09:03 +09:00
co-authored by Claude Opus 5.5
parent c327c72a73
commit 59d20ae464
19 changed files with 1070 additions and 69 deletions
+27 -54
View File
@@ -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) ──────────────
# ── 비슷한 기계 찾기 · 한 줄 ─────────────────────────────────────────
+46 -4
View File
@@ -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<MachineLists> => {
export const fetchMachineHourly = (keys: string[]): Promise<Record<string, MachineHourly>> =>
keys.length ? get("/hourly", { keys: keys.join(",") }) : Promise.resolve({});
export const fetchMachineUses = async (key: string): Promise<string[]> =>
(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<MachineUses> => 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<MachineImpact> {
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<Row[]> =>
(await get<{ rows: Row[] }>("/find", { q })).rows;
@@ -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]
],
}
@@ -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),
}
+10 -1
View File
@@ -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")
+4 -1
View File
@@ -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
]
@@ -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);
}
@@ -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);
@@ -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<boolean> {
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] : []),
],
});
}
+2
View File
@@ -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));