Merge remote-tracking branch 'origin/dev' into sub_laptop_2
This commit is contained in:
@@ -0,0 +1,287 @@
|
||||
"""M02 일위대가 문서 `labor/<열id>.json` — 정리 · 검사 · 계산 · 알약(PLAN 39-1a · 설계_정함 1장).
|
||||
|
||||
문서 = `{종류, 판, 열, 일위대가번, 단위, 본뜬, 담은로직: [{로직, 메모, 입력값, 수량}],
|
||||
자재: [{코드, 이름, 규격, 단위, 수량}], 계산값}` — 이름은 구조물 열 이름(따로 안 둠).
|
||||
수량 = `null`(면적산출 알약 칸 값 · 로직 알약 「이름|단위」 · 자재 알약 「자재|MT키」) | `{손: 수}`
|
||||
(손이 칸보다 앞섬) · 같은 로직 두 번 금지 · 입력값 = 그 로직 입력 이름만(빈 값 = 자동값).
|
||||
금액: 기준 = 결과단위 그대로(서버 단독 · M01 엔진) · 반영 = 기준 × 수량 ÷ 배 · 돈 아닌 로직은
|
||||
반영 없음 · 자재 기준 단가 = `master_material.element` 기본값.
|
||||
짝(CLAUDE.md 5장 ①): 수량 · 반영 · 합 `settle` ↔ `M02_MasterTemplete_Labor_Calc.ts` —
|
||||
거울 시험 `resources/tester/test_m02_labor_calc_mirror.py`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from decimal import Decimal, InvalidOperation
|
||||
from typing import Any
|
||||
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M01_MasterData import M01_MasterData_Store_Combo as combo_store
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
mf = m01.cm.mf
|
||||
mm = mf.mp.mm
|
||||
COSTS = mf.COST_ITEMS # 노무비 · 재료비 · 경비
|
||||
MATERIAL_HEAD = "자재|"
|
||||
_MAT_COLS = ("코드", "이름", "규격", "단위")
|
||||
|
||||
|
||||
def _bad(text: str) -> store.StoreError:
|
||||
return store.StoreError(400, text)
|
||||
|
||||
|
||||
def _number(raw: Any) -> Decimal | None:
|
||||
"""칸 값 · 손 값 → Decimal — 수가 아니면 None(쉼표는 뗌)."""
|
||||
if raw is None or isinstance(raw, bool):
|
||||
return None
|
||||
try:
|
||||
got = Decimal(str(raw).replace(",", "").strip())
|
||||
except InvalidOperation:
|
||||
return None
|
||||
return got if got.is_finite() else None
|
||||
|
||||
|
||||
def _specs(logic: dict) -> list[dict]:
|
||||
"""로직 입력 꼴 — 흐름 로직은 「설계 때 정할 것」."""
|
||||
if isinstance(logic.get("흐름"), dict):
|
||||
return mf.inputs_of(logic)
|
||||
return list(logic.get("입력") or [])
|
||||
|
||||
|
||||
def _qty(value: Any, where: str) -> dict | None:
|
||||
if value is None:
|
||||
return None
|
||||
hand = _number(value.get("손")) if isinstance(value, dict) else None
|
||||
if hand is None:
|
||||
raise _bad(f"{where} · 수량은 null 또는 {{손: 수}}")
|
||||
return {"손": int(hand) if hand == hand.to_integral_value() else float(hand)}
|
||||
|
||||
|
||||
# ── 정리 · 검사 ───────────────────────────────────────────────────────
|
||||
def clean(doc: Any) -> dict[str, Any]:
|
||||
"""서버가 받는 꼴로 — 모르는 로직 · 같은 로직 두 번 · 없는 자재 · 수량 꼴이 틀리면 400 ·
|
||||
모르는 입력 이름 · 빈 입력값은 버림 · 자재 이름 · 규격 · 단위는 M01 것."""
|
||||
if not isinstance(doc, dict):
|
||||
raise _bad("일위대가 문서가 묶음 아님")
|
||||
whole = m01.loaded()[1]
|
||||
lines, seen = [], set()
|
||||
for at, one in enumerate(doc.get("담은로직") or [], start=1):
|
||||
where = f"담은 로직 {at}째"
|
||||
if not isinstance(one, dict):
|
||||
raise _bad(f"{where} · 묶음 아님")
|
||||
code = str(one.get("로직") or "")
|
||||
try:
|
||||
logic = whole.logic(code)
|
||||
except mf.FormulaError as e:
|
||||
raise _bad(f"{where} · {e}") from e
|
||||
if code in seen:
|
||||
raise _bad(f"{where} · 같은 로직을 두 번 담음 「{code}」")
|
||||
seen.add(code)
|
||||
names = {str(spec.get("이름")) for spec in _specs(logic)}
|
||||
given = one.get("입력값") or {}
|
||||
if not isinstance(given, dict):
|
||||
raise _bad(f"{where} · 입력값이 묶음 아님")
|
||||
memo = one.get("메모")
|
||||
lines.append(
|
||||
{
|
||||
"로직": code,
|
||||
"메모": str(memo) if memo else None,
|
||||
"입력값": {k: v for k, v in given.items() if k in names and v not in (None, "")},
|
||||
"수량": _qty(one.get("수량"), where),
|
||||
}
|
||||
)
|
||||
mats, codes = [], set()
|
||||
for at, one in enumerate(doc.get("자재") or [], start=1):
|
||||
where = f"자재 {at}째"
|
||||
code = str(one.get("코드") or "") if isinstance(one, dict) else ""
|
||||
try:
|
||||
row = whole.get(code) if code[:2] == mm.MARKET else None
|
||||
except mf.FormulaError:
|
||||
row = None
|
||||
if row is None:
|
||||
raise _bad(f"{where} · M01 자재품목에 없는 코드 「{code}」")
|
||||
if code in codes:
|
||||
raise _bad(f"{where} · 같은 자재를 두 번 담음 「{code}」")
|
||||
codes.add(code)
|
||||
mats.append(
|
||||
{
|
||||
"코드": code,
|
||||
**{k: row.get(k) or "" for k in _MAT_COLS[1:]},
|
||||
"수량": _qty(one.get("수량"), where),
|
||||
}
|
||||
)
|
||||
out = {
|
||||
"종류": "일위대가",
|
||||
"판": doc.get("판") or 1,
|
||||
"열": doc.get("열"),
|
||||
"단위": str(doc["단위"]) if doc.get("단위") else None,
|
||||
"본뜬": doc["본뜬"] if isinstance(doc.get("본뜬"), dict) else None,
|
||||
"담은로직": lines,
|
||||
"자재": mats,
|
||||
}
|
||||
if doc.get("일위대가번"):
|
||||
out["일위대가번"] = doc["일위대가번"]
|
||||
return out
|
||||
|
||||
|
||||
# ── 알약 · 면적 값 ────────────────────────────────────────────────────
|
||||
def material_key(code: str) -> str:
|
||||
return f"{MATERIAL_HEAD}{code}"
|
||||
|
||||
|
||||
def pills(doc: dict) -> list[dict[str, Any]]:
|
||||
"""면적산출 알약 — 로직 물량 알약(`combo_pills` 그대로) + 자재 알약 「자재|MT키」."""
|
||||
logic = combo_store.combo_pills({"담은로직": doc.get("담은로직") or []})["물량"]
|
||||
mats = [
|
||||
{
|
||||
"키": material_key(m["코드"]),
|
||||
"이름": m.get("이름") or m["코드"],
|
||||
"단위": m.get("단위") or "",
|
||||
"자재": {k: m.get(k) or "" for k in _MAT_COLS},
|
||||
}
|
||||
for m in doc.get("자재") or []
|
||||
]
|
||||
return [*logic, *mats]
|
||||
|
||||
|
||||
def area_values(area: Any) -> dict[str, Decimal]:
|
||||
"""면적산출 문서 `연결` 의 알약 → 칸 값(식 칸 = 서버 `계산값` · 그 밖 = 칸 값) · 수만."""
|
||||
out: dict[str, Decimal] = {}
|
||||
if not isinstance(area, dict):
|
||||
return out
|
||||
calc = area.get("계산값") or {}
|
||||
for sheet in area.get("시트") or []:
|
||||
cells, got = sheet.get("칸") or {}, calc.get(sheet.get("id")) or {}
|
||||
for link in sheet.get("연결") or []:
|
||||
at = link.get("칸")
|
||||
raw = (got.get(at) or {}).get("수")
|
||||
if raw is None:
|
||||
raw = (cells.get(at) or {}).get("값")
|
||||
value = _number(raw)
|
||||
if value is not None and link.get("키"):
|
||||
out[str(link["키"])] = value
|
||||
return out
|
||||
|
||||
|
||||
def _area_of(column: Any) -> dict[str, Decimal]:
|
||||
"""지금 층 그 열 면적산출의 알약 값 — 파일이 없으면 빈 것."""
|
||||
try:
|
||||
path = store._path("area", str(column or ""))
|
||||
except store.StoreError:
|
||||
return {}
|
||||
return area_values(json.loads(path.read_bytes())) if path.is_file() else {}
|
||||
|
||||
|
||||
# ── 계산 ──────────────────────────────────────────────────────────────
|
||||
def _money(value: Any) -> dict[str, Decimal] | None:
|
||||
if not isinstance(value, dict):
|
||||
return None
|
||||
return {k: _number(value.get(k)) or Decimal(0) for k in (*COSTS, "계")}
|
||||
|
||||
|
||||
def reflect(base: dict[str, Decimal], qty: Decimal | None, times: Decimal) -> dict | None:
|
||||
"""반영 = 기준 × 수량 ÷ 배 — 수량이 없으면 None."""
|
||||
if qty is None:
|
||||
return None
|
||||
return {k: base[k] * qty / times for k in (*COSTS, "계")}
|
||||
|
||||
|
||||
def _sum(rows: list[dict | None]) -> dict[str, Decimal]:
|
||||
return {k: sum((r[k] for r in rows if r), Decimal(0)) for k in (*COSTS, "계")}
|
||||
|
||||
|
||||
def _pick(hand: Any, key: Any, given: dict[str, Decimal]) -> tuple[Decimal | None, str]:
|
||||
"""(수량, 출처) — 손 · 칸(알약 키) · 없음."""
|
||||
if isinstance(hand, dict) and _number(hand.get("손")) is not None:
|
||||
return _number(hand["손"]), "손"
|
||||
if key and key in given:
|
||||
return given[key], "칸"
|
||||
return None, "없음"
|
||||
|
||||
|
||||
def settle(result: dict, doc: dict, given: dict[str, Any]) -> dict[str, Any]:
|
||||
"""기준이 선 계산 답에 수량 · 반영 · 합을 채움 — 수량만 바뀌면 이것만 다시
|
||||
(짝: `Labor_Calc.ts` `settle` · 자재 = 재료비)."""
|
||||
have = {str(k): v for k, raw in given.items() if (v := _number(raw)) is not None}
|
||||
hands = {one.get("로직"): one.get("수량") for one in doc.get("담은로직") or []}
|
||||
mhands = {one.get("코드"): one.get("수량") for one in doc.get("자재") or []}
|
||||
zero = dict.fromkeys((*COSTS, "계"), Decimal(0))
|
||||
lines, mats, bases, reflects = [], [], [], []
|
||||
for line in result.get("줄") or []:
|
||||
qty, source = _pick(hands.get(line.get("로직")), line.get("알약"), have)
|
||||
base = _money(line.get("기준"))
|
||||
done = reflect(base, qty, _number(line.get("배")) or Decimal(1)) if base else None
|
||||
bases.append(base)
|
||||
reflects.append(done)
|
||||
lines.append({**line, "수량": qty, "수량출처": source, "반영": done})
|
||||
for one in result.get("자재") or []:
|
||||
qty, source = _pick(mhands.get(one.get("코드")), one.get("알약"), have)
|
||||
price = _number(one.get("기준단가"))
|
||||
cost = price * qty if price is not None and qty is not None else None
|
||||
bases.append({**zero, "재료비": price, "계": price} if price is not None else None)
|
||||
reflects.append({**zero, "재료비": cost, "계": cost} if cost is not None else None)
|
||||
mats.append({**one, "수량": qty, "수량출처": source, "반영": cost})
|
||||
return _json({"줄": lines, "자재": mats, "기준합": _sum(bases), "반영합": _sum(reflects)})
|
||||
|
||||
|
||||
def calc(doc: dict, given: dict[str, Any] | None = None) -> dict[str, Any]:
|
||||
"""`doc` = 정리한 문서 · `given` = {알약 키: 값}(없으면 지금 층 면적산출 파일에서) —
|
||||
줄마다 기준(서버 단독 · M01 엔진) → `settle`. 못 도는 줄은 까닭만(통째로 멈추지 않음)."""
|
||||
whole = m01.loaded()[1]
|
||||
by_logic = {
|
||||
code: pill
|
||||
for pill in combo_store.combo_pills({"담은로직": doc.get("담은로직") or []})["물량"]
|
||||
for code in pill["로직"]
|
||||
}
|
||||
lines = []
|
||||
for one in doc.get("담은로직") or []:
|
||||
code = one["로직"]
|
||||
pill = by_logic.get(code) or {}
|
||||
line = {
|
||||
"로직": code,
|
||||
"알약": pill.get("키"),
|
||||
"분모": pill.get("단위"),
|
||||
"배": pill.get("배") or 1,
|
||||
}
|
||||
try:
|
||||
logic = whole.logic(code)
|
||||
auto = {k: v for k, v in m01.mau.values(whole, logic).items() if v is not None}
|
||||
got = mf.run(whole, code, {**auto, **m01._dec(one.get("입력값") or {})})
|
||||
except (mf.FormulaError, ArithmeticError, KeyError, TypeError, ValueError) as e:
|
||||
lines.append({**line, "기준": None, "까닭": str(e) or type(e).__name__})
|
||||
continue
|
||||
if "결과" in got: # 돈 아닌 로직 — 반영 없음
|
||||
lines.append({**line, "결과": got["결과"], "기준": None, "까닭": None})
|
||||
continue
|
||||
lines.append({**line, "기준": {k: got[k] for k in (*COSTS, "계")}, "까닭": None})
|
||||
mats = []
|
||||
for one in doc.get("자재") or []:
|
||||
try:
|
||||
price, _ = mm.element(whole, one["코드"], {}, one.get("단위") or None)
|
||||
except mf.FormulaError as e:
|
||||
price, why = None, str(e)
|
||||
else:
|
||||
why = None if price is not None else "단가 없음"
|
||||
mats.append(
|
||||
{"코드": one["코드"], "알약": material_key(one["코드"]), "기준단가": price, "까닭": why}
|
||||
)
|
||||
have = _area_of(doc.get("열")) if given is None else given
|
||||
return settle(_json({"줄": lines, "자재": mats}), doc, have)
|
||||
|
||||
|
||||
def _json(value: Any) -> Any:
|
||||
"""Decimal → JSON 수(정수면 int)."""
|
||||
if isinstance(value, Decimal):
|
||||
return int(value) if value == value.to_integral_value() else float(value)
|
||||
if isinstance(value, list):
|
||||
return [_json(v) for v in value]
|
||||
if isinstance(value, dict):
|
||||
return {k: _json(v) for k, v in value.items()}
|
||||
return value
|
||||
|
||||
|
||||
def server(doc: Any) -> dict[str, Any]:
|
||||
"""[저장] · 복사 때 서버 정본 — 정리 + 지금 면적 값으로 `계산값`(브라우저 값 버림)."""
|
||||
got = clean(doc)
|
||||
return {**got, "계산값": calc(got)}
|
||||
@@ -0,0 +1,64 @@
|
||||
"""M02 일위대가 계산 · 알약 길(PLAN 39-1a · 설계_정함 1장) — `/api/m02/layers/{층}/labor/{열}/…`.
|
||||
|
||||
문서 읽기 · 쓰기는 양식 길(`GET/PUT /api/m02/layers/{층}/templates/labor/{열}`) 그대로 ·
|
||||
여기는 저장하지 않는 셈만. 층 권한 = `Router_Items._root`(읽기 권한 · `M02_Layer_Access` 한 벌).
|
||||
⚠ 등록은 `main.py`(로그인만).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from pydantic import BaseModel
|
||||
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root
|
||||
|
||||
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Labor"])
|
||||
|
||||
|
||||
class CalcBody(BaseModel):
|
||||
"""`doc` = 저장 전 화면 문서(없으면 저장본) · `수량` = {알약 키: 값}(없으면 저장된 면적산출)."""
|
||||
|
||||
doc: dict[str, Any] | None = None
|
||||
수량: dict[str, Any] | None = None
|
||||
|
||||
|
||||
def _doc(column: str, sent: dict[str, Any] | None) -> dict[str, Any]:
|
||||
got = sent if sent is not None else store.read("labor", column)["문서"]
|
||||
return labor.clean({**got, "열": column})
|
||||
|
||||
|
||||
def _calc(column: str, body: CalcBody) -> dict[str, Any]:
|
||||
doc = _doc(column, body.doc)
|
||||
return {**labor.calc(doc, body.수량), "알약": labor.pills(doc)}
|
||||
|
||||
|
||||
def _pills(column: str) -> dict[str, Any]:
|
||||
return {"열": column, "알약": labor.pills(_doc(column, None))}
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/labor/{column}/calc")
|
||||
def calc_labor(
|
||||
layer: Layer,
|
||||
column: str,
|
||||
body: CalcBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
) -> dict:
|
||||
"""줄마다 기준 · 반영 · 합 + 알약(저장 안 함 · 화면은 최신 응답만)."""
|
||||
return _call(_root(session, layer, owner), _calc, column, body)
|
||||
|
||||
|
||||
@router.get("/layers/{layer}/labor/{column}/pills")
|
||||
def labor_pills(
|
||||
layer: Layer,
|
||||
column: str,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
) -> dict:
|
||||
"""면적산출 알약 — 로직 물량 알약 「이름|단위」 + 자재 알약 「자재|MT키」(저장본)."""
|
||||
return _call(_root(session, layer, owner), _pills, column)
|
||||
@@ -189,8 +189,7 @@ def copy_item(
|
||||
have = store.read(kind, new_id)["문서"]
|
||||
body = {k: v for k, v in got.items() if k != "계산값"}
|
||||
body = {**body, "열": new_id, number: have.get(number)}
|
||||
if kind in store.SHEETS:
|
||||
body = store._server_values(body)
|
||||
body = store._server(kind, body)
|
||||
with store._LOCK:
|
||||
atomic_write_json(store._path(kind, new_id), body)
|
||||
ss = next(r for r in store.read_combos()["줄"] if r.get("열") == new_id)
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
/* M02 일위대가 수량 · 반영 · 합(PLAN 39-1a · 설계_정함 1장) — 면적 칸 값이 바뀌면 화면이 바로 곱함.
|
||||
*
|
||||
* 짝(CLAUDE.md 5장 ①): `M02_Labor_Doc.py` `settle` 과 같은 규칙 —
|
||||
* 거울 시험 `resources/tester/test_m02_labor_calc_mirror.py`.
|
||||
* 기준(결과단위 그대로)은 서버 calc 길이 셈 · 여기는 받은 기준에
|
||||
* 수량(손이 칸보다 앞섬 · 칸 = 알약 키 값) · 반영 = 기준 × 수량 ÷ 배 · 자재 = 재료비만. */
|
||||
|
||||
export const MONEY_KEYS = ["노무비", "재료비", "경비", "계"] as const;
|
||||
export type Money = Record<(typeof MONEY_KEYS)[number], number>;
|
||||
export type QtySource = "손" | "칸" | "없음";
|
||||
/** 문서의 수량 칸 — null = 면적산출 알약 · {손} = 손 입력 */
|
||||
export type Qty = { 손: number } | null;
|
||||
|
||||
export interface CalcLine {
|
||||
로직: string;
|
||||
알약?: string | null;
|
||||
분모?: string | null;
|
||||
배: number;
|
||||
기준: Money | null;
|
||||
수량?: number | null;
|
||||
수량출처?: QtySource;
|
||||
반영?: Money | null;
|
||||
까닭?: string | null;
|
||||
결과?: unknown;
|
||||
}
|
||||
|
||||
export interface CalcMaterial {
|
||||
코드: string;
|
||||
알약?: string | null;
|
||||
기준단가: number | null;
|
||||
수량?: number | null;
|
||||
수량출처?: QtySource;
|
||||
반영?: number | null;
|
||||
까닭?: string | null;
|
||||
}
|
||||
|
||||
export interface LaborCalc {
|
||||
줄: CalcLine[];
|
||||
자재: CalcMaterial[];
|
||||
기준합?: Money;
|
||||
반영합?: Money;
|
||||
}
|
||||
|
||||
/** 수량만 보는 문서 조각 — 담은 로직 · 자재의 손 값 */
|
||||
export interface LaborQtyDoc {
|
||||
담은로직?: { 로직: string; 수량?: Qty }[];
|
||||
자재?: { 코드: string; 수량?: Qty }[];
|
||||
}
|
||||
|
||||
function num(raw: unknown): number | null {
|
||||
if (raw === null || raw === undefined || typeof raw === "boolean") return null;
|
||||
const n = Number(String(raw).replace(/,/g, "").trim());
|
||||
return String(raw).trim() !== "" && Number.isFinite(n) ? n : null;
|
||||
}
|
||||
|
||||
function zero(): Money {
|
||||
return { 노무비: 0, 재료비: 0, 경비: 0, 계: 0 };
|
||||
}
|
||||
|
||||
function pick(
|
||||
hand: Qty | undefined,
|
||||
key: string | null | undefined,
|
||||
given: Record<string, number>,
|
||||
): [number | null, QtySource] {
|
||||
const own = hand ? num(hand.손) : null;
|
||||
if (own !== null) return [own, "손"];
|
||||
if (key && key in given) return [given[key], "칸"];
|
||||
return [null, "없음"];
|
||||
}
|
||||
|
||||
/** 반영 = 기준 × 수량 ÷ 배 — 수량이 없으면 null */
|
||||
export function reflect(base: Money, qty: number | null, times: number): Money | null {
|
||||
if (qty === null) return null;
|
||||
const out = zero();
|
||||
for (const k of MONEY_KEYS) out[k] = (base[k] * qty) / times;
|
||||
return out;
|
||||
}
|
||||
|
||||
/** 기준이 선 계산 답 + 문서 손 값 + 알약 값(`{키: 값}`) → 수량 · 반영 · 합을 새로 채운 답 */
|
||||
export function settle(
|
||||
result: LaborCalc,
|
||||
doc: LaborQtyDoc,
|
||||
given: Record<string, unknown>,
|
||||
): LaborCalc {
|
||||
const have: Record<string, number> = {};
|
||||
for (const [k, raw] of Object.entries(given)) {
|
||||
const v = num(raw);
|
||||
if (v !== null) have[k] = v;
|
||||
}
|
||||
const hands = new Map((doc.담은로직 ?? []).map((one) => [one.로직, one.수량 ?? null]));
|
||||
const mhands = new Map((doc.자재 ?? []).map((one) => [one.코드, one.수량 ?? null]));
|
||||
const base = zero();
|
||||
const done = zero();
|
||||
const add = (sum: Money, m: Money | null): void => {
|
||||
if (m) for (const k of MONEY_KEYS) sum[k] += m[k];
|
||||
};
|
||||
const 줄 = result.줄.map((line) => {
|
||||
const [qty, source] = pick(hands.get(line.로직), line.알약, have);
|
||||
const own = line.기준 ? reflect(line.기준, qty, num(line.배) || 1) : null;
|
||||
add(base, line.기준);
|
||||
add(done, own);
|
||||
return { ...line, 수량: qty, 수량출처: source, 반영: own };
|
||||
});
|
||||
const 자재 = result.자재.map((one) => {
|
||||
const [qty, source] = pick(mhands.get(one.코드), one.알약, have);
|
||||
const price = num(one.기준단가);
|
||||
const cost = price !== null && qty !== null ? price * qty : null;
|
||||
if (price !== null) add(base, { ...zero(), 재료비: price, 계: price });
|
||||
if (cost !== null) add(done, { ...zero(), 재료비: cost, 계: cost });
|
||||
return { ...one, 수량: qty, 수량출처: source, 반영: cost };
|
||||
});
|
||||
return { 줄, 자재, 기준합: base, 반영합: done };
|
||||
}
|
||||
@@ -65,12 +65,13 @@ IN_USE = {
|
||||
# (종류, 문서 번호 칸, 머리 글자, 시트 이름) — 시트 이름이 None 이면 구조물 도면
|
||||
PARTS = (
|
||||
("structure", "도번", "SD", None),
|
||||
("labor", "일위대가번", "SU", None), # 일위대가 — `M02_Labor_Doc`(39장)
|
||||
("area", "면적번", "SA", "면적산출"),
|
||||
("material", "재료번", "SM", "재료산출"),
|
||||
)
|
||||
_KEY = {kind: key for kind, key, _, _ in PARTS}
|
||||
SHEETS = ("area", "material") # 통합문서 종류 — [저장] 때 서버가 계산값을 새로 적음
|
||||
_CODE = re.compile(r"^S[DAM](\d{8}|-\d{6})$")
|
||||
_CODE = re.compile(r"^S[DAMU](\d{8}|-\d{6})$")
|
||||
_OLD_CODE = re.compile(r"^S[DCA](\d{6})$") # PLAN 12장 6자리 — 끝에 00 을 붙여 읽음
|
||||
_BAD_NAME = re.compile(r'[\\/:*?"<>|\x00-\x1f]|\.\.')
|
||||
# 도각 없는 빈 CAD 문서의 기본 도면층 — 없으면 B07 CAD 가 못 엶("Cannot read properties
|
||||
@@ -155,7 +156,8 @@ def write(kind: str, name: str, version: str, doc: Any, screen: bool = False) ->
|
||||
구조물집계표를 저장하면 — 새 구조물 열의 빈 구조물 도면 · 면적산출 · 재료산출을 번호와 같이
|
||||
만들고 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 지움(잠금 밖에서 · 안에서 부르면 죽음).
|
||||
통합문서(area · material)는 서버가 같은 TS 엔진을 Node 로 돌려 `계산값` 을 새로 적음
|
||||
(브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘.
|
||||
(브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘 · 일위대가(labor)는
|
||||
`M02_Labor_Doc.server` 가 정리 · `계산값` 을 새로 적음(면적산출 저장 때 그 열 일위대가도).
|
||||
번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음).
|
||||
표 열의 `본뜬열`(분류 더하기로 복사한 새 열)은 적지 않음 — 집계표면 아직 파일이 없는 새 열이
|
||||
원본 열의 일위대가 · 자재조합 키와 세 파일 내용을 받음(새 번호 · 그 뒤로는 열마다 따로).
|
||||
@@ -166,8 +168,7 @@ def write(kind: str, name: str, version: str, doc: Any, screen: bool = False) ->
|
||||
origins = _take_origins(doc) if kind == "table" else {}
|
||||
if kind == "table" and name == STRUCTURE_TABLE:
|
||||
doc = tree.normalize_table(doc) # 경로 · 머리 줄 수 · 빈 폴더(표 저장 · 나무 고침 한 줄기)
|
||||
if kind in SHEETS:
|
||||
doc = _server_values(doc)
|
||||
doc = _server(kind, doc)
|
||||
with _LOCK:
|
||||
have = version_of(path.read_bytes()) if path.is_file() else ""
|
||||
if have != (version or ""):
|
||||
@@ -179,6 +180,8 @@ def write(kind: str, name: str, version: str, doc: Any, screen: bool = False) ->
|
||||
doc = {**doc, _KEY[kind]: number} if number else doc
|
||||
atomic_write_json(path, doc)
|
||||
info = _info(kind, path)
|
||||
if kind == "area":
|
||||
_refresh_labor(name) # 면적 칸 값이 바뀌면 일위대가 계산값(목록 합계)도
|
||||
if kind == "table" and name == STRUCTURE_TABLE:
|
||||
for column, source in origins.items(): # 빈 파일 채우기 앞 — 원본 내용으로 만듦
|
||||
for part in _KEY:
|
||||
@@ -282,6 +285,17 @@ def _retired() -> list[str]:
|
||||
def _blank(kind: str, column: str) -> dict[str, Any]:
|
||||
"""빈 문서(번호는 부르는 쪽이 붙임) — 구조물 도면 = 도각 없음 · 기본 도면층 하나 /
|
||||
면적산출 · 재료산출 = 진짜 빈 시트 하나(식 없어 `계산값` 없음 · 첫 [저장] 때 서버가 적음)."""
|
||||
if kind == "labor":
|
||||
return {
|
||||
"종류": "일위대가",
|
||||
"판": 1,
|
||||
"열": column,
|
||||
"단위": None,
|
||||
"본뜬": None,
|
||||
"담은로직": [],
|
||||
"자재": [],
|
||||
"계산값": {},
|
||||
}
|
||||
if kind == "structure":
|
||||
return {
|
||||
"양식": "구조물도면",
|
||||
@@ -311,9 +325,7 @@ def _ensure(kind: str, column: str, source: str | None = None) -> bool:
|
||||
base = _blank(kind, column)
|
||||
if source and _path(kind, source).is_file():
|
||||
got = json.loads(_path(kind, source).read_bytes())
|
||||
base = {**{k: v for k, v in got.items() if k != "계산값"}, "열": column}
|
||||
if kind in SHEETS:
|
||||
base = _server_values(base)
|
||||
base = _server(kind, {**{k: v for k, v in got.items() if k != "계산값"}, "열": column})
|
||||
with _LOCK:
|
||||
if path.is_file():
|
||||
return False
|
||||
@@ -343,13 +355,13 @@ def _take_origins(doc: Any) -> dict[str, str]:
|
||||
|
||||
def create_structure(column: str) -> dict[str, Any]:
|
||||
"""구조물 열 하나의 구조물 도면 새로 — 도번 SD + 새 일련(`-` + 6자리) · 이미 있으면 409.
|
||||
면적산출 · 재료산출 파일이 없으면 빈 통합문서도 같이 만듦(같은 뒷자리)."""
|
||||
일위대가 · 면적산출 · 재료산출 파일이 없으면 빈 문서도 같이 만듦(같은 뒷자리)."""
|
||||
if column not in _column_ids():
|
||||
raise StoreError(404, f"{STRUCTURE_TABLE}에 없는 구조물 열 「{column}」")
|
||||
if not _ensure("structure", column):
|
||||
raise StoreError(409, f"이미 있는 구조물 도면 「{column}」")
|
||||
for kind in SHEETS:
|
||||
_ensure(kind, column)
|
||||
for kind in _KEY:
|
||||
_ensure(kind, column) # 도면은 위에서 만듦 · 있는 것은 그대로
|
||||
return read("structure", column)
|
||||
|
||||
|
||||
@@ -360,8 +372,7 @@ def copy_from(kind: str, column: str, source: str) -> dict[str, Any]:
|
||||
raise StoreError(404, f"없는 종류 「{kind}」")
|
||||
target = read(kind, column)["문서"]
|
||||
doc = {**read(kind, source)["문서"], **{k: target.get(k) for k in ("열", _KEY[kind])}}
|
||||
if kind in SHEETS:
|
||||
doc = _server_values({k: v for k, v in doc.items() if k != "계산값"})
|
||||
doc = _server(kind, {k: v for k, v in doc.items() if k != "계산값"})
|
||||
with _LOCK:
|
||||
atomic_write_json(_path(kind, column), doc)
|
||||
return _info(kind, _path(kind, column))
|
||||
@@ -457,6 +468,30 @@ def renumber() -> dict[str, list[str]]:
|
||||
return {"옮김": moved, "지움": gone, "바꿈": changed, "새로": made}
|
||||
|
||||
|
||||
def _server(kind: str, doc: Any) -> Any:
|
||||
"""서버가 적는 값 — 통합문서 계산값(5장 ②) · 일위대가 정리 · 계산값(`M02_Labor_Doc`)."""
|
||||
if kind in SHEETS:
|
||||
return _server_values(doc)
|
||||
if kind == "labor":
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
return labor.server(doc)
|
||||
return doc
|
||||
|
||||
|
||||
def _refresh_labor(column: str) -> None:
|
||||
"""그 열 일위대가 `계산값` 을 지금 면적 값으로 다시 적음 — 문서가 틀어졌으면 그대로 둠."""
|
||||
path = _path("labor", column)
|
||||
if not path.is_file():
|
||||
return
|
||||
try:
|
||||
doc = _server("labor", json.loads(path.read_bytes()))
|
||||
except StoreError:
|
||||
return
|
||||
with _LOCK:
|
||||
atomic_write_json(path, doc)
|
||||
|
||||
|
||||
def _server_values(doc: Any) -> dict[str, Any]:
|
||||
try:
|
||||
return spreadsheet.with_server_values(doc)
|
||||
|
||||
@@ -27,7 +27,8 @@ from config import config_system
|
||||
|
||||
LAYERS = ("system", "company", "personal", "project")
|
||||
# area = 면적산출 · material = 재료산출 — 통합문서(구조물집계표 열마다 · `A00_Common/spreadsheet/`)
|
||||
KINDS = ("table", "drawing", "structure", "area", "material")
|
||||
# labor = 일위대가(구조물 열마다 · `M02_Labor_Doc`)
|
||||
KINDS = ("table", "drawing", "structure", "labor", "area", "material")
|
||||
TEMPLATES_DIRNAME = "templates"
|
||||
INITIAL_DIRNAME = "_initial"
|
||||
MANIFEST_NAME = "manifest.json"
|
||||
@@ -168,6 +169,7 @@ _SKELETON = {
|
||||
"table": ("열",),
|
||||
"drawing": ("entities",),
|
||||
"structure": ("도면.entities",),
|
||||
"labor": ("담은로직",),
|
||||
"area": ("시트",),
|
||||
"material": ("시트",),
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user