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));
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -120,6 +120,20 @@ export const updateMyMachine = (
|
||||
): Promise<MyMachineOne> =>
|
||||
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<MyMachineImpact> =>
|
||||
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" });
|
||||
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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["위층"]),
|
||||
}
|
||||
@@ -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<boolean> {
|
||||
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,
|
||||
],
|
||||
}),
|
||||
});
|
||||
}
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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 # 지우면 글 그대로
|
||||
Reference in New Issue
Block a user