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:
@@ -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) ──────────────
|
||||
|
||||
|
||||
# ── 비슷한 기계 찾기 · 한 줄 ─────────────────────────────────────────
|
||||
|
||||
@@ -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),
|
||||
}
|
||||
@@ -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")
|
||||
|
||||
@@ -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] : []),
|
||||
],
|
||||
});
|
||||
}
|
||||
@@ -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));
|
||||
|
||||
Reference in New Issue
Block a user