Merge remote-tracking branch 'origin/dev' into sub_laptop_3
This commit is contained in:
@@ -7,6 +7,8 @@
|
||||
- 읽기 {키} → {문서, 셈, 연결, 파일, 새} — 문서가 없으면 빈 문서(이름 · 단위 = 로직 줄)
|
||||
- 미리 셈 {문서, 입력} → {셈, 연결} — 쓰기 없음
|
||||
- 저장 {문서} → {문서, 셈, 연결, 파일} — 서버가 정본으로 다시 셈 · 문서 파일에 씀(브라우저 셈 값 안 받음)
|
||||
· 기계덮음(848-1 · 그 기초의 ① 위 층 고침) = 검사 · 정본과 같은 칸 지움(`prune_doc`) · 셈 칸이 빌더 결과와 같으면
|
||||
빌더 글 + 기계덮음 · 다르면 받은 문서 + `손고침`(빌더가 안 덮음 · 같게 되돌려 저장하면 사라짐)
|
||||
권한 = 라우터를 `main.py` 가 `system_admin_only` 로 붙임. M02 는 같은 꼴로 따로(802-4).
|
||||
"""
|
||||
|
||||
@@ -20,6 +22,7 @@ from M01_MasterData import M01_MasterData_Store as store
|
||||
|
||||
import master_doc as md # noqa: E402 — `store` 가 scripts 를 길에 둔 뒤
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_cover as mcv # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
import master_doc_record as mr # noqa: E402
|
||||
import master_equation_link as link # noqa: E402
|
||||
@@ -103,9 +106,47 @@ def _file_for(key: str) -> str:
|
||||
return OWN_FILE
|
||||
|
||||
|
||||
def built(key: str) -> dict | None:
|
||||
"""빌더가 지을 그 키 문서(옛 로직 줄 변환 · `build_수식문서_802_2`) · 로직 줄 없음 · 변환 틀림 = None."""
|
||||
import master_doc_convert as cv
|
||||
|
||||
files, whole = store.loaded()
|
||||
for data in files.values():
|
||||
if data.get("그룹") != "로직":
|
||||
continue
|
||||
for row in data.get("줄") or []:
|
||||
if str(row.get("키")) == key:
|
||||
try:
|
||||
return cv.convert(whole, row)[0]
|
||||
except Exception: # noqa: BLE001 — 변환 틀림 = 빌더 문서 없음(표지 안 담)
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def layered(doc: dict, key: str) -> dict:
|
||||
"""848-1 — 기계덮음 검사 · 정본과 같은 칸 지움 · 셈 칸이 빌더 결과와 같음 = 빌더 문서 + 덮음 ·
|
||||
다름 = 받은 문서 + `손고침` · 빌더가 모르는 키 = 받은 문서 그대로."""
|
||||
links = ml.Links(store.loaded()[1], {**docs(), key: doc})
|
||||
try:
|
||||
doc = mcv.prune_doc(doc, links)
|
||||
except ValueError as e:
|
||||
raise store.StoreError(400, str(e)) from e
|
||||
cover = doc.get(mcv.COVER)
|
||||
bare = {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)}
|
||||
base = built(key)
|
||||
hand = base is not None and ml._norm(bare) != ml._norm(base)
|
||||
if base is not None and not hand:
|
||||
bare = base
|
||||
out = {**bare, **({mcv.HAND: True} if hand else {}), **({mcv.COVER: cover} if cover else {})}
|
||||
if "쌓기" in out: # 줄 쌓기 차림 = 끝 칸(화면 `docOf` 와 같은 차례)
|
||||
out["쌓기"] = out.pop("쌓기")
|
||||
return out
|
||||
|
||||
|
||||
def save(doc: dict) -> dict:
|
||||
doc = _check(doc)
|
||||
key = str(doc["키"]).strip()
|
||||
doc = layered(doc, key)
|
||||
name = _file_for(key)
|
||||
path = folder() / name
|
||||
data = ml.load_file(path) if path.exists() else {"그룹": "수식문서", "로직파일": "", "줄": []}
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -6,7 +6,8 @@
|
||||
{판, 시점, 로직 [M01 줄], 단가판, 단가시점, 단가 [M01 자원 줄], ← 값 사본(`M02_Sangeun_Copy` 꼴)
|
||||
부름 {키: 문서}(닫힌 묶음 — 연결 · [재생성] 때 새로) ·
|
||||
SK 만: 문서(이 SK 문서 · 사용자 고침) · 끊음 {키: 문서}(이 사본 안에 굳힌 부름 · 고칠 수 있음) ·
|
||||
따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음)}
|
||||
따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) ·
|
||||
위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)}
|
||||
셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) ·
|
||||
[단가 갱신] = 자원 단가 줄만 지금 M01(`skc.refresh`) · 문서 그대로 · [재생성] = 지금 M01 문서로.
|
||||
부름 문서 = 값 사본 줄이 지금 M01 줄과 같으면 M01 문서(`수식문서/`) · 다르면(만든 때 옛 줄) 그 줄을
|
||||
@@ -36,6 +37,7 @@ import master_auto as mau # noqa: E402
|
||||
import master_doc as md # noqa: E402
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_convert as cv # noqa: E402
|
||||
import master_doc_cover as mcv # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
import master_doc_work as mw # noqa: E402
|
||||
|
||||
@@ -56,6 +58,25 @@ def fp(value: Any) -> str:
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
#: 문서 셈 칸(848-2) — 덮음 · 손고침 · 쌓기 · 이름은 안 견줌
|
||||
LOGIC = ("변수", "식", "금액", "끝수", "결과단위") # fmt: skip
|
||||
#: 변수 · 식 · 금액 줄의 글 칸(연결 안 `단위` 는 셈 칸)
|
||||
LABEL = ("이름", "규격", "단위", "비고", "출처") # fmt: skip
|
||||
|
||||
|
||||
def doc_fp(doc: Any) -> str:
|
||||
"""문서 계산 내용 지문(848-2) — 셈 칸(`LOGIC`)만 · 줄 · 변수의 글 칸 뺌 · 서버 표지 칸 뺌 ·
|
||||
`기계덮음`(②) · `위덮음`(①) · `손고침` 은 셈 칸 밖 = 바뀌어도 같은 지문."""
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
|
||||
doc = doc if isinstance(doc, dict) else {}
|
||||
bare = lambda x: {k: v for k, v in x.items() if k not in LABEL} if isinstance(x, dict) else x # noqa: E731
|
||||
got = {k: doc.get(k) for k in LOGIC}
|
||||
for part in ("변수", "식", "금액"):
|
||||
got[part] = [bare(x) for x in got[part] or []]
|
||||
return fp(dsk._strip(got))
|
||||
|
||||
|
||||
# ── M01 문서(정본 폴더) ────────────────────────────────────────────────
|
||||
_FOLDER: dict[str, Any] = {"자국": None, "문서": {}}
|
||||
|
||||
@@ -139,10 +160,23 @@ def docs_of(copy: dict) -> dict[str, dict]:
|
||||
return {**(copy.get("부름") or {}), **(copy.get("끊음") or {})}
|
||||
|
||||
|
||||
def cover_of(copy: dict, doc: dict | None = None) -> dict:
|
||||
"""셈 cover(848-1) — ① `위덮음` 위에 ② 문서 `기계덮음` · ① 없음 = 문서 칸 그대로."""
|
||||
return mcv.merge_layers(
|
||||
copy.get(mcv.UPPER), mcv.cover_of(copy.get("문서") if doc is None else doc)
|
||||
)
|
||||
|
||||
|
||||
def upper_calls(copy: dict) -> list[str]:
|
||||
"""① 위 층 덮음의 시간당 작업량 식 · 굳은 기계 식 문서 키(부름 닫힌 묶음에 더함 · 848-1)."""
|
||||
return mw.cover_calls({mcv.COVER: copy.get(mcv.UPPER) or {}})
|
||||
|
||||
|
||||
def run(doc: dict, copy: dict, given: dict | None = None, whole: Any = None) -> dict:
|
||||
"""문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저)."""
|
||||
"""문서 셈 — 연결 = 값 사본 · 부름 = 사본 문서(끊음 먼저) · cover = ① + ②(`cover_of`)."""
|
||||
try:
|
||||
return mc.calc(doc, ml.Links(whole or over(copy), docs_of(copy)), given)
|
||||
links = ml.Links(whole or over(copy), docs_of(copy))
|
||||
return mc.calc(doc, links, given, cover=cover_of(copy, doc))
|
||||
except _ERR as e: # 계산기는 예외 없음이 원칙 — 남은 틈도 금액 「—」 로
|
||||
return {"셈됨": False, "표지": [{"갈래": "셈 틀림", "글": str(e)}], **dict.fromkeys(COSTS)}
|
||||
|
||||
@@ -274,10 +308,18 @@ def refresh(copy: dict) -> tuple[dict, list[dict]]:
|
||||
|
||||
|
||||
def state(copy: dict) -> dict[str, Any]:
|
||||
"""{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조."""
|
||||
"""{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조
|
||||
(문서 = 계산 내용만 · 848-2 `doc_fp`)."""
|
||||
got = skc.state(values_of(copy), skc.whole_())
|
||||
live, base = folder(), copy.get("원본") or {}
|
||||
new = {k for k, d in (copy.get("부름") or {}).items() if k in live and fp(d) != fp(live[k])}
|
||||
if base.get("키") in live and fp(live[base["키"]]) != base.get("판"):
|
||||
new.add(base["키"]) # 이 SK 문서를 찍은 M01 문서가 바뀜
|
||||
new = {
|
||||
k for k, d in (copy.get("부름") or {}).items() if k in live and doc_fp(d) != doc_fp(live[k])
|
||||
}
|
||||
if base.get("키") in live and not same_origin(base, live[base["키"]]):
|
||||
new.add(base["키"]) # 이 SK 문서를 찍은 M01 문서의 계산 내용이 바뀜
|
||||
return {**got, "문서새판": sorted(new)}
|
||||
|
||||
|
||||
def same_origin(base: dict, live: Any) -> bool:
|
||||
"""`원본.판` 대 지금 M01 문서 — 계산 내용 지문(`doc_fp`) · 옛 통째 지문(`fp`) 둘 다 받음."""
|
||||
return base.get("판") in (doc_fp(live), fp(live))
|
||||
|
||||
@@ -52,7 +52,7 @@ def gaps(copy: dict) -> list[str]:
|
||||
return []
|
||||
seen = _Seen(dc.over(copy))
|
||||
try:
|
||||
dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)))
|
||||
dc.mc.calc(copy["문서"], dc.ml.Links(seen, dc.docs_of(copy)), cover=dc.cover_of(copy))
|
||||
except dc._ERR:
|
||||
pass
|
||||
have = _have(copy)
|
||||
|
||||
@@ -32,7 +32,7 @@ def record(copy: dict) -> dict[str, Any]:
|
||||
rec = mr.Rec(dc.ml.Links(dc.over(copy), dc.docs_of(copy)))
|
||||
try:
|
||||
rec.prefetch(copy["문서"])
|
||||
dc.mc.calc(copy["문서"], rec)
|
||||
dc.mc.calc(copy["문서"], rec, cover=dc.cover_of(copy)) # ① + ②(848-1)
|
||||
except dc._ERR: # 셈 틀림 = 셈 답 표지(`dc.run`) — 기록은 모은 데까지
|
||||
pass
|
||||
return rec.out()
|
||||
|
||||
@@ -11,6 +11,9 @@ SK `수식`(꼴 = `M02_Doc_Copy`) — `문서` = 이 SK 문서(키 = SK 키 ·
|
||||
SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 사전조합 · 구조물 조합이 이 값을 씀.
|
||||
가져온 식 SK(807-1) = `M02_Doc_Import` 문서(파생 = 가져온 줄 + SK 고침에서 지음 · 따로 =
|
||||
저장본) · 셈 = 단가기준(엑셀 = 엑셀 값 · 우리 = 연결 값) · 바탕 참조 SK = 옛 길(값 사본 없음).
|
||||
위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) —
|
||||
프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 ·
|
||||
파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -29,7 +32,10 @@ from M02_MasterTemplete import M02_Sangeun_Copy as skc
|
||||
from M02_MasterTemplete import M02_Sangeun_Doc as sd
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc
|
||||
|
||||
KEY = dc.KEY
|
||||
UPPER = mcv.UPPER
|
||||
OLD_FIELDS = (
|
||||
"바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개",
|
||||
"수식고침", "고름", "자재표시", "켜쌓기율",
|
||||
@@ -88,7 +94,7 @@ def derive(sk: dict, ctx: tuple) -> dict:
|
||||
same = False
|
||||
plain = dc.doc_of(whole, base_key) if same else None
|
||||
if plain is not None:
|
||||
doc = cp.deepcopy(plain)
|
||||
doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1)
|
||||
_set_values(doc, given)
|
||||
elif not (row.get("호표") or row.get("덧줄") or row.get("결과")):
|
||||
doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))
|
||||
@@ -112,6 +118,30 @@ def seed(sk: dict) -> dict | None:
|
||||
return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))}
|
||||
|
||||
|
||||
def with_upper(sk: dict, got: dict) -> dict:
|
||||
"""① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 ·
|
||||
① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함."""
|
||||
key = str((sk.get("바탕") or {}).get("로직") or "")
|
||||
live = dc.folder().get(key) if key else None
|
||||
if live is None:
|
||||
return got
|
||||
cover = mcv.cover_of(live)
|
||||
if not cover:
|
||||
return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got
|
||||
out = {**got, UPPER: cp.deepcopy(cover)}
|
||||
have = dc.docs_of(out)
|
||||
if need := [k for k in dc.upper_calls(out) if k not in have]:
|
||||
out["부름"] = {**(out.get("부름") or {}), **dc.closure(dc.over(out), need, have)}
|
||||
return out
|
||||
|
||||
|
||||
def upper(sk: dict, got: Any) -> Any:
|
||||
"""셈 길의 ① — 프로젝트 층 밖 · 가져온 식 아님 = 지금 기초 것 · 그 밖 = 저장본(848-1)."""
|
||||
if not isinstance(got, dict) or not renew.on() or dim.is_imported(sk):
|
||||
return got
|
||||
return with_upper(sk, got)
|
||||
|
||||
|
||||
def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
|
||||
"""셈에 쓸 수식 사본 — 따로 = 저장본 · 파생 = 지금 옛 칸으로 다시 지은 문서(부름은 있던 것 먼저) ·
|
||||
`OLD` 켬(옮기기 대조 · 시험) = 옛 길."""
|
||||
@@ -120,7 +150,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
|
||||
got = sk.get(KEY) if dc.has(sk) else seed(sk)
|
||||
if got is None:
|
||||
return None
|
||||
got = renew.form(sk, got) # M01 자동 따라옴(836-2)
|
||||
got = upper(sk, renew.form(sk, got)) # M01 자동 따라옴(836-2) · ① 위 층 덮음(848-1)
|
||||
if got.get("따로") or ctx is None:
|
||||
return got
|
||||
if dim.is_imported(sk): # 가져온 식 — 엑셀 단가 기준 줄에서 지음(우리 = 한 번 더 돎)
|
||||
@@ -137,7 +167,7 @@ def copy_of(sk: dict, ctx: tuple | None) -> dict | None:
|
||||
values = dc.values_of(sk[skc.KEY]) if skc.has(sk) else dc.values_of(got) # 서버가 정한 값
|
||||
values = renew.rows(values) if renew.is_sk(sk) else values # 836-2
|
||||
whole = dc.over(values)
|
||||
calls = dc.closure(whole, dc.calls(root), got.get("부름"))
|
||||
calls = dc.closure(whole, [*dc.calls(root), *dc.upper_calls(got)], got.get("부름"))
|
||||
base = str((sk.get("바탕") or {}).get("로직") or "")
|
||||
seen = dc.doc_of(whole, base) if base else None # 바탕 M01 문서 판(「M01 새 판」 표지)
|
||||
origin = {"원본": {"키": base, "판": dc.fp(seen)}} if seen else {}
|
||||
@@ -194,7 +224,9 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
|
||||
return {**out, KEY: norm(mine["사본"])}
|
||||
file = stored(out.get("키")) or {}
|
||||
have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None)
|
||||
have = renew.form(out, have) if have else have # 836-2 — 바뀐 항목 고침 지움 · 저장 때 굳음
|
||||
have = (
|
||||
upper(out, renew.form(out, have)) if have else have
|
||||
) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음
|
||||
if have and have.get("따로") and job != skc.REGEN:
|
||||
if file and old_fp(file) != old_fp(out):
|
||||
raise sd.DocError(
|
||||
@@ -216,6 +248,10 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
|
||||
first = {**(dc.values_of(out[skc.KEY]) if skc.has(out) else {}), "부름": calls}
|
||||
if job != skc.REGEN and (have or {}).get("끊음"): # 안 바뀐 항목 고침 = 그대로(836-2)
|
||||
first["끊음"] = have["끊음"]
|
||||
if (have or {}).get(
|
||||
UPPER
|
||||
): # ① = 저장본(프로젝트 층) · 밖은 `copy_of` 가 지금 기초 것으로(848-1)
|
||||
first[UPPER] = have[UPPER]
|
||||
copy = copy_of({**out, KEY: first}, box[-1] if box else None)
|
||||
if (
|
||||
copy and skc.has(out) and skc.READS.get() is None and (keys := gap.gaps(copy))
|
||||
|
||||
@@ -10,6 +10,8 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서}
|
||||
가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음
|
||||
(형제 SK 는 셈 때 읽음) · 단가갱신 = 문서 그대로 · 바탕 참조 SK = 값 사본 없음(400).
|
||||
저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`).
|
||||
위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② ·
|
||||
저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -89,6 +91,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]:
|
||||
)
|
||||
body = {
|
||||
"문서": copy["문서"],
|
||||
"위덮음": copy.get(dsk.UPPER) or {},
|
||||
"부름": copy.get("부름") or {},
|
||||
"끊음": copy.get("끊음") or {},
|
||||
"셈": got,
|
||||
@@ -152,8 +155,9 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict:
|
||||
calls = [
|
||||
*dc.calls(out["문서"]),
|
||||
*(c for d in out.get("끊음", {}).values() for c in dc.calls(d)),
|
||||
*dc.upper_calls(out), # ① 위 층 덮음 식(848-1)
|
||||
]
|
||||
try: # 기계 덮음(836-1) — 몸 검사 · 원본과 같은 칸 · 안 부르는 기계 뺌(가져온 식 = 검사만)
|
||||
try: # 기계 덮음(836-1) — 몸 검사 · 위 층과 같은 칸 · 문서 밖 기계 뺌(가져온 식 = 검사만)
|
||||
if dim.is_imported(sk):
|
||||
got = mcv.clean(out["문서"].get(mcv.COVER))
|
||||
rest = {k: v for k, v in out["문서"].items() if k != mcv.COVER}
|
||||
@@ -163,7 +167,8 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict:
|
||||
if not dim.is_imported(sk):
|
||||
out["부름"] = dc.closure(dc.over(out), calls, copy.get("부름"))
|
||||
try:
|
||||
out["문서"] = mcv.prune_doc(out["문서"], dc.ml.Links(dc.over(out), dc.docs_of(out)))
|
||||
links = dc.ml.Links(dc.over(out), dc.docs_of(out))
|
||||
out["문서"] = mcv.prune_doc(out["문서"], links, out.get(dsk.UPPER)) # ② 대 ① + 정본
|
||||
except ValueError as e:
|
||||
raise _bad(str(e)) from e
|
||||
out = gap.fill(out) # 셈이 읽은 줄 가운데 사본 없는 것 = 지금 값으로 박음(822-1)
|
||||
|
||||
@@ -86,13 +86,21 @@ def freeze(copies: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
|
||||
if got["켜쌓기율"] is not None:
|
||||
frozen["켜쌓기율"] = prices.to_json(got["켜쌓기율"])
|
||||
if isinstance(doc.get("수식"), dict): # 841-1 수식 문서(기계덮음) — 사본 셈 = M02
|
||||
frozen["수식"] = doc["수식"]
|
||||
frozen["수식"] = _upper(doc) # 848-1 ① 위덮음 = 굳힐 때 기초 것
|
||||
out[rid] = frozen
|
||||
for rid in sorted(rid for rid, doc in copies.items() if _patched(doc)):
|
||||
out[rid] = _freeze_lines(rid, copies[rid], whole, read, taken)
|
||||
return out
|
||||
|
||||
|
||||
def _upper(doc: dict) -> dict:
|
||||
"""SK `수식` — ① 위 층 덮음을 굳힐 때 기초 것으로(848-1 · 가져온 식 · 기초 문서 없음 = 저장본)."""
|
||||
from M02_MasterTemplete import M02_Doc_Import as dim
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
|
||||
return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"])
|
||||
|
||||
|
||||
def _patched(doc: Any) -> list[int]:
|
||||
"""일위대가(SC) 사본의 덮개 줄(로직 줄 + `패치` · 740-1 SK 넣기 꼴) 차례."""
|
||||
if not isinstance(doc, dict) or doc.get("종류") != refs.TITLE["precombo"]:
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -310,12 +310,13 @@ def _formula_job(out: dict, job: Any) -> dict:
|
||||
"""수식 사본(802-4a · `M02_Doc_Sk`) 할일 — 재생성 = 파생으로(부름 새로 · 고친 문서 버림) ·
|
||||
단가갱신 = 따로 문서의 값 줄도 지금 M01."""
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
|
||||
got = out.get(dc.KEY) if dc.has(out) else None
|
||||
if got is None or job not in (PRICE, REGEN):
|
||||
return out
|
||||
if job == REGEN:
|
||||
drop = ("문서", "끊음", "따로", "처음", "기계덮음")
|
||||
if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림
|
||||
drop = ("문서", "끊음", "따로", "처음", *renew.KEEP)
|
||||
got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}}
|
||||
elif got.get("따로"):
|
||||
got = dc.refresh(got)[0]
|
||||
|
||||
@@ -1,16 +1,22 @@
|
||||
"""M02 단가산출(SK) M01 자동 따라옴(PLAN 836-2 · 요구 854) — 서버 단독.
|
||||
"""M02 단가산출(SK) M01 자동 따라옴(PLAN 836-2 · 848-2 · 요구 854 · 요구서_889 3 절) — 서버 단독.
|
||||
|
||||
프로젝트 층 밖 SK(마스터 · 회사 · 개인) = 셈 · 열기 · 목록 · 일위대가 펼침이 모두
|
||||
사본 줄 = 지금 M01(+ 층 내 기계) 줄(`rows` · 지운 키 = 사본 마지막 줄) ·
|
||||
부름 문서 = 지금 M01 수식 문서(`form`)로 봄 — 묻지 않음 · [단가 갱신] · [재생성] 없음.
|
||||
파일(작업본)은 [저장] · 알림 [확인](= 저장) 때만 새 것으로 씀 — 읽기 길은 안 씀 ·
|
||||
저장 파일의 사본 = 마지막 저장 때 받은 M01(= 고침 판정의 「복사 당시 원본」).
|
||||
고침 판정 = 내용 대조(표지 아님 · 바꿨다 되돌림 = 안 고침) — 셈에 닿는 칸(`LOGIC`)만 견줌:
|
||||
끊음[키] 대 부름[키](복사 당시) · 따로 문서 대 `처음`(따로가 된 때의 문서 · 없으면 고친 것).
|
||||
M01 에서 바뀐 항목에 고침이 얹혀 있으면 그 고침을 지우고 다시 복사 + 알림 `갱신` 한 줄
|
||||
{키, 이름, 갈래, M01 [전 → 후], 내고침 [지워진 값]} · 고침 없는 항목 = 조용히 따라옴 ·
|
||||
안 바뀐 항목의 고침 = 그대로. 따로 문서를 지우면 파생(옛 칸 + 새 M01)으로 돌아감.
|
||||
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 안 건드림 · 단가기준 「엑셀」 은 엑셀 값 그대로).
|
||||
파일(작업본)은 [저장] · 알림 [확인](= 저장 · `confirm`) 때만 새 것으로 씀 — 읽기 길은 안 씀.
|
||||
판정 = 칸 단위(848-2):
|
||||
기계 고침(② `문서.기계덮음`) — 칸마다 「위 값」(① `위덮음` 그 칸 › ⓪ 기계 줄 그 칸)
|
||||
바탕 대 지금 · 위가 바뀐 칸에 ② 가 있으면 ② 지킴 + 알림(처리 「지킴」) ·
|
||||
② 없는 칸 = 조용히 따라옴(셈이 지금 줄 · 지금 ① 을 읽음) · 기계 줄 글 = 칸 아님.
|
||||
바탕 = `덮음바탕`(지킨 칸만 · 알림 [확인] 까지) › 저장 사본 기계 줄 · 저장 `위덮음` ·
|
||||
둘 다 없음(고르지 않아 사본 줄 없는 기계) = 바탕 모름 → 알림 없음 · ② 그대로
|
||||
(다음 저장 때 지금 값이 바탕).
|
||||
문서(따로 문서 · 끊음) — 계산 내용(`dc.doc_fp`)이 바뀐 것만 다시 복사 · 고쳐 둔 문서 =
|
||||
옵션 값(선택 · 입력 열쇠) · ② 다시 얹고 못 얹은 것만 알림(처리 「다시복사」 · 「지워짐」).
|
||||
알림 한 줄 `갱신` = {키, 이름, 갈래(기계 · 문서 · 부름), 처리(지킴 · 다시복사 · 지워짐),
|
||||
M01 [전 → 후 글], 내고침 [글]} + 지킴 = {문서, 열쇠, 경로, 칸, 층(기계 · 기초), 전, 후, 내값} ·
|
||||
다시복사 · 지워짐 = {다시얹음 [글]}.
|
||||
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 그대로) · 기계 고침 판정 같음(① = 저장 `위덮음`).
|
||||
프로젝트 층 · B09 사본 = 그대로(사용자가 고르는 [단가 갱신] · [재생성]).
|
||||
"""
|
||||
|
||||
@@ -28,18 +34,22 @@ from M02_MasterTemplete import M02_Sangeun_Imported as imp
|
||||
|
||||
import master_doc_cover as mcv # noqa: E402 — 기계 덮음(836-1 · scripts 길 = dc)
|
||||
|
||||
COVER = mcv.COVER # 문서 칸 기계덮음(836-1) — 따로 문서를 다시 복사할 때 `수식` 머리에 맡겨 둠
|
||||
mw, mcrew = mcv.mw, mcv.mcrew # 작업량 · 인력 잡품 목록(같은 scripts 길)
|
||||
|
||||
COVER = mcv.COVER # 문서 칸 기계덮음(② · 836-1) — 따로 문서를 다시 복사할 때 `수식` 머리에 맡겨 둠
|
||||
UPPER = getattr(mcv, "UPPER", "위덮음") # `수식` 칸 — ① 위 층 고침(848-1)
|
||||
FIRST = "처음" # `수식` 칸 — 따로가 된 때의 문서(고침 판정 원본)
|
||||
LOGIC = (
|
||||
"변수",
|
||||
"식",
|
||||
"금액",
|
||||
"끝수",
|
||||
"결과단위",
|
||||
) # 셈에 닿는 칸 — 쌓기(차림) · 이름 · 판은 안 견줌
|
||||
OPTS = (
|
||||
"맡긴값" # `수식` 칸 — 다시 복사한 따로 문서의 옵션 값 {변수 열쇠: 값}(파생 문서에 다시 얹음)
|
||||
)
|
||||
BASE = "덮음바탕" # `수식` 칸 — 지킨 ② 칸의 바탕 {열쇠: {경로: 위 값}} · 알림 [확인] 때 걷음
|
||||
KEEP = (COVER, OPTS, BASE) # 파생 저장 때 `수식` 에 이어 실을 칸(`M02_Doc_Sk.settle`)
|
||||
CONFIRM = "갱신확인" # 알림 [확인] 저장 할일
|
||||
PICK = ("선택", "입력") # 옵션 변수 갈래
|
||||
MAX_LINES = 8
|
||||
_MEMO: dict[tuple, dict] = {}
|
||||
_LIVE: list[Any] = [None]
|
||||
_NO = object() # 바탕 모름
|
||||
|
||||
|
||||
def on() -> bool:
|
||||
@@ -64,7 +74,8 @@ def _fresh(row: dict, live: Any) -> dict:
|
||||
|
||||
|
||||
def rows(copy: Any) -> Any:
|
||||
"""값 사본(`skc` 꼴) → 줄마다 지금 M01(+ 층 내 기계) · 바뀐 몫만 판 다시 · 프로젝트 층 = 그대로."""
|
||||
"""값 사본(`skc` 꼴) → 줄마다 지금 M01(+ 층 내 기계) · 바뀐 몫만 판 다시 ·
|
||||
프로젝트 층 = 그대로."""
|
||||
if not (isinstance(copy, dict) and isinstance(copy.get("로직"), list)) or not on():
|
||||
return copy
|
||||
live = skc.whole_()
|
||||
@@ -88,13 +99,6 @@ def rows(copy: Any) -> Any:
|
||||
|
||||
|
||||
# ── 수식 사본(부름 · 끊음 · 따로 문서) ──────────────────────────────────
|
||||
def _logic(doc: Any) -> str:
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
|
||||
doc = doc if isinstance(doc, dict) else {}
|
||||
return dc.fp(dsk._strip({k: doc.get(k) for k in LOGIC}))
|
||||
|
||||
|
||||
def _say(v: dict) -> str:
|
||||
link = v.get("연결") or {}
|
||||
for slot in ("값", "식", "키"):
|
||||
@@ -133,50 +137,94 @@ def diff(a: Any, b: Any) -> list[str]:
|
||||
return out[:MAX_LINES] + ([f"… {len(out) - MAX_LINES}"] if len(out) > MAX_LINES else [])
|
||||
|
||||
|
||||
def form(sk: Any, got: Any, notes: list | None = None) -> Any:
|
||||
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · M01 에서 바뀐 항목의 고침(끊음 · 따로 문서)은
|
||||
지우고 `notes` 에 한 줄 · 안 바뀐 항목 고침 · 프로젝트 층 = 그대로."""
|
||||
def _opts(doc: Any) -> dict[str, Any]:
|
||||
"""옵션 변수 {열쇠: 값}(선택 · 입력)."""
|
||||
out = {}
|
||||
for v in (doc or {}).get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") in PICK and v.get("열쇠"):
|
||||
out[str(v["열쇠"])] = link.get("값")
|
||||
return out
|
||||
|
||||
|
||||
def put_opts(doc: dict, vals: dict) -> dict:
|
||||
"""옵션 값을 얹은 새 문서(열쇠 · 갈래가 있는 변수만)."""
|
||||
if not vals:
|
||||
return doc
|
||||
doc = cp.deepcopy(doc)
|
||||
for v in doc.get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") in PICK and str(v.get("열쇠")) in vals:
|
||||
link["값"] = vals[str(v["열쇠"])]
|
||||
return doc
|
||||
|
||||
|
||||
def _replay(mine: dict, first: Any, live: Any) -> tuple[dict, list[str], list[str]]:
|
||||
"""고친 문서(`mine` · 원본 `first`)를 새 문서(`live`)에 다시 얹기 —
|
||||
(얹을 옵션 값, 다시 얹음 글, 못 얹은 고침 글). 옵션 값 = 열쇠가 새 문서에 살아 있으면 얹음."""
|
||||
was, have, now = _opts(first), _opts(mine), _opts(live)
|
||||
edits = {k: v for k, v in have.items() if k in was and mcv._canon(v) != mcv._canon(was[k])}
|
||||
put = {k: v for k, v in edits.items() if k in now}
|
||||
rest = put_opts(mine, {k: was[k] for k in edits}) # 옵션 고침 뺀 나머지 고침
|
||||
lost = diff(first, rest) if dc.doc_fp(rest) != dc.doc_fp(first) else []
|
||||
lost += [f"{k} {edits[k]}(새 문서에 없음)" for k in edits if k not in put]
|
||||
return put, [f"{k} {v}" for k, v in put.items()], lost
|
||||
|
||||
|
||||
def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any:
|
||||
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
|
||||
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
|
||||
프로젝트 층 = 그대로 · `confirm` = 알림 [확인] 저장(바탕 걷음)."""
|
||||
if not isinstance(got, dict) or not on() or not is_sk(sk):
|
||||
return got
|
||||
out = rows(got) if "로직" in got else dict(got)
|
||||
out = _covers(got, out, notes)
|
||||
out = _covers(sk, got, out, notes, confirm)
|
||||
if imp.is_imported(sk):
|
||||
return out # 가져온 식 = 값만(식 · 가져온 줄 그대로)
|
||||
live = dc.folder()
|
||||
calls = dict(out.get("부름") or {})
|
||||
changed = {k for k, d in calls.items() if k in live and dc.fp(d) != dc.fp(live[k])}
|
||||
if not changed and not out.get("따로"):
|
||||
moved = {k for k, d in calls.items() if k in live and dc.fp(d) != dc.fp(live[k])}
|
||||
if not moved and not out.get("따로"):
|
||||
return out
|
||||
for k in changed:
|
||||
for k in moved: # 글 · 덮음만 바뀜 = 조용히 따라옴(끊음 그대로)
|
||||
calls[k] = cp.deepcopy(live[k])
|
||||
redo = {k for k in moved if dc.doc_fp((got.get("부름") or {}).get(k)) != dc.doc_fp(live[k])}
|
||||
cut = dict(out.get("끊음") or {})
|
||||
for k in sorted(changed & set(cut)):
|
||||
for k in sorted(redo & set(cut)):
|
||||
mine, was = cut.pop(k), (got.get("부름") or {}).get(k)
|
||||
if _logic(mine) != _logic(was) and notes is not None:
|
||||
notes.append(_note(k, was, live[k], diff(was, mine), "부름"))
|
||||
if dc.doc_fp(mine) == dc.doc_fp(was):
|
||||
continue # 안 고친 끊음 = 조용히 따라옴
|
||||
put, again, lost = _replay(mine, was, live[k])
|
||||
if put:
|
||||
cut[k] = put_opts(cp.deepcopy(live[k]), put)
|
||||
if notes is not None:
|
||||
notes.append(_note(k, was, live[k], lost, "부름", again=again))
|
||||
out |= {"부름": calls, "끊음": cut}
|
||||
base = out.get("원본") or {}
|
||||
key = str(base.get("키") or "")
|
||||
if out.get("따로") and key in live and dc.fp(live[key]) != base.get("판"):
|
||||
if out.get("따로") and key in live and not dc.same_origin(base, live[key]):
|
||||
first = out.get(FIRST)
|
||||
mine = out.get("문서") or {}
|
||||
if first is None or _logic(mine) != _logic(first):
|
||||
mark = (
|
||||
diff(first, mine)
|
||||
if first is not None
|
||||
else ["수식 문서 고침(옛 저장본 — 원본 없음)"]
|
||||
)
|
||||
if notes is not None:
|
||||
notes.append(_note(key, first, live[key], mark, "문서", mine.get("이름")))
|
||||
keep = {COVER: mine[COVER]} if mine.get(COVER) else {} # 기계 덮음 = 다른 항목(그대로)
|
||||
out = {k: v for k, v in out.items() if k not in ("따로", "문서", FIRST, COVER)} | keep
|
||||
if changed and "문서" in out: # 새 문서가 부르는 키 = 닫힌 묶음
|
||||
put: dict = {}
|
||||
if first is None:
|
||||
again, lost = [], ["수식 문서 고침(옛 저장본 — 원본 없음)"]
|
||||
elif dc.doc_fp(mine) != dc.doc_fp(first):
|
||||
put, again, lost = _replay(mine, first, live[key])
|
||||
else:
|
||||
again, lost = [], []
|
||||
if (again or lost) and notes is not None:
|
||||
notes.append(_note(key, first, live[key], lost, "문서", mine.get("이름"), again))
|
||||
keep = {COVER: mine[COVER]} if mine.get(COVER) else {} # 기계 고침 = 다시 얹음(`carry`)
|
||||
if put := {**(out.get(OPTS) or {}), **put}:
|
||||
keep[OPTS] = put
|
||||
out = {k: v for k, v in out.items() if k not in ("따로", "문서", FIRST, COVER, OPTS)} | keep
|
||||
if moved and "문서" in out: # 새 문서가 부르는 키 = 닫힌 묶음
|
||||
keys = [*dc.calls(out["문서"]), *(c for d in cut.values() for c in dc.calls(d))]
|
||||
out["부름"] = dc.closure(dc.over(out), keys, calls)
|
||||
return out
|
||||
|
||||
|
||||
# ── 기계 덮음(836-1) — 그 기계 줄이 M01 에서 바뀌면 덮음 지움 ─────────────
|
||||
# ── 기계 고침(②) — 칸 단위 지킴 ─────────────────────────────────────────
|
||||
def _eq_rows(copy: dict) -> dict[str, dict]:
|
||||
"""사본의 기계 줄 {원문번호 · 키: 줄}."""
|
||||
out: dict[str, dict] = {}
|
||||
@@ -188,78 +236,161 @@ def _eq_rows(copy: dict) -> dict[str, dict]:
|
||||
return out
|
||||
|
||||
|
||||
def _mine(entry: dict) -> list[str]:
|
||||
vals = [f"{k} {v}" for k, v in (entry.get("값") or {}).items()]
|
||||
crew = [f"조종원 {x.get('키')} {x.get('인')}인" for x in entry.get("조종원") or []]
|
||||
misc = [
|
||||
f"잡품 {x.get('이름') or x.get('키') or x.get('줄')} {x.get('율')}%"
|
||||
for x in entry.get("잡품") or []
|
||||
]
|
||||
return [*vals, *crew, *misc] or ["덮음"]
|
||||
def _live_row(text: str) -> dict | None:
|
||||
whole = skc.whole_()
|
||||
got = (whole.numbers.get("EQ") or {}).get(text) or (whole.index.get("EQ") or {}).get(text)
|
||||
return prices.to_json(got) if got else None
|
||||
|
||||
|
||||
def _row_diff(a: dict, b: dict) -> list[str]:
|
||||
va, vb = a.get("값") or {}, b.get("값") or {}
|
||||
if not isinstance(va, dict) or not isinstance(vb, dict):
|
||||
return [f"{a.get('값')} → {b.get('값')}"]
|
||||
keys = [*va, *(k for k in vb if k not in va)]
|
||||
return [f"{k} {va.get(k, '—')} → {vb.get(k, '—')}" for k in keys if va.get(k) != vb.get(k)]
|
||||
def paths(entry: Any) -> dict[str, Any]:
|
||||
"""덮음 한 열쇠 → {칸 경로: 값}(848-1 계약 경로 · 조종원 · 잡품 = 목록 통째 한 칸)."""
|
||||
e = entry if isinstance(entry, dict) else {}
|
||||
out = {f"값.{k}": v for k, v in (e.get("값") or {}).items()}
|
||||
for part in ("조종원", "잡품"):
|
||||
if e.get(part) is not None:
|
||||
out[part] = e[part]
|
||||
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
|
||||
for k in ("방식", "식"):
|
||||
if w.get(k) not in (None, ""):
|
||||
out[f"작업량.{k}"] = w[k]
|
||||
for k, v in (w.get("변수") or {}).items():
|
||||
out[f"작업량.변수.{k}"] = v
|
||||
if w.get("기계"):
|
||||
out["작업량.기계"] = {k: w[k] for k in mw.FIXED if w.get(k)}
|
||||
return out
|
||||
|
||||
|
||||
def _same_new(a: dict, b: dict) -> bool:
|
||||
"""옛 꼴 사본 줄 대 새 꼴 M01 줄(842-3 인력 · 잡품 목록 옮김) — 새 꼴로 바꿔 같으면 안 바뀜."""
|
||||
import master_machine_crew as mcrew
|
||||
|
||||
return skc._fp(mcrew.from_old_row(a)) == skc._fp(mcrew.from_old_row(b))
|
||||
def _machine(text: str, path: str, *layers: Any) -> str:
|
||||
"""그 칸의 기계 열쇠 — 작업량 = 굳은 기계(② › ①) · 그 밖 = 덮음 열쇠."""
|
||||
if path.startswith("작업량."):
|
||||
for e in layers:
|
||||
w = (e or {}).get(mw.WORK) if isinstance(e, dict) else None
|
||||
if isinstance(w, dict) and w.get("기계"):
|
||||
return str(w["기계"])
|
||||
return text
|
||||
|
||||
|
||||
def _covers(got: dict, out: dict, notes: list | None) -> dict:
|
||||
"""문서(따로) · 맡긴 기계 덮음 가운데 그 기계 줄이 M01 에서 바뀐 것 = 지움 + 알림."""
|
||||
def _up(path: str, row: dict | None, one: Any, mine: dict) -> Any:
|
||||
"""그 칸 위 값 = ① 그 칸 › ⓪ 기계 줄 그 칸 · 기계 줄 없음 = `_NO`."""
|
||||
have = paths(one)
|
||||
if path in have:
|
||||
return have[path]
|
||||
if row is None:
|
||||
return _NO
|
||||
vals = mcrew.from_old_row(row).get("값") # 옛 꼴 사본 줄 = 새 꼴로 견줌(842-3)
|
||||
vals = vals if isinstance(vals, dict) else {}
|
||||
if path.startswith("값."):
|
||||
return vals.get(path[2:])
|
||||
if path in ("조종원", "잡품"):
|
||||
return vals.get(mcrew.CREW if path == "조종원" else mcrew.MISC)
|
||||
if path.startswith("작업량.변수."):
|
||||
want = (mine.get(mw.WORK) or {}).get("식") or ((one or {}).get(mw.WORK) or {}).get("식")
|
||||
specs = mw.specs_of(vals.get(mw.WORK))
|
||||
spec = next((s for s in specs if s["식"] == want), None) if want else None
|
||||
spec = spec or (specs[0] if specs and not want else None)
|
||||
return ((spec or {}).get("변수") or {}).get(path[len("작업량.변수.") :])
|
||||
return None # 작업량 방식 · 식 · 기계 = 기계 줄에 없음(위 층 없음 = 빈 값)
|
||||
|
||||
|
||||
def _upper_now(sk: dict, got: dict) -> dict:
|
||||
"""지금 ① — 가져온 식 = 저장본 · 그 밖 = 지금 기초(`바탕.로직`) 문서 `기계덮음` ·
|
||||
기초 문서 없음 = 저장본."""
|
||||
if imp.is_imported(sk):
|
||||
return got.get(UPPER) or {}
|
||||
key = str((sk.get("바탕") or {}).get("로직") or "")
|
||||
live = dc.folder().get(key) if key else None
|
||||
return mcv.cover_of(live) if live is not None else got.get(UPPER) or {}
|
||||
|
||||
|
||||
def _same(a: Any, b: Any) -> bool:
|
||||
return mcv._canon(a) == mcv._canon(b)
|
||||
|
||||
|
||||
def _covers(sk: dict, got: dict, out: dict, notes: list | None, confirm: bool) -> dict:
|
||||
"""② 칸마다 위 값 바탕 대 지금 — 바뀐 칸 = ② 지킴 + 알림 · 바탕(`덮음바탕`)은 지킨 칸만 남김 ·
|
||||
`confirm` = 바탕 걷음(알림 없음)."""
|
||||
doc = out.get("문서") if isinstance(out.get("문서"), dict) else None
|
||||
cover = dict(mcv.cover_of(doc) if doc is not None else out.get(COVER) or {})
|
||||
if not cover:
|
||||
return out
|
||||
was, now = _eq_rows(got), _eq_rows(out)
|
||||
for text in list(cover):
|
||||
a, b = was.get(text), now.get(text)
|
||||
if a is None or b is None or skc._fp(a) == skc._fp(b) or _same_new(a, b):
|
||||
continue
|
||||
entry = cover.pop(text)
|
||||
if notes is not None:
|
||||
name = f"{b.get('이름') or ''} {b.get('규격') or ''}".strip() or text
|
||||
notes.append(
|
||||
{
|
||||
"키": str(b.get("키")),
|
||||
"이름": name,
|
||||
"갈래": "기계",
|
||||
"M01": _row_diff(a, b) or ["바뀜"],
|
||||
"내고침": _mine(entry),
|
||||
} # fmt: skip
|
||||
cover = mcv.cover_of(doc) if doc is not None else out.get(COVER) or {}
|
||||
held: dict = {} if confirm else got.get(BASE) or {}
|
||||
keep: dict = {}
|
||||
if cover and not confirm:
|
||||
was, here = _eq_rows(got), _eq_rows(out)
|
||||
up0, up1 = got.get(UPPER) or {}, _upper_now(sk, got)
|
||||
for text, mine in cover.items():
|
||||
for path, val in paths(mine).items():
|
||||
m0 = _machine(text, path, mine, up0.get(text))
|
||||
m1 = _machine(text, path, mine, up1.get(text))
|
||||
before = (held.get(text) or {}).get(path, _NO)
|
||||
if before is _NO:
|
||||
before = _up(path, was.get(m0), up0.get(text), mine)
|
||||
now = _up(path, _live_row(m1) or here.get(m1), up1.get(text), mine)
|
||||
if before is _NO or now is _NO or _same(before, now) or _same(val, now):
|
||||
continue
|
||||
keep.setdefault(text, {})[path] = before
|
||||
if notes is not None:
|
||||
above = path in paths(up1.get(text))
|
||||
notes.append(_kept(sk, text, path, m1, before, now, val, above))
|
||||
rest = {k: v for k, v in out.items() if k != BASE}
|
||||
return rest | ({BASE: keep} if keep else {})
|
||||
|
||||
|
||||
def _txt(v: Any) -> str:
|
||||
"""칸 값 글 — 인력 · 잡품 목록 = 줄 글 · 빈 값 = —."""
|
||||
if isinstance(v, list):
|
||||
return (
|
||||
" · ".join(
|
||||
f"{x.get('키') or '직종'} {x.get('인')}인"
|
||||
if "인" in x
|
||||
else f"{x.get('이름') or x.get('키') or x.get('줄')} {x.get('율')}%"
|
||||
for x in v
|
||||
if isinstance(x, dict)
|
||||
)
|
||||
if doc is not None:
|
||||
rest = {k: v for k, v in doc.items() if k != COVER}
|
||||
return {**out, "문서": {**rest, COVER: cover} if cover else rest}
|
||||
return {k: v for k, v in out.items() if k != COVER} | ({COVER: cover} if cover else {})
|
||||
or "없음"
|
||||
)
|
||||
if isinstance(v, dict):
|
||||
return str(v.get("이름") or v.get("기계") or json.dumps(v, ensure_ascii=False))
|
||||
return "—" if v in (None, "") else str(v)
|
||||
|
||||
|
||||
def _label(path: str) -> str:
|
||||
return {"조종원": "인력", "잡품": "잡품"}.get(path) or path.removeprefix("값.").replace(
|
||||
".", " "
|
||||
)
|
||||
|
||||
|
||||
def _kept(sk, text, path, machine, before, now, mine, upper) -> dict:
|
||||
row = _live_row(machine) or {}
|
||||
name = f"{row.get('이름') or ''} {row.get('규격') or ''}".strip() or text
|
||||
label = _label(path)
|
||||
return {
|
||||
"키": str(row.get("키") or text), "이름": name, "갈래": "기계", "처리": "지킴",
|
||||
"문서": str(sk.get("키") or ""), "열쇠": text, "경로": path, "칸": label,
|
||||
"층": "기초" if upper else "기계", "전": before, "후": now, "내값": mine,
|
||||
"M01": [f"{label} {_txt(before)} → {_txt(now)}"], "내고침": [f"{label} {_txt(mine)}"],
|
||||
} # fmt: skip
|
||||
|
||||
|
||||
def carry(got: dict, root: dict) -> dict:
|
||||
"""파생 문서에 맡긴 기계 덮음을 다시 얹음(따로 문서를 다시 복사한 뒤)."""
|
||||
"""파생 문서에 맡긴 기계 고침 · 옵션 값을 다시 얹음(따로 문서를 다시 복사한 뒤)."""
|
||||
root = put_opts(root, got.get(OPTS) or {}) if isinstance(got.get(OPTS), dict) else root
|
||||
return {**root, COVER: got[COVER]} if isinstance(got.get(COVER), dict) and got[COVER] else root
|
||||
|
||||
|
||||
def _note(key: str, was: Any, now: dict, mine: list[str], kind: str, name: Any = None) -> dict:
|
||||
def _note(key, was, now, lost, kind, name=None, again=()) -> dict:
|
||||
return {
|
||||
"키": key,
|
||||
"이름": str(name or now.get("이름") or key),
|
||||
"갈래": kind,
|
||||
"처리": "지워짐" if lost else "다시복사",
|
||||
"M01": diff(was, now) or ["바뀜"],
|
||||
"내고침": mine,
|
||||
"내고침": list(lost),
|
||||
"다시얹음": list(again),
|
||||
}
|
||||
|
||||
|
||||
def notes(sk: Any) -> list[dict]:
|
||||
"""열 때 알림 — 이 SK 저장본에서 지울 고침(없으면 []) · 가져온 식 · 프로젝트 층 = []."""
|
||||
if not is_sk(sk) or not dc.has(sk) or imp.is_imported(sk):
|
||||
"""열 때 알림 — 이 SK 저장본의 지킨 칸 · 다시 복사 · 지울 고침(없으면 []) · 프로젝트 층 = []."""
|
||||
if not is_sk(sk) or not dc.has(sk):
|
||||
return []
|
||||
out: list[dict] = []
|
||||
form(sk, sk[dc.KEY], out)
|
||||
|
||||
@@ -8,8 +8,12 @@
|
||||
* 셈 규칙(`coverDoc`) = 계산기가 기계 식을 부를 때 그 기계 덮음을 얹은 문서로 셈 — 덮음 없음 = 문서 그대로(금액 전후 같음)
|
||||
* 기계 줄 목록(842-3 · `common_util_machine_crew`) = 바탕 덮음(`rowEntry` — 식 한 줄로 안 풀리는 부분만) ·
|
||||
* 단가산출 덮음이 그 위에 부분별로 덮음(`mergeCover` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째)
|
||||
* 겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
|
||||
* ② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`mergeCover` · `mergeLayers` · `layeredCover` — 작업량 = 방식 ·
|
||||
* 식 · 변수 열쇠 · 기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `putCover` 의 `upper`) · 위 층 값(`upperOf`) ·
|
||||
* 출처(`sourcesOf`)
|
||||
* 파이썬 · TS 짝 — 짝 = resources/master_data/scripts/master_doc_cover.py · 거울 시험 test_836_1_machine_cover.py ·
|
||||
* test_842_3_machine_crew.py
|
||||
* test_842_3_machine_crew.py · test_848_1_cover_layers.py
|
||||
* · 화면 · DOM · fetch 없음
|
||||
* ========================================================================== */
|
||||
|
||||
@@ -22,10 +26,18 @@ import {
|
||||
type FormulaDoc,
|
||||
type MoneyLine,
|
||||
} from "./common_util_formula_doc";
|
||||
import { WORK, pruneWork, type WorkCover } from "./common_util_formula_doc_work";
|
||||
import { DAILY, HOURLY, WORK, type WorkCover } from "./common_util_formula_doc_work";
|
||||
import { CREW, MISC, code as jobOf } from "./common_util_machine_crew";
|
||||
|
||||
export const COVER = "기계덮음";
|
||||
/** SK `수식` 칸 — ① 위 층 고침(848-1 · 꼴 = `기계덮음`) */
|
||||
export const UPPER = "위덮음";
|
||||
/** M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1) */
|
||||
export const HAND = "손고침";
|
||||
/** 출처(`sourcesOf`) — 없는 칸 = 정본 */
|
||||
export const MINE = "나";
|
||||
export const ABOVE = "위";
|
||||
export type Source = typeof MINE | typeof ABOVE;
|
||||
/** 값 칸에서 빼는 기계 칸 — 줄(조종원 · 잡품)로 다룸 */
|
||||
export const NOT_VALUE = ["조종원", "조종원직종", "잡재료율"];
|
||||
const HOUR = "Q_시간환산";
|
||||
@@ -224,36 +236,174 @@ const sameVal = (a: unknown, b: unknown): boolean =>
|
||||
? Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b))
|
||||
: String(a) === String(b);
|
||||
|
||||
/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) */
|
||||
/** 기계 덮음 + 시간당 작업량(846-1 · `common_util_formula_doc_work`) — `MachineCover` 는 그대로(Required 꼴 지킴) ·
|
||||
* 848-1 한 층의 작업량은 바꾼 칸만 담을 수 있음(`방식` 없음 = 위 층 방식) — 읽을 때는 `mergeLayers` 답을 봄 */
|
||||
export type CoverEntry = MachineCover & { [WORK]?: WorkCover };
|
||||
/** 원본 기본값 + 작업량 기본 변수(`workDefaults` · 없으면 변수 그대로) */
|
||||
export type CoverBase = Required<MachineCover> & { [WORK]?: Record<string, unknown> };
|
||||
/** 위 층 값(`upperOf`) — 정본 기본 위에 ① · 작업량 = ① 층 그대로 */
|
||||
export type UpperValue = Required<MachineCover> & { [WORK]?: WorkCover };
|
||||
/** 작업량 한 층(848-1) — 바꾼 칸만(방식 없음 = 위 층 방식) */
|
||||
export type WorkLayer = Partial<WorkCover>;
|
||||
|
||||
/** 원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null */
|
||||
export function prune(entry: CoverEntry, base: CoverBase): CoverEntry | null {
|
||||
/** 위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 null —
|
||||
* `base` = 정본 기본(`defaultsOf` · 작업량 = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위) */
|
||||
export function prune(
|
||||
entry: CoverEntry,
|
||||
base: CoverBase,
|
||||
upper?: CoverEntry | null,
|
||||
): CoverEntry | null {
|
||||
const up = upperOf(base, upper);
|
||||
const out: CoverEntry = {};
|
||||
const vals = Object.entries(entry.값 ?? {}).filter(
|
||||
([k, v]) =>
|
||||
v !== null && v !== undefined && v !== "" && !(k in base.값 && sameVal(v, base.값[k])),
|
||||
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in up.값 && sameVal(v, up.값[k])),
|
||||
);
|
||||
if (vals.length) out.값 = Object.fromEntries(vals);
|
||||
if (entry.조종원 && canon(entry.조종원) !== canon(base.조종원)) out.조종원 = entry.조종원;
|
||||
if (entry.잡품 && canon(entry.잡품) !== canon(base.잡품)) out.잡품 = entry.잡품;
|
||||
const work = pruneWork(entry[WORK], base[WORK] ?? null);
|
||||
if (work) out[WORK] = work;
|
||||
if (entry.조종원 && canon(entry.조종원) !== canon(up.조종원)) out.조종원 = entry.조종원;
|
||||
if (entry.잡품 && canon(entry.잡품) !== canon(up.잡품)) out.잡품 = entry.잡품;
|
||||
const work = pruneWorkLayer(entry[WORK], base[WORK] ?? null, upper?.[WORK] ?? null);
|
||||
if (work) out[WORK] = work as WorkCover;
|
||||
return Object.keys(out).length ? out : null;
|
||||
}
|
||||
|
||||
/** 덮음 한 기계 고침 → 문서 칸(원본 대조로 정리 · 비면 칸 지움) */
|
||||
// ── 층(848-1) ─────────────────────────────────────────────────────────
|
||||
const FIXED = ["기계", "키", "이름"] as const;
|
||||
const fixedOf = (w: WorkLayer): WorkLayer => {
|
||||
const out: WorkLayer = {};
|
||||
for (const k of FIXED) if (w[k]) out[k] = String(w[k]);
|
||||
return out;
|
||||
};
|
||||
const sameNum = (a: unknown, b: unknown): boolean => {
|
||||
const x = Number(a);
|
||||
const y = Number(b);
|
||||
return a !== "" && b !== "" && Number.isFinite(x) && Number.isFinite(y)
|
||||
? Math.abs(x - y) <= 1e-9 * Math.max(1, Math.abs(x))
|
||||
: String(a) === String(b);
|
||||
};
|
||||
|
||||
/** 작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 · `base` = 그 식 기본 변수
|
||||
* (`workDefaults`) · 일당 = 방식만 · 남는 것 없음 = null(위 층 없음 = `pruneWork` 와 같음) */
|
||||
export function pruneWorkLayer(
|
||||
want: WorkLayer | null | undefined,
|
||||
base: Record<string, unknown> | null = null,
|
||||
upper: WorkLayer | null = null,
|
||||
): WorkLayer | null {
|
||||
if (!want || typeof want !== "object") return null;
|
||||
const up = upper ?? {};
|
||||
const upWay = up.방식 || DAILY;
|
||||
const way = want.방식 || upWay;
|
||||
const out: WorkLayer = way !== upWay ? { 방식: way } : {};
|
||||
if (way !== HOURLY) return Object.keys(out).length ? out : null;
|
||||
const upForm = upWay === HOURLY ? String(up.식 ?? "") : "";
|
||||
const form = String(want.식 ?? "") || upForm;
|
||||
if (form !== upForm) out.식 = form;
|
||||
const held = { ...(base ?? {}), ...(form === upForm ? (up.변수 ?? {}) : {}) };
|
||||
const got = Object.entries(want.변수 ?? {}).filter(
|
||||
([k, v]) => v !== null && v !== undefined && v !== "" && !(k in held && sameNum(v, held[k])),
|
||||
);
|
||||
if (got.length) out.변수 = Object.fromEntries(got);
|
||||
const fix = fixedOf(want);
|
||||
const upFix = upWay === HOURLY ? fixedOf(up) : {};
|
||||
if (
|
||||
Object.keys(fix).length &&
|
||||
(!Object.keys(upFix).length || fix.기계 !== upFix.기계 || fix.키 !== upFix.키)
|
||||
)
|
||||
Object.assign(out, fix);
|
||||
return Object.keys(out).length ? out : null;
|
||||
}
|
||||
|
||||
/** 작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
|
||||
* 식을 바꾼 아래 층 = 위 층 변수 안 물려받음 */
|
||||
export function mergeWork(
|
||||
top: WorkLayer | null | undefined,
|
||||
low: WorkLayer | null | undefined,
|
||||
): WorkLayer | null {
|
||||
if (!top || !Object.keys(top).length) return low && Object.keys(low).length ? low : null;
|
||||
if (!low || !Object.keys(low).length) return top;
|
||||
let out: WorkLayer = { ...top };
|
||||
if (low.방식) out.방식 = low.방식;
|
||||
if (low.식 && String(low.식) !== String(top.식 ?? "")) {
|
||||
out.식 = low.식;
|
||||
delete out.변수;
|
||||
}
|
||||
const vals = { ...(out.변수 ?? {}), ...(low.변수 ?? {}) };
|
||||
if (Object.keys(vals).length) out.변수 = vals;
|
||||
if (low.기계) {
|
||||
out = Object.fromEntries(
|
||||
Object.entries(out).filter(([k]) => !(FIXED as readonly string[]).includes(k)),
|
||||
) as WorkLayer;
|
||||
Object.assign(out, fixedOf(low));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** ① 위 층 고침 위에 ② 내 고침(열쇠마다 `mergeCover`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로 */
|
||||
export function mergeLayers(
|
||||
upper: Cover | null | undefined,
|
||||
mine: Cover | null | undefined,
|
||||
): Cover {
|
||||
if (!upper || !Object.keys(upper).length) return mine ?? {};
|
||||
if (!mine || !Object.keys(mine).length) return upper;
|
||||
const out: Cover = {};
|
||||
for (const k of [...Object.keys(upper), ...Object.keys(mine).filter((k) => !(k in upper))]) {
|
||||
const got = mergeCover(upper[k], mine[k]);
|
||||
if (got) out[k] = got;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** 화면 셈 cover — 문서 칸 `기계덮음`(②) 을 ① 위에 얹음(SK = 읽기 답 `위덮음` · M01 = 없음) */
|
||||
export const layeredCover = (doc: FormulaDoc, upper?: Cover | null): Cover =>
|
||||
mergeLayers(upper, coverOf(doc));
|
||||
|
||||
/** 위 층 값 — 정본 기본(`defaultsOf`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `workDefaults`) */
|
||||
export function upperOf(base: CoverBase, upper?: CoverEntry | null): UpperValue {
|
||||
const { [WORK]: _, ...rest } = base;
|
||||
const out: UpperValue = { ...rest };
|
||||
if (!upper) return out;
|
||||
out.값 = { ...base.값, ...(upper.값 ?? {}) };
|
||||
if (upper.조종원) out.조종원 = upper.조종원;
|
||||
if (upper.잡품) out.잡품 = upper.잡품;
|
||||
if (upper[WORK]) out[WORK] = upper[WORK];
|
||||
return out;
|
||||
}
|
||||
|
||||
/** 칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 · `작업량.방식` ·
|
||||
* `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계` */
|
||||
export function sourcesOf(
|
||||
upper: CoverEntry | null | undefined,
|
||||
mine: CoverEntry | null | undefined,
|
||||
): Record<string, Source> {
|
||||
let out: Record<string, Source> = {};
|
||||
const upForm = String((upper?.[WORK] as WorkLayer | undefined)?.식 ?? "");
|
||||
for (const [layer, tag] of [
|
||||
[upper, ABOVE],
|
||||
[mine, MINE],
|
||||
] as const) {
|
||||
const e = layer ?? {};
|
||||
for (const k of Object.keys(e.값 ?? {})) out[`값.${k}`] = tag;
|
||||
if (e.조종원) out.조종원 = tag;
|
||||
if (e.잡품) out.잡품 = tag;
|
||||
const w = (e[WORK] ?? {}) as WorkLayer;
|
||||
if (tag === MINE && w.식 && String(w.식) !== upForm)
|
||||
out = Object.fromEntries(Object.entries(out).filter(([k]) => !k.startsWith("작업량.변수.")));
|
||||
for (const k of ["방식", "식", "기계"] as const) if (w[k]) out[`작업량.${k}`] = tag;
|
||||
for (const k of Object.keys(w.변수 ?? {})) out[`작업량.변수.${k}`] = tag;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** 덮음 한 기계 고침 → 문서 칸(위 층 대조로 정리 · 비면 칸 지움) — `upper` = ① 그 열쇠 칸(848-1 · SK) */
|
||||
export function putCover(
|
||||
doc: FormulaDoc,
|
||||
machine: string,
|
||||
entry: CoverEntry,
|
||||
base: CoverBase,
|
||||
upper?: CoverEntry | null,
|
||||
): void {
|
||||
const box = doc as Holder;
|
||||
const all = { ...coverOf(doc) };
|
||||
const kept = prune(entry, base);
|
||||
const kept = prune(entry, base, upper);
|
||||
if (kept) all[machine] = kept;
|
||||
else delete all[machine];
|
||||
if (Object.keys(all).length) box[COVER] = all;
|
||||
@@ -388,17 +538,21 @@ export function rowEntry(doc: FormulaDoc, vals: Vals | null | undefined): Machin
|
||||
return Object.keys(out).length ? out : null;
|
||||
}
|
||||
|
||||
/** 바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) */
|
||||
/** 바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
|
||||
* 작업량 = `mergeWork`(848-1) */
|
||||
export function mergeCover(
|
||||
base: MachineCover | null | undefined,
|
||||
top: MachineCover | null | undefined,
|
||||
): MachineCover | null {
|
||||
base: CoverEntry | null | undefined,
|
||||
top: CoverEntry | null | undefined,
|
||||
): CoverEntry | null {
|
||||
if (!base || !Object.keys(base).length) return top && Object.keys(top).length ? top : null;
|
||||
if (!top || !Object.keys(top).length) return base;
|
||||
const out: MachineCover = { ...base, ...top };
|
||||
const out: CoverEntry = { ...base, ...top };
|
||||
const 값 = { ...(base.값 ?? {}), ...(top.값 ?? {}) };
|
||||
if (Object.keys(값).length) out.값 = 값;
|
||||
else delete out.값;
|
||||
const work = mergeWork(base[WORK], top[WORK]);
|
||||
if (work) out[WORK] = work as WorkCover;
|
||||
else delete out[WORK];
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
@@ -19,6 +19,8 @@
|
||||
· 옛 로직 JSON 은 안 씀).
|
||||
- 목록 = `docs/raw/요구_1104/_목록_802-2_변환대조.xlsx`(로직 · 옵션 · 옛 · 새 · 차이 · 까닭 + 요약).
|
||||
- 이미 저장된 문서가 이번에 저장 밖(다름 · 부르는 문서 빠짐)이면 멈춤 — 안 씀 · 그 문서와 까닭을 알림(`lost`).
|
||||
- 화면 고침 이어받기(848-1) — 저장본 `기계덮음`(그 기초의 ① 위 층 고침) = 키별로 새 문서에 얹음 ·
|
||||
`손고침` 문서(M01 화면이 셈 칸을 고쳐 저장) = 저장본 그대로 · 실행 · `--check` 때 목록으로 알림.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -36,6 +38,7 @@ import master_cut as mcut # noqa: E402 — 옛 엔진(대조 쪽만)
|
||||
import master_doc as md # noqa: E402
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_convert as cv # noqa: E402
|
||||
import master_doc_cover as mcv # noqa: E402
|
||||
import master_doc_link as ml # noqa: E402
|
||||
import master_equation as meq # noqa: E402
|
||||
import master_formula as mf # noqa: E402
|
||||
@@ -184,9 +187,33 @@ def build(log=print) -> dict:
|
||||
"대조": runs,
|
||||
"저장": keep,
|
||||
"요약": summary,
|
||||
"저장본": carried(),
|
||||
}
|
||||
|
||||
|
||||
def carried() -> dict[str, dict]:
|
||||
"""이어받을 저장본 문서(848-1) — `기계덮음` 또는 `손고침` 이 있는 것 {키: 문서}."""
|
||||
if not ml.FOLDER.exists():
|
||||
return {}
|
||||
return {k: d for k, d in ml.load_all().items() if d.get(mcv.COVER) or d.get(mcv.HAND)}
|
||||
|
||||
|
||||
def hand_kept(result: dict) -> list[str]:
|
||||
"""저장본 그대로 둔 `손고침` 문서 키(저장되는 것만)."""
|
||||
have = result.get("저장본") or {}
|
||||
return sorted(k for k, d in have.items() if d.get(mcv.HAND) and k in result["저장"])
|
||||
|
||||
|
||||
def _out_doc(result: dict, key: str) -> dict:
|
||||
"""쓸 문서 — `손고침` = 저장본 · 저장본 `기계덮음` = 새 문서에 얹음 · 그 밖 = 새 문서."""
|
||||
have = (result.get("저장본") or {}).get(key)
|
||||
if have and have.get(mcv.HAND):
|
||||
return have
|
||||
if have and have.get(mcv.COVER):
|
||||
return {**result["문서"][key], mcv.COVER: have[mcv.COVER]}
|
||||
return result["문서"][key]
|
||||
|
||||
|
||||
def _calls(doc: dict) -> set[str]:
|
||||
out = set()
|
||||
for v in doc.get("변수") or []:
|
||||
@@ -229,7 +256,7 @@ def files_of(result: dict) -> dict[str, str]:
|
||||
"""저장 파일 이름 → 글."""
|
||||
out = {}
|
||||
for name, keys in result["파일"].items():
|
||||
kept = [result["문서"][k] for k in keys if k in result["저장"]]
|
||||
kept = [_out_doc(result, k) for k in keys if k in result["저장"]]
|
||||
body = {"그룹": "수식문서", "로직파일": name, "줄": kept}
|
||||
out[ml.file_of(name)] = ml.dump(body)
|
||||
return out
|
||||
@@ -323,6 +350,8 @@ def main() -> int:
|
||||
parser.add_argument("--check", action="store_true", help="저장본 · 목록과 같은지만")
|
||||
args = parser.parse_args()
|
||||
result = build()
|
||||
if hand := hand_kept(result):
|
||||
print(f"손고침 {len(hand)} 장 — 저장본 그대로(빌더 안 덮음): {' · '.join(hand)}")
|
||||
if args.check:
|
||||
bad = check(result)
|
||||
for line in bad:
|
||||
|
||||
@@ -7,8 +7,11 @@
|
||||
덮음 없음 = 문서 그대로(금액 전후 같음).
|
||||
기계 줄 목록(842-3 · `master_machine_crew`) = 바탕 덮음(`row_entry` — 식 한 줄로 안 풀리는 부분만) ·
|
||||
단가산출 덮음이 그 위에 부분별로 덮음(`merge` — 값 = 칸별 · 조종원 · 잡품 = 목록 통째).
|
||||
겹쳐 덮는 층(848-1 · 틀 문서 10 절) = ⓪ 정본(기계 줄) → ① 위 층(M01 기초 `기계덮음` · SK `수식.위덮음`) →
|
||||
② 내 고침(SK `수식.문서.기계덮음`) · 칸 단위 합침(`merge` · `merge_layers` — 작업량 = 방식 · 식 · 변수 열쇠 ·
|
||||
기계 고정) · 층마다 위 층과 같은 칸 지움(`prune` · `prune_doc` 의 `upper`) · 위 층 값(`upper_of`) · 출처(`sources`).
|
||||
파이썬 · TS 짝 — 짝 = `common_util/common_util_formula_doc_cover.ts` · 거울 시험
|
||||
`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py`.
|
||||
`resources/tester/test_836_1_machine_cover.py` · `test_842_3_machine_crew.py` · `test_848_1_cover_layers.py`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -23,6 +26,9 @@ import master_doc_work as mw
|
||||
import master_machine_crew as mcrew
|
||||
|
||||
COVER = "기계덮음"
|
||||
UPPER = "위덮음" # SK `수식` 칸 — ① 위 층 고침(848-1)
|
||||
HAND = "손고침" # M01 문서 칸 — 빌더 결과와 셈 칸이 다른 문서(빌더가 안 덮음 · 848-1)
|
||||
MINE, ABOVE = "나", "위" # 출처(`sources`) — 없는 칸 = 정본
|
||||
NOT_VALUE = (
|
||||
"조종원",
|
||||
"조종원직종",
|
||||
@@ -192,24 +198,136 @@ def _same(a, b) -> bool:
|
||||
return str(a) == str(b)
|
||||
|
||||
|
||||
def prune(entry: dict, base: dict) -> dict | None:
|
||||
"""원본과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None."""
|
||||
def prune(entry: dict, base: dict, upper: dict | None = None) -> dict | None:
|
||||
"""위 층과 같은 칸 · 줄을 뺀 덮음(바꿨다 되돌림 = 안 고침) · 다 빠지면 None —
|
||||
`base` = 정본 기본(`defaults_of` · `작업량` = 그 식 기본 변수) · `upper` = ① 그 열쇠 칸(848-1 · 없음 = 정본 위)."""
|
||||
up = upper_of(base, upper)
|
||||
out: dict = {}
|
||||
vals = {
|
||||
k: v
|
||||
for k, v in (entry.get("값") or {}).items()
|
||||
if v not in (None, "") and not (k in base["값"] and _same(v, base["값"][k]))
|
||||
if v not in (None, "") and not (k in up["값"] and _same(v, up["값"][k]))
|
||||
}
|
||||
if vals:
|
||||
out["값"] = vals
|
||||
for part in ("조종원", "잡품"):
|
||||
if entry.get(part) is not None and _canon(entry[part]) != _canon(base[part]):
|
||||
if entry.get(part) is not None and _canon(entry[part]) != _canon(up[part]):
|
||||
out[part] = entry[part]
|
||||
if work := mw.prune_work(entry.get(mw.WORK), base.get(mw.WORK)): # 846-1 시간당 작업량
|
||||
work = prune_work_layer(entry.get(mw.WORK), base.get(mw.WORK), (upper or {}).get(mw.WORK))
|
||||
if work: # 846-1 시간당 작업량
|
||||
out[mw.WORK] = work
|
||||
return out or None
|
||||
|
||||
|
||||
# ── 층(848-1) ─────────────────────────────────────────────────────────
|
||||
def _fixed(w: dict) -> dict:
|
||||
return {k: str(w[k]) for k in mw.FIXED if w.get(k)}
|
||||
|
||||
|
||||
def prune_work_layer(want, base: dict | None = None, upper: dict | None = None) -> dict | None:
|
||||
"""작업량 한 층 정리 — 위 층(`upper` = ① 작업량 칸 · 없음 = 정본 일당)과 같은 칸 뺌 ·
|
||||
`base` = 그 식 기본 변수(`mw.defaults`) · 일당 = 방식만 · 남는 것 없음 = None(위 층 없음 = `mw.prune_work` 와 같음)."""
|
||||
if not isinstance(want, dict):
|
||||
return None
|
||||
up = upper if isinstance(upper, dict) else {}
|
||||
up_way = up.get("방식") or mw.DAILY
|
||||
way = want.get("방식") or up_way
|
||||
out: dict = {"방식": way} if way != up_way else {}
|
||||
if way != mw.HOURLY:
|
||||
return out or None
|
||||
up_form = str(up.get("식") or "") if up_way == mw.HOURLY else ""
|
||||
form = str(want.get("식") or "") or up_form
|
||||
if form != up_form:
|
||||
out["식"] = form
|
||||
held = {**(base or {}), **((up.get("변수") or {}) if form == up_form else {})}
|
||||
got = {
|
||||
k: v
|
||||
for k, v in (want.get("변수") or {}).items()
|
||||
if v not in (None, "") and not (k in held and mw._same(v, held[k]))
|
||||
}
|
||||
if got:
|
||||
out["변수"] = got
|
||||
fix, up_fix = _fixed(want), (_fixed(up) if up_way == mw.HOURLY else {})
|
||||
if fix and (
|
||||
not up_fix
|
||||
or [fix.get(k) for k in ("기계", "키")] != [up_fix.get(k) for k in ("기계", "키")]
|
||||
):
|
||||
out |= fix
|
||||
return out or None
|
||||
|
||||
|
||||
def merge_work(top: dict | None, low: dict | None) -> dict | None:
|
||||
"""작업량 층 합침 — 아래 층(`low`)이 칸마다 이김(방식 · 식 · 변수 열쇠 · 기계 고정 한 덩이) ·
|
||||
식을 바꾼 아래 층 = 위 층 변수 안 물려받음."""
|
||||
if not isinstance(top, dict) or not top:
|
||||
return low if isinstance(low, dict) and low else None
|
||||
if not isinstance(low, dict) or not low:
|
||||
return top
|
||||
out = dict(top)
|
||||
if low.get("방식"):
|
||||
out["방식"] = low["방식"]
|
||||
if low.get("식") and str(low["식"]) != str(top.get("식") or ""):
|
||||
out["식"] = low["식"]
|
||||
out.pop("변수", None)
|
||||
if vals := {**(out.get("변수") or {}), **(low.get("변수") or {})}:
|
||||
out["변수"] = vals
|
||||
if low.get("기계"):
|
||||
out = {k: v for k, v in out.items() if k not in mw.FIXED} | _fixed(low)
|
||||
return out
|
||||
|
||||
|
||||
def merge_layers(upper: dict | None, mine: dict | None) -> dict:
|
||||
"""① 위 층 고침 위에 ② 내 고침(열쇠마다 `merge`) — 계산기 `cover` 인자 · 위 층 없음 = ② 그대로."""
|
||||
if not isinstance(upper, dict) or not upper:
|
||||
return mine if isinstance(mine, dict) else {}
|
||||
if not isinstance(mine, dict) or not mine:
|
||||
return upper
|
||||
out = {}
|
||||
for k in [*upper, *(k for k in mine if k not in upper)]:
|
||||
if got := merge(upper.get(k), mine.get(k)):
|
||||
out[k] = got
|
||||
return out
|
||||
|
||||
|
||||
def upper_of(base: dict, upper: dict | None) -> dict:
|
||||
"""위 층 값 — 정본 기본(`defaults_of`) 위에 ① 그 열쇠 칸 · 작업량 = ① 층 그대로(기본 변수는 `mw.defaults`)."""
|
||||
out = {k: v for k, v in base.items() if k != mw.WORK}
|
||||
if not upper:
|
||||
return out
|
||||
out["값"] = {**(base.get("값") or {}), **(upper.get("값") or {})}
|
||||
for part in ("조종원", "잡품"):
|
||||
if upper.get(part) is not None:
|
||||
out[part] = upper[part]
|
||||
if upper.get(mw.WORK):
|
||||
out[mw.WORK] = upper[mw.WORK]
|
||||
return out
|
||||
|
||||
|
||||
def sources(upper: dict | None, mine: dict | None) -> dict[str, str]:
|
||||
"""칸 경로 → 출처(「위」 = ① · 「나」 = ②) · 없는 경로 = 정본 — `값.<칸>` · 조종원 · 잡품 ·
|
||||
`작업량.방식` · `작업량.식` · `작업량.변수.<열쇠>` · `작업량.기계`."""
|
||||
out: dict[str, str] = {}
|
||||
up_form = str(((upper or {}).get(mw.WORK) or {}).get("식") or "")
|
||||
for layer, tag in ((upper, ABOVE), (mine, MINE)):
|
||||
e = layer if isinstance(layer, dict) else {}
|
||||
for k in e.get("값") or {}:
|
||||
out[f"값.{k}"] = tag
|
||||
for part in ("조종원", "잡품"):
|
||||
if e.get(part) is not None:
|
||||
out[part] = tag
|
||||
w = e.get(mw.WORK) if isinstance(e.get(mw.WORK), dict) else {}
|
||||
if (
|
||||
tag == MINE and w.get("식") and str(w["식"]) != up_form
|
||||
): # 식을 바꿈 = 위 층 변수 안 물려받음
|
||||
out = {k: v for k, v in out.items() if not k.startswith("작업량.변수.")}
|
||||
for k in ("방식", "식", "기계"):
|
||||
if w.get(k):
|
||||
out[f"작업량.{k}"] = tag
|
||||
for k in w.get("변수") or {}:
|
||||
out[f"작업량.변수.{k}"] = tag
|
||||
return out
|
||||
|
||||
|
||||
# ── 셈 규칙 ───────────────────────────────────────────────────────────
|
||||
def _add_var(doc: dict, sign: str, low: str, name: str, key: str) -> str:
|
||||
have = {md.var_id(v) for v in doc.get("변수") or []} | {
|
||||
@@ -354,14 +472,17 @@ def row_entry(doc: dict, vals) -> dict | None:
|
||||
|
||||
|
||||
def merge(base: dict | None, top: dict | None) -> dict | None:
|
||||
"""바탕 덮음 위에 단가산출 덮음 — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만)."""
|
||||
"""바탕 덮음(위 층) 위에 단가산출 덮음(아래 층) — 값 = 칸별 · 조종원 · 잡품 = 목록 통째(있는 부분만) ·
|
||||
작업량 = `merge_work`(848-1)."""
|
||||
if not base:
|
||||
return top or None
|
||||
if not top:
|
||||
return base
|
||||
out = {**base, **{k: v for k, v in top.items() if k != "값"}}
|
||||
out = {**base, **{k: v for k, v in top.items() if k not in ("값", mw.WORK)}}
|
||||
vals = {**(base.get("값") or {}), **(top.get("값") or {})}
|
||||
return {**out, "값": vals} if vals else out
|
||||
out = {**out, "값": vals} if vals else out
|
||||
work = merge_work(base.get(mw.WORK), top.get(mw.WORK))
|
||||
return {**out, mw.WORK: work} if work else out
|
||||
|
||||
|
||||
def lists_of(links, given) -> dict:
|
||||
@@ -425,32 +546,66 @@ def clean(raw) -> dict:
|
||||
if part == "잡품" and not (r.get("줄") or r.get("키")):
|
||||
raise ValueError(f"{COVER} 「{key}」 잡품 줄 — 재료(키) 또는 줄 필요")
|
||||
one[part] = rows
|
||||
if entry.get(mw.WORK) is not None:
|
||||
one[mw.WORK] = mw.clean_work(entry[mw.WORK], f"{COVER} 「{key}」")
|
||||
w = entry.get(mw.WORK)
|
||||
if isinstance(w, dict) and not w.get("방식"): # 848-1 바꾼 칸만 담은 층(방식 = 위 층)
|
||||
got = mw.clean_work({**w, "방식": mw.DAILY}, f"{COVER} 「{key}」")
|
||||
got.pop("방식")
|
||||
if got:
|
||||
one[mw.WORK] = got
|
||||
elif w is not None:
|
||||
one[mw.WORK] = mw.clean_work(w, f"{COVER} 「{key}」")
|
||||
if one:
|
||||
out[str(key)] = one
|
||||
return out
|
||||
|
||||
|
||||
def prune_doc(doc: dict, links) -> dict:
|
||||
"""서버 정리 — 덮음을 검사하고 원본과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로).
|
||||
원본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답)."""
|
||||
def _quoted(text) -> set[str]:
|
||||
return set(re.findall(r"'([^']*)'", str(text or "")))
|
||||
|
||||
|
||||
def listed(doc: dict) -> set[str]:
|
||||
"""문서 안 덮음 열쇠 후보(848-1) — 선택 목록 · 입력 값 · 따옴표 글(식 · 부름 입력 · 금액) · 변수 기호."""
|
||||
out: set[str] = set()
|
||||
for v in doc.get("변수") or []:
|
||||
out.add(md.var_id(v))
|
||||
link = v.get("연결") or {}
|
||||
out |= {str(x) for x in link.get("목록") or []}
|
||||
if isinstance(link.get("값"), str):
|
||||
out.add(link["값"])
|
||||
for x in (link.get("입력") or {}).values():
|
||||
out |= _quoted(x)
|
||||
for x in doc.get("식") or []:
|
||||
out |= _quoted(x.get("식"))
|
||||
for x in doc.get("금액") or []:
|
||||
out |= _quoted(x.get("수량")) | _quoted(x.get("단가"))
|
||||
return out
|
||||
|
||||
|
||||
def prune_doc(doc: dict, links, upper: dict | None = None) -> dict:
|
||||
"""서버 정리 — 덮음을 검사하고 위 층과 같은 칸 · 줄 · 기계를 뺀 문서(새 문서 · 덮음 없음 = 그대로).
|
||||
정본 = 덮음 뺀 문서 셈의 부름 메모(그 기계 식 · 입력 · 원본 답 · 작업량 · 굳은 기계는 얹고 셈) ·
|
||||
`upper` = ① 위 층 고침(SK `수식.위덮음` · 848-1) · 이번 셈이 안 부른 열쇠 = 문서 안에 들면(`listed`) 그대로 남김."""
|
||||
import master_doc_calc as mc
|
||||
|
||||
cover = clean(doc.get(COVER))
|
||||
rest = {k: v for k, v in doc.items() if k != COVER}
|
||||
if not cover:
|
||||
return rest
|
||||
upper = upper if isinstance(upper, dict) else {}
|
||||
both = merge_layers(upper, cover)
|
||||
steer = {k: {mw.WORK: e[mw.WORK]} for k, e in both.items() if (e or {}).get(mw.WORK)}
|
||||
memo: dict = {}
|
||||
top = mc.calc(rest, links, None, (), memo)
|
||||
kept: dict = {} # 문서가 안 부르는 기계 덮음 = 뺌
|
||||
top = mc.calc(rest, links, None, (), memo, steer)
|
||||
kept: dict = {}
|
||||
seen: set[str] = set() # 값 · 조종원 · 잡품을 견준 열쇠
|
||||
for (key, given), ans in memo.items():
|
||||
m = machine_key(dict(given))
|
||||
sub = links.doc(key) if m in cover and m not in kept else None
|
||||
if not sub or not is_machine(sub):
|
||||
continue
|
||||
seen.add(m)
|
||||
base = defaults_of(sub, ans.get("값") or {}, row_entry(sub, lists_of(links, dict(given))))
|
||||
if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base):
|
||||
if one := prune({k: v for k, v in cover[m].items() if k != mw.WORK}, base, upper.get(m)):
|
||||
kept[m] = one
|
||||
works: dict = {} # 작업량(846-1) = 기계 줄 답이 읽은 작업 기계(부착 기계 포함) · 847-1 단가 기호 열쇠도
|
||||
for a in (top, *memo.values()):
|
||||
@@ -460,11 +615,24 @@ def prune_doc(doc: dict, links) -> dict:
|
||||
if w.get("기호"):
|
||||
works.setdefault(w["기호"], w["기계"])
|
||||
for m in sorted(set(works) & set(cover)):
|
||||
want = cover[m].get(mw.WORK)
|
||||
if want and (
|
||||
one := mw.prune_work(want, _work_base(links, want.get("기계") or works[m], want))
|
||||
):
|
||||
if not (want := cover[m].get(mw.WORK)):
|
||||
continue
|
||||
seen.add(f"{m}\n{mw.WORK}")
|
||||
up = (upper.get(m) or {}).get(mw.WORK) or {}
|
||||
eff = merge_work(up, want) or {}
|
||||
if eff.get("방식") == mw.HOURLY and not eff.get("식"):
|
||||
raise ValueError(f"{COVER} 「{m}」 작업량 — 시간당은 식 키 필요")
|
||||
base = _work_base(links, eff.get("기계") or works[m], eff)
|
||||
if one := prune_work_layer(want, base, up):
|
||||
kept[m] = {**kept.get(m, {}), mw.WORK: one}
|
||||
names = listed(rest) | {
|
||||
str(e[mw.WORK]["기계"]) for e in steer.values() if e[mw.WORK].get("기계")
|
||||
}
|
||||
for m in [m for m in cover if m in names]: # 안 부른 열쇠 — 문서 안에 들면 그대로
|
||||
if m not in seen and (vals := {k: v for k, v in cover[m].items() if k != mw.WORK}):
|
||||
kept[m] = {**vals, **kept.get(m, {})}
|
||||
if f"{m}\n{mw.WORK}" not in seen and cover[m].get(mw.WORK):
|
||||
kept[m] = {**kept.get(m, {}), mw.WORK: cover[m][mw.WORK]}
|
||||
return {**rest, COVER: kept} if kept else rest
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
/* 848-1 겹쳐 덮는 층 거울 헬퍼 — common_util_formula_doc_cover.ts 를 그 자리에서 트랜스파일해 Node 로 돌림.
|
||||
* stdin = {경우: [{위, 나, 기본}]}
|
||||
* stdout = {답: [{합침: mergeCover, 층: mergeLayers, 정리: prune, 위값: upperOf, 출처: sourcesOf}]} */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) =>
|
||||
p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const cover = load(path.join(__dirname, "..", "..", "common_util", "common_util_formula_doc_cover.ts"));
|
||||
|
||||
const input = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
const out = { 답: [] };
|
||||
for (const one of input.경우 || []) {
|
||||
const up = one.위 ?? null;
|
||||
const me = one.나 ?? null;
|
||||
out.답.push({
|
||||
합침: cover.mergeCover(up, me),
|
||||
층: cover.mergeLayers(up ? { K: up } : null, me ? { K: me } : null),
|
||||
정리: me ? cover.prune(me, one.기본, up) : null,
|
||||
위값: cover.upperOf(one.기본, up),
|
||||
출처: cover.sourcesOf(up, me),
|
||||
});
|
||||
}
|
||||
process.stdout.write(JSON.stringify(out));
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -219,8 +219,8 @@ def _cover(me, key: str, cover: dict) -> None:
|
||||
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
||||
|
||||
|
||||
def test_machine_cover_dropped_when_machine_moves(world, monkeypatch):
|
||||
"""㉢ 기계 덮음(836-1) + 그 기계 줄 M01 바뀜 = 덮음 지움 + 알림(전 · 후 · 내 고침 값)."""
|
||||
def test_machine_cover_kept_when_machine_moves(world, monkeypatch):
|
||||
"""㉢ 기계 덮음(836-1) + 그 칸 M01 바뀜 = 덮음 지킴(848-2 칸 단위) + 알림(전 · 후 · 내 값)."""
|
||||
me = world["personal"]
|
||||
key = _sk(me)
|
||||
_stack(me, key, [("기계", MACHINE, "묶음")])
|
||||
@@ -229,9 +229,9 @@ def test_machine_cover_dropped_when_machine_moves(world, monkeypatch):
|
||||
assert _at(me, path.read, key)["문서"]["기계덮음"]
|
||||
_move(monkeypatch, DIG)
|
||||
got = _at(me, path.read, key)
|
||||
assert "기계덮음" not in got["문서"]
|
||||
assert got["문서"]["기계덮음"] == {no: {"값": {"가격": 150000}}}
|
||||
[note] = got["사본"]["갱신"]
|
||||
assert note["키"] == DIG and note["갈래"] == "기계"
|
||||
assert note["키"] == DIG and note["갈래"] == "기계" and note["처리"] == "지킴"
|
||||
assert any(x.startswith("가격 ") for x in note["M01"]) and note["내고침"] == ["가격 150000"]
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,362 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""848-1 겹쳐 덮는 층(요구 889 · 요구서_889 1 절) — 층 셈 거울 · M01 기초 고침 저장 · SK 위 층 덮음 · 빌더 이어받기.
|
||||
|
||||
① 거울 — 합침 · 층 합침 · 정리(위 층 대조) · 위 층 값 · 출처가 파이썬 = TS(손셈 기대값 몇 개 + 전수 대조).
|
||||
㉠ M01 기초 고침(가격 · 조종원 · 작업량 시간당 + 변수) = 그 기초 셈만 바뀜 · 다른 기초 · 기계 정본 그대로 ·
|
||||
문서 밖 기계 고침 뺌 · ㉥ 빌더 이어받기(덮음 얹음 · 손고침 문서 그대로 + 목록 · 같게 되돌리면 표지 없음) ·
|
||||
㉣ 정본 값으로 되돌림 = 고침 0 · 문서 바이트 = 고침 전.
|
||||
㉡ 그 기초로 만든 SK = 위덮음 · 금액 = 기초 금액 · SK 고침 = ② 에만 · 금액 = ① + ② 셈 · 출처 ·
|
||||
㉢ ② 를 위 층 값으로 = ② 0 · ㉤ 옵션으로 기계를 바꿔 저장해도 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐 ·
|
||||
㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도).
|
||||
㉧ 기초 A 가 B 를 부를 때 A 의 고침만 A 셈에.
|
||||
정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage.
|
||||
"""
|
||||
|
||||
import copy as cp
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
from decimal import Decimal as D
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
from M01_MasterData import M01_MasterData_Store as m01 # scripts 길을 둠
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Item_Prices as item_prices
|
||||
from M02_MasterTemplete import M02_Item_Source as source
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Labor_SkRow as skrow
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
mc = importlib.import_module("master_doc_calc")
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
mcv = importlib.import_module("master_doc_cover")
|
||||
cv = importlib.import_module("master_doc_convert")
|
||||
build = importlib.import_module("build_수식문서_802_2")
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
COVER = mcv.COVER
|
||||
BASE = "GC000088" # 터파기(기계) 보통토사 — 굴착기 줄 하나(TypeⅠ = 1.0㎥ · TypeⅢ = 0.6㎥)
|
||||
NO, NO3 = "0201-0100", "0201-0060"
|
||||
SYM = "P_굴착기무한궤" # 그 줄 단가 기호 = 작업량 덮음 열쇠(847-1)
|
||||
TPL = "GC001147" # 굴착기 시간당 작업량 식
|
||||
|
||||
# ── ① 거울 ────────────────────────────────────────────────────────────
|
||||
BASE0 = {"값": {"가격": 100, "주연료": 10}, "조종원": [{"키": "LB:1", "인": 1}],
|
||||
"잡품": [{"줄": "주연료", "율": 22}], "작업량": {"f": 0.7, "E": 0.5}} # fmt: skip
|
||||
U1 = {"값": {"가격": 150}, "조종원": [{"키": "LB:1", "인": 2}],
|
||||
"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8}}} # fmt: skip
|
||||
U2 = {"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}}
|
||||
MINES = [
|
||||
None,
|
||||
{"값": {"가격": 150, "주연료": 20}},
|
||||
{"값": {"가격": 100}},
|
||||
{"조종원": [{"키": "LB:1", "인": 2}]},
|
||||
{"조종원": [{"키": "LB:1", "인": 1}]},
|
||||
{"잡품": []},
|
||||
{"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}},
|
||||
{"작업량": {"방식": "일당"}},
|
||||
{"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}},
|
||||
{"작업량": {"변수": {"E": 0.6}}},
|
||||
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO3, "이름": "굴착기 0.6㎥"}},
|
||||
{"작업량": {"방식": "시간당", "식": "T1", "기계": NO, "이름": "굴착기 1.0㎥"}},
|
||||
]
|
||||
|
||||
|
||||
def test_층_합침_정리_출처_손셈():
|
||||
p = mcv.prune
|
||||
assert p({"값": {"가격": 150, "주연료": 20}}, BASE0, U1) == {"값": {"주연료": 20}}
|
||||
assert p({"값": {"가격": 100}}, BASE0, U1) == {"값": {"가격": 100}} # 정본 값 = 위 층과 다름
|
||||
assert p({"값": {"가격": 100}}, BASE0) is None # 위 층 없음 = 지금과 같음
|
||||
assert p({"조종원": [{"키": "LB:1", "인": 2}]}, BASE0, U1) is None
|
||||
assert (
|
||||
p({"작업량": {"방식": "시간당", "식": "T1", "변수": {"f": 0.8, "E": 0.5}}}, BASE0, U1)
|
||||
is None
|
||||
)
|
||||
assert p({"작업량": {"방식": "일당"}}, BASE0, U1) == {"작업량": {"방식": "일당"}}
|
||||
assert p({"작업량": {"방식": "일당"}}, BASE0) is None
|
||||
want = {"작업량": {"식": "T2", "변수": {"f": 0.8}}} # 식 바꿈 = 위 층 변수 안 물려받음
|
||||
assert p({"작업량": {"방식": "시간당", "식": "T2", "변수": {"f": 0.8}}}, BASE0, U1) == want
|
||||
assert p({"작업량": {"변수": {"E": 0.6}}}, BASE0, U1) == {"작업량": {"변수": {"E": 0.6}}}
|
||||
assert p(U2, BASE0, U2) is None and p(U2, BASE0) == U2
|
||||
assert mcv.merge(U1, {"작업량": {"식": "T2"}})["작업량"] == {"방식": "시간당", "식": "T2"}
|
||||
assert mcv.merge(U1, {"작업량": {"방식": "일당"}})["작업량"]["방식"] == "일당"
|
||||
assert mcv.merge(U2, {"작업량": {"기계": NO}})["작업량"] == {
|
||||
"방식": "시간당",
|
||||
"식": "T1",
|
||||
"기계": NO,
|
||||
}
|
||||
got = mcv.sources(U1, {"값": {"주연료": 20}, "작업량": {"변수": {"E": 0.6}}})
|
||||
assert got == {"값.가격": "위", "조종원": "위", "작업량.방식": "위", "작업량.식": "위",
|
||||
"작업량.변수.f": "위", "값.주연료": "나", "작업량.변수.E": "나"} # fmt: skip
|
||||
assert mcv.sources(U1, {"작업량": {"식": "T2"}})["작업량.식"] == "나"
|
||||
assert "작업량.변수.f" not in mcv.sources(U1, {"작업량": {"식": "T2"}})
|
||||
assert mcv.upper_of(BASE0, U1) == {"값": {"가격": 150, "주연료": 10}, "조종원": U1["조종원"],
|
||||
"잡품": BASE0["잡품"], "작업량": U1["작업량"]} # fmt: skip
|
||||
mine = {"개인 EQP000001": {"값": {"가격": 1}}} # 내 기계 열쇠 = 같은 꼴
|
||||
assert mcv.merge_layers(None, mine) is mine and mcv.merge_layers(mine, {}) is mine
|
||||
assert mcv.merge_layers({"개인 EQP000001": U1}, mine)["개인 EQP000001"]["값"] == {"가격": 1}
|
||||
|
||||
|
||||
def _same(a, b, where=""):
|
||||
if isinstance(a, dict):
|
||||
assert isinstance(b, dict) and set(a) == set(b), (where, a, b)
|
||||
for k in a:
|
||||
_same(a[k], b[k], f"{where}.{k}")
|
||||
elif isinstance(a, list):
|
||||
assert isinstance(b, list) and len(a) == len(b), (where, a, b)
|
||||
for i, (x, y) in enumerate(zip(a, b)):
|
||||
_same(x, y, f"{where}[{i}]")
|
||||
elif isinstance(a, (int, float)) and not isinstance(a, bool):
|
||||
assert float(a) == pytest.approx(b), (where, a, b)
|
||||
else:
|
||||
assert a == b, (where, a, b)
|
||||
|
||||
|
||||
def test_거울_파이썬_TS_같은_답():
|
||||
cases = [{"위": u, "나": m, "기본": BASE0} for u in (None, U1, U2) for m in MINES]
|
||||
want = [
|
||||
{
|
||||
"합침": mcv.merge(c["위"], c["나"]),
|
||||
"층": mcv.merge_layers(
|
||||
{"K": c["위"]} if c["위"] else None, {"K": c["나"]} if c["나"] else None
|
||||
),
|
||||
"정리": mcv.prune(c["나"], BASE0, c["위"]) if c["나"] else None,
|
||||
"위값": mcv.upper_of(BASE0, c["위"]),
|
||||
"출처": mcv.sources(c["위"], c["나"]),
|
||||
}
|
||||
for c in cases
|
||||
]
|
||||
proc = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_848_1_cover_layers.cjs")],
|
||||
input=json.dumps({"경우": cases}, ensure_ascii=False),
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
check=True,
|
||||
)
|
||||
got = json.loads(proc.stdout)["답"]
|
||||
assert len(got) == len(want) == 36
|
||||
for i, (a, b) in enumerate(zip(want, got)):
|
||||
_same(a, b, f"경우{i}")
|
||||
|
||||
|
||||
# ── 임시 수식 문서 폴더(정본 파일 안 고침) ──────────────────────────────
|
||||
@pytest.fixture
|
||||
def docs_tmp(tmp_path, monkeypatch):
|
||||
dst = tmp_path / "수식문서"
|
||||
shutil.copytree(ml.FOLDER, dst)
|
||||
load = ml.load_all
|
||||
monkeypatch.setattr(ml, "FOLDER", dst)
|
||||
monkeypatch.setattr(ml, "load_all", lambda folder=dst: load(folder))
|
||||
m01doc._memo.clear()
|
||||
dc._FOLDER["자국"] = None
|
||||
yield dst
|
||||
m01doc._memo.clear()
|
||||
dc._FOLDER["자국"] = None
|
||||
|
||||
|
||||
def _json(v):
|
||||
"""화면 왕복(JSON 수)."""
|
||||
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False))
|
||||
|
||||
|
||||
def _norm(v):
|
||||
return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, sort_keys=True))
|
||||
|
||||
|
||||
def _defaults() -> dict:
|
||||
"""정본 — BASE 기본 옵션 굴착기(NO)의 덮음 없는 기본값."""
|
||||
links = ml.Links(m01.loaded()[1])
|
||||
memo: dict = {}
|
||||
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
|
||||
mc.calc(doc, links, None, (), memo)
|
||||
for (key, given), ans in memo.items():
|
||||
if mcv.is_machine(sub := links.doc(key)) and mcv.machine_key(dict(given)) == NO:
|
||||
lists = mcv.lists_of(links, dict(given))
|
||||
return mcv.defaults_of(sub, ans["값"], mcv.row_entry(sub, lists))
|
||||
raise AssertionError("굴착기 부름 없음")
|
||||
|
||||
|
||||
def _upper(d: dict, rate=D("1.5")) -> dict:
|
||||
"""기초 고침 ① — 가격 · 조종원 · 작업량(시간당 + 변수 f)."""
|
||||
return {NO: {"값": {"가격": float(D(str(d["값"]["가격"])) * rate)},
|
||||
"조종원": [{"키": d["조종원"][0]["키"], "인": 2}]},
|
||||
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
|
||||
|
||||
|
||||
def _save_m01(cover: dict | None, edit=None) -> dict:
|
||||
doc = _json(m01doc.read(BASE)["문서"])
|
||||
doc.pop(COVER, None)
|
||||
if cover:
|
||||
doc[COVER] = _json(cover)
|
||||
if edit:
|
||||
edit(doc)
|
||||
return m01doc.save(doc)
|
||||
|
||||
|
||||
def _calls(key: str) -> bool:
|
||||
return any(
|
||||
(v.get("연결") or {}).get("키") == "GC000267" for v in m01doc.docs()[key].get("변수") or []
|
||||
)
|
||||
|
||||
|
||||
def _mini():
|
||||
"""빌더 한 로직 파일 몫(BASE 가 든 파일) — {결과, 쓸 글, 파일}."""
|
||||
files, whole = m01.loaded()
|
||||
name = next(
|
||||
n
|
||||
for n, d in files.items()
|
||||
if d.get("그룹") == "로직" and any(str(r.get("키")) == BASE for r in d.get("줄") or [])
|
||||
)
|
||||
rows = files[name]["줄"]
|
||||
keys = [str(r["키"]) for r in rows]
|
||||
result = {
|
||||
"문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows},
|
||||
"파일": {name: keys},
|
||||
"저장": set(keys) & build.saved_keys(),
|
||||
"저장본": build.carried(),
|
||||
}
|
||||
return result, build.files_of(result)[ml.file_of(name)], ml.FOLDER / ml.file_of(name)
|
||||
|
||||
|
||||
def test_M01_기초_고침_빌더_이어받기_되돌림(docs_tmp):
|
||||
d = _defaults()
|
||||
result, text, file = _mini()
|
||||
orig = file.read_bytes()
|
||||
assert text == file.read_text(encoding="utf-8") # 고침 없음 = 빌더 글 = 저장본
|
||||
other = next(k for k in sorted(m01doc.docs()) if k != BASE and _calls(k))
|
||||
before, other_before = m01doc.read(BASE)["셈"]["계"], m01doc.read(other)["셈"]["계"]
|
||||
price = m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"]
|
||||
# ㉠ 고침 저장 — 문서 밖 기계(9999) = 뺌
|
||||
want = _upper(d)
|
||||
got = _save_m01({**want, "9999-9999": {"값": {"가격": 1}}})
|
||||
saved = ml.load_all()[BASE]
|
||||
assert _norm(saved[COVER]) == _norm(want) and mcv.HAND not in saved
|
||||
assert got["셈"]["계"] != before and m01doc.read(BASE)["셈"]["계"] == got["셈"]["계"]
|
||||
assert m01doc.read(other)["셈"]["계"] == other_before # 다른 기초 그대로
|
||||
assert m01.loaded()[1].numbers["EQ"][NO]["값"]["가격"] == price # 기계 정본 그대로
|
||||
line = next(x for x in got["셈"]["줄"] if x.get("작업량"))
|
||||
assert line["작업량"]["꼴"] == "시간당" and str(line["작업량"]["변수"]["f"]) == "0.8"
|
||||
# ㉥ 빌더 — 덮음 얹음(글 = 저장본)
|
||||
result, text, _ = _mini()
|
||||
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == []
|
||||
|
||||
# ㉥ 손고침 — 줄 식을 고친 문서 = 저장본 그대로 + 목록 · 같게 되돌리면 표지 없음
|
||||
def qty(text_):
|
||||
return lambda doc: doc["금액"][0].update({"수량": text_})
|
||||
|
||||
first = m01doc.read(BASE)["문서"]["금액"][0]["수량"]
|
||||
_save_m01(want, qty("Q_굴착기^표 × 9 ÷ Q_시공"))
|
||||
assert ml.load_all()[BASE].get(mcv.HAND) is True
|
||||
result, text, _ = _mini()
|
||||
assert text == file.read_text(encoding="utf-8") and build.hand_kept(result) == [BASE]
|
||||
_save_m01(want, qty(first))
|
||||
assert mcv.HAND not in ml.load_all()[BASE]
|
||||
# ㉣ 정본 값으로 되돌림 = 고침 0 · 바이트 = 고침 전
|
||||
back = {NO: {"값": {"가격": float(d["값"]["가격"])}, "조종원": d["조종원"]},
|
||||
SYM: {"작업량": {"방식": "일당"}}} # fmt: skip
|
||||
got = _save_m01(back)
|
||||
assert COVER not in got["문서"] and file.read_bytes() == orig
|
||||
assert got["셈"]["계"] == before
|
||||
|
||||
|
||||
def _sk(me) -> str:
|
||||
with store.at(me):
|
||||
body = skrow.logic_doc({"로직": BASE, "입력값": {}}, {}, m01.loaded()[1])
|
||||
return refs.create("sangeun", {**body, "이름": "sub2임시 848"})["이름"]
|
||||
|
||||
|
||||
def _at(me, fn, *args):
|
||||
with store.at(me):
|
||||
return fn(*args)
|
||||
|
||||
|
||||
def _mixed_sum(cover: dict) -> float:
|
||||
"""기초 문서(덮음 뗌)에 cover 를 얹은 셈 계 — SK 금액 대조."""
|
||||
links = ml.Links(m01.loaded()[1])
|
||||
doc = {k: v for k, v in links.doc(BASE).items() if k != COVER}
|
||||
return float(mc.calc(doc, links, None, (), None, cover)["계"])
|
||||
|
||||
|
||||
def test_SK_위덮음_내고침_되돌림_옵션_굳힘(docs_tmp, world):
|
||||
me = world["personal"]
|
||||
d = _defaults()
|
||||
upper = _upper(d)
|
||||
_save_m01(upper)
|
||||
base_sum = float(m01doc.read(BASE)["셈"]["계"])
|
||||
key = _sk(me)
|
||||
got = _at(me, path.read, key)
|
||||
# ㉡ ① = 위덮음 · 금액 = 기초 금액 · 파일에 굳음
|
||||
assert _norm(got["위덮음"]) == _norm(upper) and COVER not in got["문서"]
|
||||
assert float(got["셈"]["계"]) == base_sum
|
||||
with store.at(me):
|
||||
file = store.read("sangeun", key)["문서"]["수식"]
|
||||
assert _norm(file[mcv.UPPER]) == _norm(upper)
|
||||
# SK 에서 한 칸 더 고침 → ② 에만(① 과 같은 가격 = 지움 · 작업량 = 바꾼 변수만)
|
||||
doc = cp.deepcopy(got["문서"])
|
||||
doc[COVER] = {NO: {"값": {"가격": upper[NO]["값"]["가격"], "주연료": 20}},
|
||||
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.9}}}} # fmt: skip
|
||||
after = _at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
||||
mine = {NO: {"값": {"주연료": 20}}, SYM: {"작업량": {"변수": {"f": 0.9}}}}
|
||||
assert _norm(after["문서"][COVER]) == _norm(mine) and _norm(after["위덮음"]) == _norm(upper)
|
||||
assert float(after["셈"]["계"]) == _mixed_sum(mcv.merge_layers(upper, mine)) != base_sum
|
||||
assert mcv.sources(upper[NO], mine[NO]) == {"값.가격": "위", "조종원": "위", "값.주연료": "나"}
|
||||
assert mcv.sources(upper[SYM], mine[SYM]) == {
|
||||
"작업량.방식": "위", "작업량.식": "위", "작업량.변수.f": "나"
|
||||
} # fmt: skip
|
||||
# ㉦ 프로젝트로 굳힘 = 굳힐 때 금액(기초가 그 뒤 바뀌어도)
|
||||
with store.at(me):
|
||||
here = refs.here()
|
||||
ref = {"층": here[0], "주인": here[1], "키": key}
|
||||
rows = source.labor_doc_rows(
|
||||
{"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]}
|
||||
)
|
||||
bundle = source.price_bundle(rows, me)
|
||||
frozen = rows["참조사본"][refs.ref_id(ref)]["수식"]
|
||||
assert _norm(frozen[mcv.UPPER]) == _norm(upper)
|
||||
was = float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"])
|
||||
assert was == float(after["셈"]["계"])
|
||||
_save_m01(_upper(d, D(2))) # 기초 고침이 바뀜
|
||||
now = _at(me, path.read, key)
|
||||
assert float(now["셈"]["계"]) != was # 프로젝트 밖 = 지금 기초 것
|
||||
assert float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) == was # 사본 = 굳은 것
|
||||
_save_m01(upper)
|
||||
# ㉢ ② 를 위 층 값으로 = ② 0
|
||||
now = _at(me, path.read, key)
|
||||
doc = cp.deepcopy(now["문서"])
|
||||
doc[COVER] = {NO: {"값": {"주연료": d["값"]["주연료"]}},
|
||||
SYM: {"작업량": {"방식": "시간당", "식": TPL, "변수": {"f": 0.8}}}} # fmt: skip
|
||||
back = _at(me, path.save, key, {"문서": doc, "판": now["판"]})
|
||||
assert COVER not in back["문서"] and float(back["셈"]["계"]) == base_sum
|
||||
with store.at(me):
|
||||
assert COVER not in store.read("sangeun", key)["문서"]["수식"]["문서"]
|
||||
# ㉤ 옵션으로 기계를 바꿔 저장 = 앞 기계 고침 남음 · 문서 밖 기계 고침만 빠짐
|
||||
doc = cp.deepcopy(back["문서"])
|
||||
next(v for v in doc["변수"] if v["열쇠"] == "Type")["연결"]["값"] = "TypeⅢ"
|
||||
doc[COVER] = {NO: {"값": {"주연료": 20}}, "9999-9999": {"값": {"가격": 1}}}
|
||||
moved = _at(me, path.save, key, {"문서": doc, "판": back["판"]})
|
||||
assert moved["문서"][COVER] == {NO: {"값": {"주연료": 20}}}
|
||||
line = next(x for x in moved["셈"]["줄"] if x.get("작업량"))
|
||||
assert line["작업량"]["기계"] == NO3 # 셈은 바꾼 기계(앞 기계 고침은 안 걸림)
|
||||
|
||||
|
||||
def test_A_가_B_를_부를_때_A_고침만():
|
||||
links = ml.Links(m01.loaded()[1])
|
||||
a, b, no = "GF000177", "GF000168", "0201-0070"
|
||||
price = float(m01.loaded()[1].numbers["EQ"][no]["값"]["가격"])
|
||||
cover = {no: {"값": {"가격": price * 2}}}
|
||||
given = {"기초잡석량": D(1)} # A(날개벽) 기초잡석 1 ㎥ = B(기초잡석) 부름
|
||||
plain_a = mc.calc(links.doc(a), links, given)["계"]
|
||||
plain_b = mc.calc(links.doc(b), links)["계"]
|
||||
assert plain_a > 0
|
||||
with_b = ml.Links(m01.loaded()[1], {**links.docs, b: {**links.doc(b), COVER: cover}})
|
||||
assert mc.calc(with_b.doc(a), with_b, given)["계"] == plain_a # B 의 고침 = A 셈에 안 걸림
|
||||
assert mc.calc(with_b.doc(b), with_b)["계"] != plain_b # B 를 맨 위로 열면 걸림
|
||||
mine = mc.calc({**links.doc(a), COVER: cover}, links, given)["계"]
|
||||
assert mine > plain_a # A 고침 = B 안 기계 줄까지
|
||||
@@ -0,0 +1,290 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""848-2 갱신 칸 단위(요구서_889 3 절) — 임시 storage + M01 메모리 사본(정본 파일 안 고침).
|
||||
|
||||
㉠ 기계 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음
|
||||
㉡ 기계 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값) · 금액 그대로
|
||||
㉢ 기계 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음
|
||||
㉣ 기초 고침(①)만 바뀜 = 따로 문서 · 끊음 안 지워짐 · ① 이 내 고침 칸을 바꾸면 지킴 알림(층 기초)
|
||||
㉤ 기초에 줄이 더해짐 = 다시 복사 + 알림 자료 · 기계 고침 · 옵션 값 다시 얹힘
|
||||
㉥ 확인 전 [저장] = 바탕 남아 알림 계속 · 확인 뒤 = 안 뜸
|
||||
㉦ 프로젝트 사본 = 그대로 ㉧ 내 기계 · 가져온 식 = 같은 규칙.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import shutil
|
||||
|
||||
import pytest
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_MyMachine as mym
|
||||
from M02_MasterTemplete import M02_Sk_AutoRenew as renew
|
||||
from resources.tester.test_822_1_copy_gap import DIG, DIG_NO, MACHINE, _at, _move, _sk, _stack
|
||||
from resources.tester.test_836_2_sk_auto_renew import _cover, _doc_move
|
||||
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
|
||||
|
||||
CUT = (
|
||||
"GC000085" # 흙깎기(기계) 보통토사 — 굴착기 1.0㎥(0201-0100) 부름 · 옵션 규모 · 지역 · 보정작업
|
||||
)
|
||||
PRICE = 142069 # 굴착기 1.0㎥ M01 가격
|
||||
WAIT = pytest.mark.xfail(reason="M02_Doc_Sk 세 줄(848-2 a · b · c) 붙인 뒤", strict=True)
|
||||
|
||||
|
||||
def _eq_move(monkeypatch, key: str, fn) -> None:
|
||||
"""M01 기계 줄 하나 고침(메모리 · 진짜 색인 사본)."""
|
||||
files, live = m01.loaded()
|
||||
fake = copy.copy(live)
|
||||
fake.index, fake.numbers = dict(live.index), dict(live.numbers)
|
||||
row = copy.deepcopy(live.index["EQ"][key])
|
||||
fn(row)
|
||||
fake.index["EQ"] = {**fake.index["EQ"], key: row}
|
||||
fake.numbers["EQ"] = {**fake.numbers["EQ"], str(row["원문번호"]): row}
|
||||
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
|
||||
|
||||
|
||||
def _read(me, key):
|
||||
return _at(me, path.read, key)
|
||||
|
||||
|
||||
def _machine_sk(me, cover: dict) -> str:
|
||||
key = _sk(me)
|
||||
_stack(me, key, [("기계", MACHINE, "묶음")])
|
||||
_cover(me, key, {DIG_NO: cover})
|
||||
return key
|
||||
|
||||
|
||||
def _cut_sk(me, size: str = "소규모", cover: dict | None = None) -> str:
|
||||
"""흙깎기 바탕 SK — 규모 옵션 고침(소규모 = 굴착기 줄 셈) · ② 기계 고침 · 따로 저장."""
|
||||
key = _sk(me, 바탕={"로직": CUT}, 단위="㎥")
|
||||
got = _read(me, key)
|
||||
doc = copy.deepcopy(got["문서"])
|
||||
for v in doc["변수"]:
|
||||
if v.get("열쇠") == "규모":
|
||||
v["연결"]["값"] = size
|
||||
if cover:
|
||||
doc["기계덮음"] = {DIG_NO: cover}
|
||||
_at(me, path.save, key, {"문서": doc, "판": got["판"]})
|
||||
return key
|
||||
|
||||
|
||||
def _size(doc: dict) -> str:
|
||||
return next(v["연결"]["값"] for v in doc["변수"] if v.get("열쇠") == "규모")
|
||||
|
||||
|
||||
def test_price_follows_crew_kept(world, monkeypatch):
|
||||
"""㉠ 가격만 바뀜 + 인력 고침 = 가격 따라옴 · 인력 고침 남음 · 알림 없음."""
|
||||
me = world["personal"]
|
||||
crew = {"조종원": [{"키": "LB:1048", "인": 2}]}
|
||||
key = _machine_sk(me, crew)
|
||||
was = _read(me, key)
|
||||
assert was["문서"]["기계덮음"] == {DIG_NO: crew}
|
||||
_move(monkeypatch, DIG)
|
||||
got = _read(me, key)
|
||||
assert got["문서"]["기계덮음"] == {DIG_NO: crew} and got["사본"]["갱신"] == []
|
||||
assert got["셈"]["계"] > was["셈"]["계"]
|
||||
|
||||
|
||||
def test_price_kept_with_note(world, monkeypatch):
|
||||
"""㉡ 가격 바뀜 + 가격 고침 = 내 값 지킴 + 알림(전 → 후 · 내 값 · 칸 경로) · 금액 그대로 ·
|
||||
읽기 = 파일 안 씀."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}})
|
||||
was = _read(me, key)
|
||||
file = me / "sangeun" / f"{key}.json"
|
||||
before = file.read_bytes()
|
||||
_move(monkeypatch, DIG)
|
||||
got = _read(me, key)
|
||||
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
|
||||
assert got["셈"]["계"] == was["셈"]["계"]
|
||||
[note] = got["사본"]["갱신"]
|
||||
assert {k: note[k] for k in ("키", "갈래", "처리", "열쇠", "경로", "층")} == {
|
||||
"키": DIG, "갈래": "기계", "처리": "지킴", "열쇠": DIG_NO, "경로": "값.가격", "층": "기계",
|
||||
} # fmt: skip
|
||||
assert (note["전"], note["후"], note["내값"]) == (PRICE, PRICE * 2, 150000)
|
||||
assert note["M01"] == [f"가격 {PRICE} → {PRICE * 2}"] and note["내고침"] == ["가격 150000"]
|
||||
assert file.read_bytes() == before
|
||||
|
||||
|
||||
def test_label_only(world, monkeypatch):
|
||||
"""㉢ 비고 · 출처 글만 바뀜 = 고침 그대로 · 알림 없음 · 금액 같음."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": [{"키": "LB:1048", "인": 2}]})
|
||||
was = _read(me, key)
|
||||
|
||||
def label(row: dict) -> None:
|
||||
row["비고"] = "848-2 시험 비고"
|
||||
row["출처"] = {**row["출처"], "가격": "848-2 시험 출처"}
|
||||
row["이름"] = row["이름"] + " 새 이름"
|
||||
|
||||
_eq_move(monkeypatch, DIG, label)
|
||||
got = _read(me, key)
|
||||
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"] and got["사본"]["갱신"] == []
|
||||
assert got["셈"]["계"] == was["셈"]["계"]
|
||||
|
||||
|
||||
def test_crew_list_kept(world, monkeypatch):
|
||||
"""㉡ 목록 칸 — 기계 인력 줄 바뀜 + 인력 고침 = 지킴 알림(목록 글) · 가격 고침 칸은 알림 없음."""
|
||||
me = world["personal"]
|
||||
mine = [{"키": "LB:1048", "인": 2}]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}, "조종원": mine})
|
||||
_eq_move(monkeypatch, DIG, lambda r: r["값"].update(인력=[{"키": "LB:1048", "인": 1.5}]))
|
||||
[note] = _read(me, key)["사본"]["갱신"]
|
||||
assert (note["경로"], note["처리"], note["내값"]) == ("조종원", "지킴", mine)
|
||||
assert note["M01"] == ["인력 LB:1048 1인 → LB:1048 1.5인"]
|
||||
|
||||
|
||||
@WAIT
|
||||
def test_upper_only(world, monkeypatch):
|
||||
"""㉣ 기초 고침(①)만 바뀜(+ 이름 글) = 따로 문서 그대로 · 내 고침 칸을 ① 이 바꾸면 지킴 알림(층 기초) ·
|
||||
② 없는 칸(주연료)은 알림 없음."""
|
||||
me = world["personal"]
|
||||
key = _cut_sk(me, cover={"값": {"가격": 150000}})
|
||||
was = _read(me, key)
|
||||
assert was["사본"]["따로"] is True
|
||||
|
||||
def upper(d: dict) -> None:
|
||||
d["기계덮음"] = {DIG_NO: {"값": {"가격": 200000, "주연료": 30}}}
|
||||
d["이름"] = d["이름"] + " 새 이름"
|
||||
|
||||
_doc_move(monkeypatch, CUT, upper)
|
||||
got = _read(me, key)
|
||||
assert got["사본"]["따로"] is True and _size(got["문서"]) == "소규모"
|
||||
assert got["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
|
||||
[note] = got["사본"]["갱신"]
|
||||
assert (note["경로"], note["층"], note["전"], note["후"]) == ("값.가격", "기초", PRICE, 200000)
|
||||
assert not got["사본"]["문서새판"]
|
||||
|
||||
|
||||
def test_cut_kept_on_upper(world, monkeypatch):
|
||||
"""㉣ 끊음 — 부른 문서의 ① · 글만 바뀜 = 끊음 그대로 · 계산 내용이 바뀜 = 다시 복사 + 알림."""
|
||||
me = world["personal"]
|
||||
key = _sk(me)
|
||||
_stack(me, key, [("기계", MACHINE, "묶음")])
|
||||
got = _read(me, key)
|
||||
call = MACHINE["키"]
|
||||
mine = copy.deepcopy(got["부름"][call])
|
||||
mine["금액"][0]["수량"] = f"({mine['금액'][0].get('수량') or 1}) × 2"
|
||||
_at(me, path.save, key, {"끊음": {call: mine}, "판": got["판"]})
|
||||
was = _read(me, key)
|
||||
assert call in was["끊음"]
|
||||
_doc_move(
|
||||
monkeypatch, call, lambda d: d.update(기계덮음={DIG_NO: {"값": {"가격": 1}}}, 이름="새")
|
||||
)
|
||||
got = _read(me, key)
|
||||
assert got["끊음"][call]["금액"][0]["수량"] == mine["금액"][0]["수량"]
|
||||
assert got["사본"]["갱신"] == [] and got["셈"]["계"] == was["셈"]["계"]
|
||||
_doc_move(monkeypatch, call, lambda d: d["금액"].append(copy.deepcopy(d["금액"][0])))
|
||||
got = _read(me, key)
|
||||
assert call not in got["끊음"]
|
||||
[note] = got["사본"]["갱신"]
|
||||
assert (note["갈래"], note["처리"]) == ("부름", "지워짐") and note["내고침"]
|
||||
|
||||
|
||||
def _grow(d: dict) -> None:
|
||||
d["금액"].append({**copy.deepcopy(d["금액"][1]), "이름": "848-2 덧줄"})
|
||||
|
||||
|
||||
def test_structure_recopy(world, monkeypatch):
|
||||
"""㉤ 기초에 줄이 더해짐 = 다시 복사(따로 아님) · 기계 고침 · 옵션 값 다시 얹음 · 알림 다시복사."""
|
||||
me = world["personal"]
|
||||
cover = {"값": {"가격": 150000}}
|
||||
key = _cut_sk(me, cover=cover)
|
||||
_doc_move(monkeypatch, CUT, _grow)
|
||||
got = _read(me, key)
|
||||
assert got["사본"]["따로"] is False
|
||||
assert got["문서"]["기계덮음"] == {DIG_NO: cover} and _size(got["문서"]) == "소규모"
|
||||
assert any(x["이름"] == "848-2 덧줄" for x in got["문서"]["금액"])
|
||||
[note] = got["사본"]["갱신"]
|
||||
assert (note["갈래"], note["처리"], note["내고침"]) == ("문서", "다시복사", [])
|
||||
assert note["다시얹음"] == ["규모 소규모"]
|
||||
|
||||
|
||||
@WAIT
|
||||
def test_structure_recopy_saved(world, monkeypatch):
|
||||
"""㉤ 다시 복사한 뒤 알림 [확인](저장) = 기계 고침 · 옵션 값 남음 · 알림 없음."""
|
||||
me = world["personal"]
|
||||
cover = {"값": {"가격": 150000}}
|
||||
key = _cut_sk(me, cover=cover)
|
||||
_doc_move(monkeypatch, CUT, _grow)
|
||||
got = _read(me, key)
|
||||
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
|
||||
after = _read(me, key)
|
||||
assert after["사본"]["갱신"] == [] and after["문서"]["기계덮음"] == {DIG_NO: cover}
|
||||
assert _size(after["문서"]) == "소규모" and after["셈"]["계"] == got["셈"]["계"]
|
||||
|
||||
|
||||
def test_save_keeps_base(world, monkeypatch):
|
||||
"""㉥ 확인 전 [저장](고친 문서 다시 저장) = 바탕 남아 알림 계속."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}})
|
||||
_move(monkeypatch, DIG)
|
||||
got = _read(me, key)
|
||||
_at(me, path.save, key, {"문서": got["문서"], "판": got["판"]})
|
||||
again = _read(me, key)
|
||||
[note] = again["사본"]["갱신"]
|
||||
assert (note["전"], note["후"]) == (PRICE, PRICE * 2)
|
||||
|
||||
|
||||
@WAIT
|
||||
def test_confirm_clears(world, monkeypatch):
|
||||
"""㉥ 알림 [확인] 뒤 = 안 뜸 · 내 값 그대로 · 금액 같음."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}})
|
||||
_move(monkeypatch, DIG)
|
||||
got = _read(me, key)
|
||||
_at(me, path.save, key, {"할일": renew.CONFIRM, "판": got["판"]})
|
||||
after = _read(me, key)
|
||||
assert after["사본"]["갱신"] == [] and after["셈"]["계"] == got["셈"]["계"]
|
||||
assert after["문서"]["기계덮음"] == {DIG_NO: {"값": {"가격": 150000}}}
|
||||
|
||||
|
||||
def test_project_keeps(world, monkeypatch):
|
||||
"""㉦ 프로젝트 층 사본 = 그대로(금액 · 고침 · 알림 없음)."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}})
|
||||
proj = me.parent / "p8482" / "templates"
|
||||
(proj / "sangeun").mkdir(parents=True)
|
||||
shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json")
|
||||
with store.at(proj):
|
||||
assert refs.here()[0] == "project"
|
||||
was = _read(proj, key)
|
||||
_move(monkeypatch, DIG)
|
||||
got = _read(proj, key)
|
||||
assert got["셈"]["계"] == was["셈"]["계"] and got["사본"]["갱신"] == []
|
||||
assert got["문서"]["기계덮음"] == was["문서"]["기계덮음"]
|
||||
|
||||
|
||||
def test_my_machine(world):
|
||||
"""㉧ 내 기계 — 가격 고침 + 내 기계 가격 바뀜 = 지킴 알림."""
|
||||
me = world["personal"]
|
||||
vals = {"가격": 1000, "손료계수": 2000, "주연료": 2, "주연료종류": "경유", "잡재료율": 10,
|
||||
"조종원": 1, "조종원직종": "1048"} # fmt: skip
|
||||
made = _at(me, mym.create, {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로", "값": vals})
|
||||
no, hourly = made["줄"]["원문번호"], made["시간당"]["로직"]
|
||||
key = _sk(me)
|
||||
link = {"갈래": "단가산출", "키": hourly, "입력": {"기계": f"'{no}'"}}
|
||||
_stack(me, key, [("기계", link, "묶음")])
|
||||
_cover(me, key, {no: {"값": {"가격": 5000}}})
|
||||
assert _read(me, key)["사본"]["갱신"] == []
|
||||
_at(me, mym.update, made["줄"]["키"], {"이름": "sub4임시기계", "규격": "1㎾", "방식": "바로",
|
||||
"값": {**vals, "가격": 3000}}) # fmt: skip
|
||||
[note] = _read(me, key)["사본"]["갱신"]
|
||||
assert (note["열쇠"], note["처리"], note["전"], note["후"], note["내값"]) == (
|
||||
no, "지킴", 1000, 3000, 5000,
|
||||
) # fmt: skip
|
||||
|
||||
|
||||
def test_imported_same_rule(world, monkeypatch):
|
||||
"""㉧ 가져온 식 — 같은 칸 판정(① = 저장 `위덮음`) · 알림 지킴."""
|
||||
me = world["personal"]
|
||||
key = _machine_sk(me, {"값": {"가격": 150000}})
|
||||
sk = _at(me, lambda: store.read("sangeun", key)["문서"])
|
||||
sk = {**sk, "가져온": {"로직": {}}} # 가져온 식 꼴(판정만)
|
||||
_move(monkeypatch, DIG)
|
||||
with store.at(me):
|
||||
[note] = renew.notes(sk)
|
||||
assert (note["처리"], note["경로"], note["후"]) == ("지킴", "값.가격", PRICE * 2)
|
||||
@@ -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