Merge remote-tracking branch 'origin/dev' into sub_laptop_1

This commit is contained in:
2026-11-18 07:20:06 +09:00
93 changed files with 1579 additions and 2504 deletions
@@ -0,0 +1,175 @@
# -*- coding: utf-8 -*-
"""마스터 바탕 기반 — 요소 · 표 색인(`Master`) · 표 줄 찾기(`find`) · 오류 · 비목 이름 · 재료 고르기 이음.
옛 엔진(`master_formula` — 식 읽기 · 셈 · 끝수)과 새 계산기(`master_doc_*`) · 불러오기 · 서고가 같이 씀.
`master_formula` 는 이 이름들을 그대로 다시 내보냄(855-E 2-E4 준비 — 엔진 몸을 지워도 이 모듈은 남음).
"""
from __future__ import annotations
from decimal import Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
# ── 표 줄 찾기 ────────────────────────────────────────────────────────
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
# 품셈재료 단가 · 고르기 — 서로 부르는 모듈이라 끝에서 읽음
from master_material import ( # noqa: E402, F401
LINKED,
PICK_KEYS,
REGION,
SLOTS,
TARIFF,
candidates,
check_pick,
check_unit,
static,
cond_text,
element,
pick,
)
import master_pick as mp # noqa: E402 — 검색어 · 고름 · 단위
@@ -11,7 +11,7 @@
from __future__ import annotations
import master_doc as md
import master_formula as mf # 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_base as mf # 바탕 기반 · 마스터 색인(`Master.get`) — 없는 키 = FormulaError
import master_keys as mk
import master_material as mm # 재료 고르기 조건 검사(`check_pick`)
@@ -20,7 +20,7 @@ from pathlib import Path
import master_doc as md
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
import master_machine_crew as mcrew
import master_material as mm
import master_pick as mp
@@ -13,7 +13,7 @@
from __future__ import annotations
import master_doc_calc as mc
import master_formula as mf
import master_base as mf # 바탕 기반(색인 · 오류)
class Rec:
+16 -143
View File
@@ -3,6 +3,7 @@
식은 틀 7장 범위만 읽음 — eval 쓰지 않음. 수는 Decimal(끝수 사사오입이 흔들리지 않게).
`check_master.py` 가 부름.
바탕 기반(색인 `Master` · 표 찾기 `find` · 오류 · 비목 이름 · 재료 고르기) = `master_base` — 여기서 그대로 다시 내보냄.
"""
from __future__ import annotations
@@ -12,15 +13,22 @@ import re
from decimal import ROUND_DOWN, ROUND_HALF_UP, ROUND_UP, Decimal
import master_keys as mk
import master_machine_crew as mcrew # 기계 인력 · 잡품 줄 → 식이 읽는 칸(842-3)
from master_base import ( # noqa: F401 — 바탕 기반(855-E 2-E4 준비) · 이름은 여기서 그대로
BUNDLE,
COST_ITEMS,
GROUPS,
TABLE_GROUPS,
TABLE_IDS,
EmptyInput,
FormulaError,
Master,
NoRow,
_match,
_name,
_plain,
find,
)
# 식이 부르는 요소 그룹 — 일위대가 조합(`master_combo`)은 식에 안 들어와 여기 두지 않음
# (조합은 `/rows`·`/files` 같은 요소 길이 아니라 제 길 `/combos`·`/combo` 로만 다룸)
GROUPS = ("인력", "재료", "기계", "소요량", "계수", "환율", "요율", "로직")
TABLE_GROUPS = ("소요량", "계수")
TABLE_IDS = tuple(t for t in mk.IDS if mk.GROUP_OF[t] in TABLE_GROUPS)
COST_ITEMS = ("노무비", "재료비", "경비")
BUNDLE = (*COST_ITEMS, "계")
FUNCS = ("만약", "올림", "버림", "반올림", "최소", "최대")
_NAME = re.compile(r"[\w가-힣]+")
_NUMBER = re.compile(r"\d+(?:\.\d+)?")
@@ -38,18 +46,6 @@ def inputs_of(row: dict) -> list[dict]:
raise FormulaError(FLOW_GONE)
class FormulaError(ValueError):
pass
class EmptyInput(FormulaError):
"""값을 안 넣은(null) 입력을 씀 — 그 줄만 비우고 로직은 계속(`run`)."""
class NoRow(EmptyInput):
"""표에서 조건에 맞는 줄이 하나가 아님 — 그 찾기를 쓰는 줄만 비움(값이 비어 있는 입력과 같은 길)."""
class Blank:
"""못 구한 중간값 — 이 값을 쓰는 줄만 까닭과 함께 비움."""
@@ -57,11 +53,6 @@ class Blank:
self.why = why
def _plain(v) -> str:
"""사람이 읽는 값 글 — 파이썬 날글(Decimal('1000') · 따옴표) 없이."""
return format(v.normalize(), "f") if isinstance(v, Decimal) else str(v)
# ── 읽기 ──────────────────────────────────────────────────────────────
class _Parser:
def __init__(self, text: str):
@@ -257,70 +248,6 @@ def walk(node):
yield from walk(item)
# ── 마스터 모음 ────────────────────────────────────────────────────────
class Master:
"""요소·표·로직 찾기 — `files` = {파일 이름: 읽은 JSON}(수는 Decimal).
`ref` = 키(「LB000123」) · 「ID:원문번호」(`{이름}` 을 끼운 원문번호 · 끼운 값이 키여도 됨)."""
def __init__(self, files: dict[str, dict]):
self.index: dict[str, dict[str, dict]] = {} # 테이블ID → {키: 줄}
self.numbers: dict[str, dict[str, dict]] = {} # 테이블ID → {원문번호: 줄}
self.twice: set[tuple[str, str]] = set() # 한 절에 여럿 — 번호로 못 부름
for data in files.values():
rows = data.get("표") if data.get("그룹") in TABLE_GROUPS else data.get("줄")
for row in rows or []:
key = str(row.get("키"))
self.index.setdefault(key[:2], {}).setdefault(key, row)
if row.get("원문번호"):
number = str(row["원문번호"])
slot = self.numbers.setdefault(key[:2], {})
if number in slot:
self.twice.add((key[:2], number))
slot.setdefault(number, row)
mp.EQ.set(self) # 기계 입력이 목록 밖 원문 분류번호도 받게
def get(self, ref: str) -> dict:
tid, _, number = ref.partition(":")
if number and mk.KEY.fullmatch(number) and number[:2] == tid:
row = self.index.get(tid, {}).get(number) # 「ID:키」 — 고르기 값이 키인 자리
elif number:
if (tid, number) in self.twice:
raise FormulaError(f"원문번호 겹침 「{ref}」 — 키로 적을 것")
row = self.numbers.get(tid, {}).get(number)
else:
row = self.index.get(ref[:2], {}).get(ref)
if row is None:
raise FormulaError(f"없는 요소 「{ref}」")
return row
def label(self, ref) -> str:
"""알림 글 — 키 옆에 이름 · 고르기 조건은 조건 글."""
if isinstance(ref, dict):
return "재료 고르기 " + " · ".join(str(v) for v in ref.values() if v)
try:
row = self.get(ref)
except FormulaError:
return ref
return f"{row.get('키')} {row.get('이름') or row.get('원문번호')}"
def value(self, ref: str):
"""요소 값 · 출처 글 — 준용(관리자가 고른 키)이 있으면 그 요소 값 · 없으면 제 값."""
row = self.get(ref)
alias = row.get("준용")
if alias not in (None, ""):
target = self.get(str(alias))
name = target.get("이름") or alias
if row.get("상태") == "추정": # 값을 이미 준용 직종에서 채워 둠
return row.get("값"), f"추정(준용: {name})"
return target.get("값"), f"준용: {name}"
return mcrew.view(row.get("값")) if str(row.get("키"))[:2] == "EQ" else row.get("값"), None
def logic(self, ref: str) -> dict:
if mk.GROUP_OF.get(mk.id_of(ref)) != "로직":
raise FormulaError(f"로직 아님 「{ref}」")
return self.get(ref)
def fill(template: str, env: dict) -> str:
def one(m):
if m.group(1) not in env:
@@ -338,60 +265,6 @@ def _round(x: Decimal, places, mode) -> Decimal:
return x.quantize(Decimal(1).scaleb(-int(places)), rounding=mode)
def _match(table: dict, row: dict, cond: str, want) -> bool:
if cond not in row: # 빈 조건 칸은 무엇이든 맞음
return True
have = row[cond]
if table.get("조건", {}).get(cond) == "범위":
low, high = have
rule, *more = table.get("범위규칙", "초과·이하").split(" · ")
rule = rule.split(" (")[0] # 「이상·미만 (원문 …)」 — 괄호 설명은 뺌
if rule == "이상·이하":
return (low is None or want >= low) and (high is None or want <= high)
if rule == "초과·이하":
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·미만":
# 「마지막 칸(80~100)은 이하 포함」 — 가장 윗줄만 위 끝 포함
top = max(r[cond][1] for r in table["줄"] if r.get(cond) and r[cond][1] is not None)
closed = any("이하 포함" in x for x in more) and high == top
return (low is None or want >= low) and (
high is None or want < high or (closed and want == high)
)
if rule == "이하": # 칸마다 위 끝만 — 맞는 줄 가운데 위 끝이 가장 작은 줄(find)
return (low is None or want > low) and (high is None or want <= high)
if rule == "이상·이하": # 양 끝 포함 — 이웃 칸 끝이 겹치면 위 끝이 가장 작은 줄(find)
return (low is None or want >= low) and (high is None or want <= high)
raise FormulaError(f"모르는 범위규칙 「{table.get('범위규칙')}」")
return have == want
def _name(row: dict) -> str:
return f"{row.get('키')} {row.get('원문번호')}"
def find(table: dict, conds: dict, want: str | None = None) -> dict:
for cond in conds:
if cond not in table.get("조건", {}):
raise FormulaError(f"「{_name(table)}」 에 없는 조건 「{cond}」")
hits = [row for row in table["줄"] if all(_match(table, row, c, v) for c, v in conds.items())]
if len(hits) > 1 and table.get("범위규칙", "").split(" · ")[0] in ("이하", "이상·이하"):
for c in conds:
ups = [r[c][1] for r in hits if table["조건"].get(c) == "범위" and r.get(c)]
if ups and None not in ups:
hits = [r for r in hits if not r.get(c) or r[c][1] == min(ups)]
if len(hits) > 1 and want: # 여러 줄이면 찾는 값 칸이 있는 줄만
hits = [row for row in hits if want in row]
if len(hits) != 1:
where = f"표 {table.get('키')}({table.get('원문번호')})"
what = " · ".join(f"{c} {_plain(v)}" for c, v in conds.items())
raise NoRow(
f"{where}에 {what} 인 줄이 없음"
if not hits
else f"{where}에 {what} 인 줄이 {len(hits)}개"
)
return hits[0]
def evaluate(node, env: dict, master: Master, depth: int = 0):
kind = node[0]
if kind in ("num", "str"):
@@ -284,5 +284,5 @@ def element(
return min(offers, key=lambda x: x[0]) if offers else (None, None)
import master_formula as mf # noqa: E402 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_pick as mp # noqa: E402 — 검색어 찾기
+1 -1
View File
@@ -230,4 +230,4 @@ def check_warn(master, where: str, cond: dict, unit: str | None) -> list[str]:
return []
import master_formula as mf # noqa: E402, F401 — 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
import master_base as mf # noqa: E402, F401 — 바탕 기반 · 서로 부름 · 이 모듈 이름이 다 선 뒤에 읽음
+80 -10
View File
@@ -40,8 +40,14 @@ class Fake {
get firstChild() {
return this.children[0] ?? null;
}
addEventListener() {}
addEventListener(t, f) {
((this.on ??= {})[t] ??= []).push(f);
}
removeEventListener() {}
/** 사건 일으킴(⑥ 머리 칸 change) */
fire(t) {
for (const f of this.on?.[t] ?? []) f({ target: this });
}
setAttribute(k, v) {
this.attrs[k] = v;
if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v;
@@ -87,15 +93,18 @@ const button = (o = {}) => box("button", { "data-button": o.label ?? "" });
const input = (o = {}) => {
const i = box("input");
i.value = o.value ?? "";
return { root: box("label", { "data-input": o.label ?? "" }, ""), input: i, setError() {} };
const root = box("label", { "data-input": o.label ?? "" }, "");
root.append(i); // ⑥ 칸이 머리 나무에 달림
return { root, input: i, setError() {} };
};
const modals = []; // 열린 모달 — 제목 · 몸
const toasts = []; // 알림 글(856-3 M01 로직 줄 안내)
const ui = {
ui_template_elements: {
el,
createButton: button,
createInputField: input,
showToast() {},
showToast: (text, kind) => toasts.push([kind, text]),
showConfirmDialog: async () => true,
},
ui_template_button: { createButton: button },
@@ -112,7 +121,7 @@ const ui = {
const head = box("div");
const close = () => {};
o.mount?.(body, close, head);
modals.push({ title: o.title, body, head, actions: o.actions ?? [] });
modals.push({ title: o.title, body, head, actions: o.actions ?? [], shut: o.beforeClose });
return { close };
},
askConfirm: async () => true,
@@ -158,6 +167,7 @@ const screen = {
// 서버 부름 — 길 · 몸을 적고 견본 답
const calls = [];
const files = { reads: 0, saves: 0 }; // 층 파일 읽기 · 저장 수
const api = {
call: async (p, init) => {
calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null });
@@ -166,8 +176,11 @@ const api = {
return { items: [{ ref: "X1", 이름: "견본", 단위: "EA", 값: 1 }] }; // 찾아 넣기(⑤)
return {};
},
readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }),
saveTemplate: async () => ({}),
readTemplate: async (_l, _k, key) => (
files.reads++,
{ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }
),
saveTemplate: async () => (files.saves++, {}),
getActiveLayer: () => "system",
getActiveOwner: () => null,
};
@@ -193,7 +206,10 @@ const stubs = {
tabOf: () => ({}),
},
M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] },
M02_MasterTemplete_Sangeun_Unit: { buildUnitSwap: () => null, baseUnitOf: () => "" },
M02_MasterTemplete_Sangeun_Unit: {
buildUnitSwap: () => (swaps.n++, box("div", { "data-swap": "" })), // ⑥ 환산 다시 그린 수
baseUnitOf: () => "",
},
M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] },
M02_Labor_Values_Model: {
valueLine: () => ({ text: "", empty: 0 }),
@@ -219,6 +235,7 @@ const stubs = {
},
};
const picked = { rows: 0 };
const swaps = { n: 0 };
const real = new Set([
"M02_MasterTemplete_Sangeun_Detail",
"M02_MasterTemplete_Sangeun_Tabs",
@@ -366,7 +383,7 @@ async function openSk(doc, opt = {}) {
);
out.bands_fail = await bandCase({ doc: null, answer: null, fail: "서버 못 닿음" }, "SK-000004");
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(원본 층 카드) · 프로젝트 사본(856-3 굳힌 SK 문서)
const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts");
const rows = [
{
@@ -377,7 +394,9 @@ async function openSk(doc, opt = {}) {
},
{ 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } },
];
const click = async (calc) => {
const copyDoc = { 키: "SK-000010", 이름: "사본", 단위: "㎡", 수식: { 따로: true, 굳힘: true } };
const asked = [];
const click = async (calc, copy) => {
const res = [];
for (let i = 0; i < rows.length; i++) {
const t = mountLaborTable(
@@ -387,16 +406,21 @@ async function openSk(doc, opt = {}) {
mode: "precombo",
layer: "system",
column: "공통",
readOnly: false,
readOnly: !!calc && !copy, // 셈 주입 카드 = 보기만 · 사본은 표가 열려 있어도 줄 쌓기는 보기만인지 봄
owner: null,
onChanged() {},
...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}),
...(copy
? { skCopy: async (ref) => (asked.push(ref.키), ref.키 === copy.키 ? copy : null) }
: {}),
},
);
await settle();
modals.length = 0;
stacks.length = 0;
calls.length = 0;
toasts.length = 0;
files.reads = files.saves = 0;
grid.onRowClick(i);
await settle();
const m = modals[0];
@@ -405,16 +429,25 @@ async function openSk(doc, opt = {}) {
modal: m ? m.title : null,
skModal: m ? all(m.body, (n) => "laborSk" in n.dataset).length : 0, // 그 SK 문서 모달(806-1)
stack: s ? { shown: shown(s.root), draws: s.draws.map((d) => d.key) } : null,
memory: s ? s.draws.map((d) => d.memory) : [],
admin: s ? s.opt.admin : null, // 고침 칸(편집) 열림
save: m ? all(m.head, (n) => n.dataset.button === "Save").length : 0, // [저장] 단추
files: { ...files },
toasts: toasts.map((x) => x[0]),
body: m ? all(m.body, (n) => "skCover" in n.dataset && shown(n)).length : 0,
banners: m ? all(m.body, (n) => "banner" in n.dataset).map((n) => n.dataset.banner) : [],
calc: skCalls().length,
});
for (const one of modals) await one.shut?.(); // 닫기(같은 SK 다시 열 수 있게)
t.destroy?.();
}
return res;
};
out.labor = await click(false);
out.labor_inject = await click(true);
out.labor_copy = await click(true, copyDoc);
out.labor_copy_asked = asked.slice();
out.labor_copy_none = await click(true, { ...copyDoc, 키: "SK-999999" });
// ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기
const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts");
@@ -460,6 +493,43 @@ async function openSk(doc, opt = {}) {
};
}
globalThis.fetch = fetch0;
// ⑥ 머리 칸 고침(856-G) — 이름 change 뒤 머리 칸 그대로(Tab 으로 옮긴 단위 칸 = 같은 칸 · 초점 유지) ·
// 단위 change = 환산만 새로 · 문서 · 고침 알림
{
const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts");
const host = box("div");
let dirty = false;
const doc = { 키: "SK-000011", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } };
const h = mountSangeunDetail(host, doc, {
layer: "system",
owner: null,
readOnly: false,
mode: "page",
onChanged: (d) => (dirty = d),
});
await settle();
const fields = () => all(host, (n) => n.dataset.sk === "이름" || n.dataset.sk === "단위");
const before = fields();
const [name, unit] = before;
const same = () => fields().length === 2 && fields().every((n, i) => n === before[i]);
let n0 = swaps.n;
name.value = " 고친 이름 ";
name.fire("change");
const afterName = { same: same(), swaps: swaps.n - n0, dirty };
n0 = swaps.n;
unit.value = "m2";
unit.fire("change");
const afterUnit = { same: same(), swaps: swaps.n - n0, shown: all(host, (n) => "swap" in n.dataset).length }; // prettier-ignore
const got = h.getDoc();
out.head = {
order: before.map((n) => n.dataset.sk),
afterName,
afterUnit,
doc: [got.이름, got.단위],
};
h.destroy();
}
console.log(JSON.stringify(out));
})().catch((e) => {
console.error(e.stack || String(e));
@@ -34,20 +34,6 @@ def _save(folder, doc):
return key, json.loads((folder / "precombo" / f"{key}.json").read_bytes())
def test_화면_서고_모드도_자재목록_세_칸_자재_저장(world): # noqa: F811
"""723-2 — 서고 = 일위대가표만(`Labor_Table`) · [항목 추가] 머리(736-1 · 자재 추가 단추 걷음) · 세 칸 = 줄 모달(`Labor_RowModal`)."""
read = lambda name: open(os.path.join(SRC, name), encoding="utf-8").read() # noqa: E731
detail, lib = (
read("M02_MasterTemplete_Labor_Detail.ts"),
read("M02_MasterTemplete_Labor_Table.ts"),
)
modal = read("M02_MasterTemplete_Labor_RowModal.ts")
assert "return mountLaborTable(host, doc, opt);" in detail # 806-1 — 조합도 같은 부품
assert 'className: "ui-btn-group", children: [addLogic]' in lib and "addMat" not in lib
assert "setLogicMark(row, at, key, v);" in modal and "setMark(o.mat, key, v);" in modal
assert "delete out.자재" not in lib and "delete out.열" in lib
def test_저장_왕복_고름_자재표시_자재_남음(world): # noqa: F811
line = {"로직": NET, "고름": {"4": NET_ITEM}, "자재표시": {"3": {"자재구분": "관급"}}}
mats = [
+7 -10
View File
@@ -5,7 +5,7 @@
자동값(master_auto 「나누는 자리 = 1」)이 1 이라 838 ㎥(자료 · 기본값 몫 — 223 보고).
② 별도계상 — 로직 자재(`자재표시` · 빈 칸 = 기본 별도계상) = 기준에서 빠지고 `줄` 에서 지움 · `재료` 는
남음 · 사용자 자재 = 합에서 뺌(짝 TS `settle`) · 사전조합 안 줄 · 사본 셈 같은 길.
③ 원문 — 로직 출처 + 호표 · 입력 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
③ 원문 — 문서 출처 + 금액 줄 · 변수 출처 가운데 같은 책 절 번호(「산림품셈 12-1-2 · 12-1-3」).
"""
import os
@@ -13,6 +13,7 @@ from decimal import Decimal
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M01_MasterData import M01_MasterData_Store_Make as make
from M02_MasterTemplete import M02_Labor_Doc as labor
@@ -130,16 +131,9 @@ def test_사전조합_안_줄도_별도계상_뺌():
assert got["기준"]["계"] == _kept(raw)["계"]
def test_화면_별도계상_바꾸면_다시_셈():
# 806-1 — 조합 · 서고 모두 일위대가표 부품 · 세 칸은 줄 모달(`Labor_RowModal`)
modal = open(os.path.join(SRC, "M02_MasterTemplete_Labor_RowModal.ts"), encoding="utf-8").read()
assert 'o.done(key === "별도계상");' in modal # 사용자 자재 · 로직 자재 모두 별도계상만 다시 셈
assert modal.count('o.done(key === "별도계상");') == 2
# ── ③ 원문 여럿 ──────────────────────────────────────────────────────
def test_원문_출처는_같은_책_절_모두():
src = inputs.sources(_whole().logic(MIX))
src = inputs.sources(m01_doc.docs()[MIX])
assert src == "산림품셈 12-1-2 · 12-1-3"
assert inputs.logic_inputs([MIX])["로직"][0]["출처"] == src
assert [f["number"] for f in make.source(src)["found"]] == ["12-1-2", "12-1-3"]
@@ -150,6 +144,9 @@ def test_원문_출처_번호_없거나_더할_것_없으면_그대로():
assert inputs.sources({"출처": None}) is None
one = {
"출처": "산림품셈 3-1",
"호표": [{"출처": "건설품셈 공통 1-2-4 3"}, {"출처": "산림품셈 3-1"}],
"금액": [
{"수량": "1", "출처": "건설품셈 공통 1-2-4 3"},
{"수량": "1", "출처": "산림품셈 3-1"},
],
}
assert inputs.sources(one) == "산림품셈 3-1" # 다른 책 · 같은 절은 안 붙임
+4 -40
View File
@@ -3,18 +3,14 @@
서버 없이 잡음: 탭(역할) 따라 판 바꿈(일위대가표 = 호표 목록 · 단가산출 탭 = 단가산출 목록 · 칸은 처음 한 번만 지음) ·
시트 행 → 목록 강조 · 목록 줄 → 지금 탭의 블록 자리 + 개인 층 가져온 식 모달(835-1 · [내 단가산출로] 단추 걷음) ·
줄 끝 [가져온 식으로 열기](809-1 · 판정 블록 판 걷음) ·
[끝내기] = 막지 않고 물음창 글만 ·
화면 = 부품 상자만 · 700 줄.
[끝내기] = 막지 않고 물음창 글만.
"""
import json
import os
import re
import subprocess
from pathlib import Path
HERE = os.path.dirname(__file__)
M02 = Path(__file__).resolve().parents[2] / "M02_MasterTemplete"
def _node(payload: dict) -> dict:
@@ -59,7 +55,9 @@ def test_판_바꿈_목록_지음_강조_뛰기():
assert got["opened"] == [{"no": 8, "canWrite": True, "to": "personal"}] * 6
rows = {r["label"]: r for r in got["rows"]}
assert rows["단산8 거푸집"]["sub"] == "㎡ · M02_JudgeCalls 1"
assert rows["단산8 거푸집"]["tail"] == [] # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음
assert (
rows["단산8 거푸집"]["tail"] == []
) # 만들 층 = 개인 → [가져온 식으로 열기] 숨김 · 저장 단추 없음
assert rows["단산9 잡석"]["sub"] == "㎥ · M02_JudgeOutside"
assert rows["단산10 운반"]["tail"] == ["success:M02_JudgeMade SK-000001"]
assert got["count"] == {"블록": 2, "밖": 1, "줄": 0} # 만든 SK 뺌
@@ -71,37 +69,3 @@ def test_권한_그대로_넘김():
{"no": 8, "canWrite": True, "to": "personal"},
{"no": 8, "canWrite": False, "to": "company"},
]
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8")
def test_캐시_공유_알림_칠_다시():
sheet = _src("Sheet")
assert "createSheetSk(" in sheet and "sk?.at(s);" in sheet
side = _src("SheetSk")
assert "readHopyoMarks(opt.scope, opt.key, opt.target)" in side # 809-1 블록 칠 재료 목록
assert (
"createJudgeBlock" not in side and "createJudgeMove" not in side
) # 판정 블록 판 · 옮기기 걷음
nav = _src("SheetNav")
assert "blockAt(sheet: string, row: number)" in nav and "spotOf(no: number, role: Role)" in nav
wizard = _src("Import")
assert (
'L("M02_SkUnmoved")' in wizard and "leftCount" not in wizard
) # 밖 = 안 막음 · 옛 남은 줄 막음 걷음
tone = (M02 / "logic" / "M02_MasterTemplete_Hopyo_SheetMap.ts").read_text(encoding="utf-8")
assert '글: "일위대가 밖"' in tone
def test_부품_상자만_700줄():
for name in ("SheetSk", "Sheet", "SheetNav", "Import", "Side"):
src = _src(name)
assert len(src.splitlines()) <= 700, name
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name
for name in ("SheetSk", "Import"):
assert not re.search(r'el\("(button|input|select)"|<button|<input', _src(name)), name
css = (M02 / "M02_MasterTemplete_Hopyo.css").read_text(encoding="utf-8")
block = css.split(".m02-hopyo-sheet.is-sk", 1)[1].split("/*", 1)[0]
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", block)
+1 -1
View File
@@ -27,7 +27,7 @@ THREE = ("GF000220", "GC000404", "GF000101") # 돌쌓기 메쌓기(장비) ·
def _rows(key: str) -> list[dict]:
whole = m01.loaded()[1]
return st._rows_of(whole, whole.logic(key), False)
return st._rows_of(whole, m01_doc.docs()[key], False)
def _given(key: str, change: dict) -> dict:
+2 -46
View File
@@ -1,9 +1,8 @@
"""704-2 딸림 — 기준 목록 · 계산서 끝수 = B09 산근 규칙(줄마다 ROUNDDOWN 1 · 비목마다 ROUNDDOWN 0).
"""704-2 딸림 — 계산서 끝수(줄마다 0.1 · 비목 소계 정수) · 계 = 기준 목록 금액(문서 셈).
거울: 엔진 줄(수량 · 단가)에 B09 `_money` · `block_totals` 를 그대로 씌운 값 = `settle` 값.
옛 거울(엔진 줄 + B09 끝수 = `M02_Logic_Settle`)은 부르는 곳 0 이라 그 파일과 함께 걷음(855 L2 ⓑ).
"""
import re
import sys
from decimal import Decimal
from pathlib import Path
@@ -12,53 +11,10 @@ ROOT = Path(__file__).resolve().parents[2]
if str(ROOT) not in sys.path:
sys.path.insert(0, str(ROOT))
from B09_Estimation import B09_Estimation_Sangeun as sg # noqa: E402
from M01_MasterData import M01_MasterData_Doc as m01_doc # noqa: E402
from M01_MasterData import M01_MasterData_Store as m01 # noqa: E402
from M02_MasterTemplete import M02_Logic_Settle as st # noqa: E402
from M02_MasterTemplete import M02_Logic_Standard as ls # noqa: E402
mf = m01.cm.mf
PART_OF = {"노무비": "labor", "재료비": "material", "경비": "expense"}
def _plain(row: dict) -> bool:
"""로직 줄 · 덧줄 · 작업량 Q 가 없는 돈 로직 — 엔진 줄만으로 B09 값을 낼 수 있음."""
return (
str(row.get("결과단위") or "").startswith("원")
and not row.get("덧줄")
and not row.get("끝수")
and not any(i.get("종류") == "로직" for i in row.get("호표") or [])
and not any(re.fullmatch(r"Q\d*", s["이름"]) for s in row.get("중간") or [])
)
def test_줄마다_버림_비목마다_버림_B09와_같음():
files, whole = m01.loaded()
checked = 0
for _, data in m01._logic_files(files):
for row in data.get("줄") or []:
if not _plain(row) or checked >= 60:
continue
base, _ = ls.axes(whole, m01_doc.docs()[row["키"]])
given = mf.fill_empty(row, base)
got = mf.run(whole, row["키"], given)
lines = []
for line in got["줄"]:
one = dict.fromkeys(PART_OF.values(), 0.0)
for part, money in line["비목"].items():
one[PART_OF[part]] = sg._money(1.0, float(money)) if money is not None else None
lines.append(one)
if any(v is None for one in lines for v in one.values()):
continue
want = sg.block_totals(lines)
mine = st.settle(whole, row["키"], given)
for name, part in PART_OF.items():
assert float(mine[name]) == want[part], (row["키"], name)
assert float(mine["계"]) == want["sum"], row["키"]
checked += 1
assert checked >= 30
def test_계산서_줄_소계_계가_맞물림():
files, whole = m01.loaded()
+2 -1
View File
@@ -15,6 +15,7 @@ from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Doc as m01_doc
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
@@ -52,7 +53,7 @@ def test_727_1_기초마다_한_줄():
whole = m01.loaded()[1]
rows = []
for key in (GF, "GC000269", "GC001109"):
rows += standard._rows_of(whole, whole.logic(key), False)
rows += standard._rows_of(whole, m01_doc.docs()[key], False)
assert sum(r["키"] == GF for r in rows) == 3 # 옵션 축 보정작업 두 값 + 바탕
got = _heads(rows)
assert [r["키"] for r in got] == [GF, "GC000269", "GC001109"]
+2 -1
View File
@@ -21,6 +21,7 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Library_Same as same
from M02_MasterTemplete import M02_Library_Same_Router as same_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
@@ -112,7 +113,7 @@ def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world):
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9)
with store.at(me):
(me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움
assert refs.users({**MINE, "키": inner}) == []
assert library_uses.users({**MINE, "키": inner}) == []
store.delete("precombo", inner)
assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로
@@ -110,17 +110,3 @@ def test_B09_옛_사본_null_은_그대로_빈_줄():
def _src(name: str) -> str:
return open(os.path.join(SRC, name), encoding="utf-8").read()
def test_화면_수량_칸_저장_새_줄_1_두_칸():
table = _src("M02_MasterTemplete_Labor_Table.ts")
assert "const temp = new Map" not in table and "withTemp" not in table # 휘발 칸 걷음
assert "row.수량 = raw ? { 손: v } : null;" in table and "changed(true);" in table
assert (
table.count("수량: fresh()") == 4
) # 기초 · 참조 · 고정 · 자재 새 줄 = 서고 1 · 조합 면적 따름(806-1)
assert "const fresh = (): LaborRow" in table and "{ ...ONE }" in table
assert 'BasePrice: ["기준단위 단가"' in table and 'QtyAmount: ["수량 반영 금액"' in table
assert 'sum_price: t("BasePrice"), sum: t("QtyAmount")' in table
assert 'NeedQty: ["수량 입력"' in table
assert 'if (!edit || key !== "qty" || n === null) return false;' in table # 읽기 층 못 고침
+1 -29
View File
@@ -103,7 +103,7 @@ def test_끝내기_남는_파일_0_금액_그대로_출처만_다시_올림(clie
assert not {"키", "원본", "확인", "품셈", "갈래", "엑셀품", "못옮김", "또"} & set(got)
lines = doc.get("담은로직") or []
assert not any(str(x.get("메모", "")).startswith("실무 ") for x in lines)
assert hs.done(folder)["지문"] == {} # 끝낸 기록 없음
assert hs.done(folder) == {"번": 1} # 끝낸 기록 없음 · 번만
again = _post(client) # 같은 엑셀 다시 올림 = 새 키(409 없음)
assert again.status_code == 200 and again.json()["키"] == "HP-000002"
@@ -121,31 +121,3 @@ def test_하루_지난_HP_목록_숨김_올림_때_지움(client):
got = _post(client).json() # 같은 엑셀이어도 지난 것 = 지우고 새로(이어서 아님)
assert got["키"] == "HP-000002" and not got.get("이어서")
assert _files(folder) == ["HP-000002.json"] * 3 # 이번 것 + 격자 + 산근 시트(793-3b)
def test_옛_파일_정리_미리_보기_쓰기_0_고침(client):
folder = layers.personal_dir(7, 42)
assert _post(client).json()["키"] == "HP-000001" # 작업 중 — 그대로
home = folder / hs.DIRNAME
(home / "HP-000007.json").write_text(json.dumps({"키": "HP-000007", "호표": []}), "utf-8")
hs._put_done(folder, {"번": 7, "지문": {"ab": {"파일": "옛.xls", "만든": ["SC-000001"]}}})
(folder / "precombo").mkdir(exist_ok=True)
gone = {"이름": "옛", "단위": "개", "담은로직": [{"로직": "L", "메모": "실무 1개 × 1"}],
"본뜬": {**HEAD, "키": "HP-000005 제1호표", "확인": SURE}} # fmt: skip
live = {**gone, "본뜬": {**HEAD, "키": "HP-000001 제1호표", "확인": SURE}}
for key, doc in (("SC-000001", gone), ("SC-000002", live)):
text = json.dumps(doc, ensure_ascii=False)
(folder / "precombo" / f"{key}.json").write_text(text, "utf-8")
snap = {p: p.read_bytes() for p in folder.rglob("*.json")}
rows = forget.tidy(folder)
assert [r["대상"] for r in rows] == ["실무자료/HP-000007", "불러옴.json", "SC-000001"]
assert {p: p.read_bytes() for p in folder.rglob("*.json")} == snap # 미리 보기 = 쓰기 0
assert forget.tidy(folder, apply=True) == rows
assert _files(folder) == ["HP-000001.json"] * 3
assert hs.done(folder) == {"번": 7, "지문": {}}
docs = _docs(folder, "precombo")
assert "키" not in docs["SC-000001"]["본뜬"] and "메모" not in docs["SC-000001"]["담은로직"][0]
assert docs["SC-000002"] == live # 작업 중 HP 것 그대로
assert forget.tidy(folder) == [] # 두 번째 = 할 일 없음
@@ -118,7 +118,8 @@ def test_STmate_같은_코드_두_묶음_따로_계수_율_밖():
), # fmt: skip
_row(c0="총계"),
]
blocks = st._blocks(rows, {})
lines = [{"행": at, **{chr(65 + c): v for c, v in enumerate(r) if v is not None}} for at, r in enumerate(rows, 1)] # fmt: skip
blocks = st.from_two([{"코드": "D00001", "칸줄": lines}], {})
units = blocks["D00001"]["항목"]
xs = [u for u in units if u["묶음"] == "X"]
assert [x["품"] for x in xs] == [0.1, 0.2] # 두 묶음 따로(단가 두 배 아님)
@@ -1,75 +0,0 @@
"""785-4 불러오기 화면 껍데기 — 가운데 상세 페이지(마법사) 없음 · 왼쪽 [불러오기] → 바로 본 칸 엑셀 + 오른쪽 목록 ·
머리 막대 [끝내기] · 좁은 판 줄 판 자리 · 부품 상자만 · 700 줄(785-7 — 안 이은 줄 띠 · 마법사 단가산출 걸음 · 옛 캐시 걷음 반영).
소스 글만 읽음(서버 · 화면 없이 돎)."""
import re
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
M02 = ROOT / "M02_MasterTemplete"
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_Hopyo_{name}.ts").read_text(encoding="utf-8")
def test_가운데_상세_페이지_없음():
assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists()
every = "\n".join(p.read_text(encoding="utf-8") for p in M02.glob("*.ts"))
for gone in ("buildHopyoWizard", "HopyoWizard", "wantSangeun", "M02_WizSkCheck", "STEPS"):
assert gone not in every, gone
for key in ("M02_WizSkHead", "M02_WizIlwiHead", "M02_SkHint"):
assert key not in (ROOT / "ui_template" / "ui_template_locale_m2.ts").read_text("utf-8")
def test_누름_하나_바로_엑셀():
side = _src("Side")
choose = side.split("async function choose()")[1].split("input.addEventListener")[0]
assert "input.click();" in choose # [불러오기] = 바로 파일 고르기 창
change = side.split('input.addEventListener("change"')[1].split("async function leaveOk")[0]
assert "uploadHopyo(MINE, file)" in change and "return show(got, true);" in change
show = side.split("async function show(")[1].split("async function showLedger")[0]
assert "buildHopyoImport({" in show and "opt.show(" in show # 올림 뒤 본 칸 바로
imp = _src("Import")
assert "m.buildHopyoSheet({" in imp and "headExtra: [finish]" in imp
def test_층_가르기_없음_늘_개인(): # 837-1 · 요구 855 — 예전 「결과 층 고름」 걷음
side, imp = _src("Side"), _src("Import")
for gone in ("createSegment", "writableLayers", "LAYERS", "layerText", "seg.hidden", "pick"):
assert gone not in side, gone
for gone in ("LAYERS", "layerText", "writableLayers", "layerNote", "createBadge"):
assert gone not in imp, gone
assert 'export const MINE: HopyoScope = { layer: "personal", owner: null };' in imp
def test_끝내기_머리_막대_끝냄_뒤_빈_본_칸():
imp = _src("Import")
end = imp.split("async function end()")[1]
assert (
"skCount()" in end.split("showConfirmDialog(")[0]
) # 안 만든 단가산출 = 물음 글만(막지 않음)
assert "deleteHopyo(scope, file.키)" in end and "a.onEnded();" in end
side = _src("Side")
assert "onEnded: () => {" in side and "void refresh();" in side
sheet = _src("Sheet")
assert "dropButton" not in sheet and "onDeleted" not in sheet # [삭제] 걷음
def test_부품_상자만_700줄_늘리지_않음():
for name in ("Import", "Side", "Sheet", "SheetSk"):
src = _src(name)
assert len(src.splitlines()) <= 700, name
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", src), name # 색 = 공통 값
for name in ("Import", "SheetSk"):
assert not re.search(r'el\("(button|input|select)"|<button|<input', _src(name)), name
assert len(_src("Api").splitlines()) <= 632
css = (M02 / "M02_MasterTemplete_Hopyo.css").read_text(encoding="utf-8")
assert not re.search(r"#[0-9a-fA-F]{3,6}\b|rgb\(", css) and ".m02-hopyo-import" in css
def test_해시_캐시_열쇠_없음():
# 809-1 — 판정 고름 캐시(`Hopyo_Picks`) 걷음 · 옮기기 = [내 일위대가로]
assert not (M02 / "logic" / "M02_MasterTemplete_Hopyo_Picks.ts").exists()
assert "draftKey" not in _src("Import") and "dirty: () => body?.matDirty()" in _src("Import")
assert "location.hash" not in _src("Import") + _src("Side") # 새 해시 열쇠 없음
+3 -53
View File
@@ -1,18 +1,12 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""790-2 단가산출(SK) 숫자 넓힘 — 상수 · 표값 덮개 · 글 줄 · 까닭 · M01 원래로 · 짝잃음(요구서_652).
"""790-2 단가산출(SK) 글 줄 · 까닭 칸 꼴 · 옛 SK 셈 답(요구서_652).
- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(지붕 감률 17 → 20 = 61,088 · 공구손료 1 → 2 % = 51,802 ·
인력운반 120 → 100 = 38,696 · 표값 운반량 30 = 35,764) · 옵션 바꿔도 상수 덮개 식 따라감
- 식 속 숫자 차례 = 엔진 파서(찾기 머리 · 키 · EQ: · 따옴표 글 안 셈)
- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · 저장 = M01판 · 셈 답 `원래` · `시트`
- 799-2 — TS 거울(`Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버 `M02_Sangeun_Const` 만 지킴
- 펼침 = 상수 덮개 SK 안 펼침(참조 그대로 · 값 그대로) · [초기화] = 새 덮개도 걷음
- 글줄 · 까닭 = 꼴 검사 · 빈 칸 안 둠 · 상수 · 표값 덮개 = 셈 은퇴 뒤 받지 않음(855 2-E2 · 시험 792_1)
- 옛 SK(새 칸 없음) = 꼴 · 금액 그대로 · M01판 = 서버 몫(버림)
"""
from __future__ import annotations
import json
from pathlib import Path
import pytest
@@ -24,11 +18,7 @@ from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
ROOT = Path(__file__).resolve().parents[2]
FORM = "GC000211" # 합판거푸집
CARRY = "GC001140" # 인력운반(지게)
ROOF = "지붕 슬래브(경사 20˚ 미만)"
TOOL = "pct:공구손료 및 경장비#0"
F211 = {
"자재지역": "포항",
"유형": "보통",
@@ -46,15 +36,6 @@ def _whole():
return m01.loaded()[1]
def _carry():
return {
**json.loads(json.dumps(_whole().logic(CARRY)["시험입력"], default=str)),
"재료종별": "암석",
"재료형상": "화강암",
"운반회수": 0,
}
def _doc(code, given, **more):
return {
"키": "SK-000001",
@@ -66,47 +47,19 @@ def _doc(code, given, **more):
}
def _sum(doc):
whole = _whole()
return float(calc.run(sd.clean(doc, None, whole), whole)["기준"]["계"])
# ── 식 속 자리 ────────────────────────────────────────────────────────
def test_scan_엔진_차례():
t = "찾기(QC000431, 유형=유형).시공량 * (1 - (높이감률 + 만약(지붕슬래브 == '아님', 0, 17)) / 100)"
got = const.scan(t)
assert [t[a:b] for a, b in got["num"]] == ["1", "0", "17", "100"]
assert [t[a:b] for a, b in got["find"]] == ["찾기(QC000431, 유형=유형).시공량"]
tool = "(형틀목공 * LB000007 + 보통인부 * LB000002) * 1 / 100"
assert [tool[a:b] for a, b in const.scan(tool)["num"]] == ["1", "100"]
assert const.scan("EQ:0201-0012.잡재료율 * 2 + '3t/㎡'")["num"] == [(20, 21)]
assert const.scan("((((") == {"num": [], "find": []} # 못 읽는 식 = 빈
assert const.swap(t, {"2": 20}, {"0": -45}).startswith("(-45) * (1 - ")
assert ", 0, 20)) / 100)" in const.swap(t, {"2": 20}, {})
# ── 금액 = 견본(서버 셈) ──────────────────────────────────────────────
# ── 문서 꼴 ──────────────────────────────────────────────────────────
def test_새_칸_꼴_검사():
whole = _whole()
doc = _doc(
FORM,
F211,
상수덮개={"mid:시공량": {"2": "20"}, TOOL: {}},
표값덮개={},
글줄=[{"자리": "", "글": " 건설표준품셈 6-3-1 "}, {"자리": "mid:시공량", "글": ""}],
까닭={"mid:시공량": "현장 경사 반영", "add:#0": " ", "add:#1/labor:LB000002#0": "x"},
)
got = sd.clean(doc, None, whole)
assert got["상수덮개"] == {"mid:시공량": {"2": 20}} and "표값덮개" not in got
assert got["글줄"] == [{"자리": "", "글": "건설표준품셈 6-3-1"}]
assert got["까닭"] == {"mid:시공량": "현장 경사 반영", "add:#1/labor:LB000002#0": "x"}
for bad in (
{"상수덮개": {"엉뚱": {"0": 1}}},
{"상수덮개": {"mid:시공량": {"a": 1}}},
{"표값덮개": {"mid:운반량": {"0": "글"}}},
{"까닭": {"x": "y"}},
{"글줄": [{"자리": "", "글": "가" * 501}]},
):
@@ -119,9 +72,6 @@ def test_옛_SK_꼴_금액_그대로():
old = _doc(FORM, F211, 덮개={"labor:LB000007#0": {"qty": 0.2}}, 뺀줄=["labor:LB000002#0"])
got = sd.clean(old, None, whole)
assert not set(got) & {*const.NEW, "M01판"}
assert const.formulas(whole.logic(FORM), got) is whole.logic(
FORM
) # 새 덮개 없음 = 그 줄 그대로
assert sd.clean({**old, "M01판": {"mid:시공량": "x"}}, None, whole) == got # M01판 = 서버 몫
+33 -80
View File
@@ -1,39 +1,27 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""792-1 단가산출(SK) 사용자 식 칸 — 변수 줄 · 식 덮개 · 더한줄 수량식 · 이름 꼴 ↔ 엔진 식 · 검사.
"""792-1 식 글 번역 · 옛 SK 식 칸 막음.
- 금액 = 서버 셈 = _분석_650-H2 4 장 견본(인력운반 「할증율 20」 변수 줄 + 보통인부 품 식
× (1 + 할증율 / 100) = 51,501) · 합판거푸집 줄 식 고침 · 공구손료 식 2 % = 51,802(790-2 같은 값)
- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음
- 꼴 상한 — 변수 줄 수 · 이름 꼴 · 자리 겹침 · 괄호 깊이(식 칸 검사 길은 894 에서 걷음)
- 옛 SK(식 칸 없음) = 꼴 · 금액 그대로 · 저장 = 엔진 식 · 틀린 식 저장 400 · 셈 답 덧칸
- B09 사본 굳힘(`GX9#####`) 줄 = 식 칸 그대로 · 다시 셈 같은 금액
- 799-2 — TS 거울(`Formula_Model.ts` · `Const_Model.ts`)은 시트 탭과 함께 걷음 · 서버만 지킴
- 이름 꼴(`×` · `[노임 형틀목공]` · `[별칭]`) ↔ 엔진 식 왕복 = M01 로직 견본 식 전부 같음(M01 수식 탭 · 가져온 식이 씀)
- 식 글 상한 — 괄호 깊이 · 길이
- 옛 SK 식 칸(변수줄 · 식덮개 · 더한줄 수량식)과 상수 · 표값 덮개 = 셈 은퇴(855 2-C1) 뒤 받지 않음 400(855 2-E2)
- [초기화] = 덮개 · 뺀줄 · 그 까닭 걷음 · 빈 옛 식 칸 = 지문 그대로
"""
from __future__ import annotations
import json
from pathlib import Path
import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Formula as fx
from resources.tester.test_m02_labor_ref import MINE, world # noqa: F401 — 같은 임시 층
ROOT = Path(__file__).resolve().parents[2]
FORM, CARRY = "GC000211", "GC001140" # 합판거푸집 · 인력운반(지게)
MAN = "labor:LB000002#0" # 인력운반 보통인부
TOOL = "pct:공구손료 및 경장비#0"
F211 = {"자재지역": "포항", "유형": "보통", "사용횟수": "6회", "높이감률": 0, "지붕슬래브": "아님"}
F211 |= {"폼타이": "아님", "폼타이규격": "12.7㎜", "측압": "3t/㎡", "구멍땜": 0}
PLUS = "무게 / 운반량 / 일운반회수 × (1 + 할증율 / 100)"
def _whole():
@@ -59,23 +47,6 @@ def _sk_doc(code, given, **more):
return {**_doc(code, given), **more}
def _run(doc):
whole = _whole()
return calc.run(sd.clean(doc, None, whole), whole)
def _sum(doc):
return float(_run(doc)["기준"]["계"])
def _plus(**more):
var = [{"이름": "할증율", "식": "20", "자리": ""}]
return _sk_doc(CARRY, _carry(), **({"변수줄": var, "식덮개": {MAN: PLUS}} | more))
# ── 견본 금액 ─────────────────────────────────────────────────────────
# ── 이름 꼴 ↔ 엔진 식 ────────────────────────────────────────────────
def test_이름_꼴_양방향():
whole = _whole()
@@ -98,61 +69,43 @@ def test_이름_꼴_양방향():
assert fx.to_engine(fx.to_name(str(x[f]), one), one) == (str(x[f]), [])
def test_꼴_상한_겹침():
def test_식_글_상한():
assert fx.limits("(" * 13 + "1" + ")" * 13) == [f"괄호가 {fx.DEEP} 겹을 넘음"]
assert fx.limits("1" * (fx.LONG + 1)) == [f"식이 {fx.LONG} 자를 넘음"]
assert fx.limits("'((((((((((((('") == [] # 따옴표 글 안 괄호 안 셈
def test_옛_식_칸_받지_않음():
whole = _whole()
many = [{"이름": f"v{i}", "식": "1", "자리": ""} for i in range(fx.MANY + 1)]
for bad, why in (
({"변수줄": many}, "까지 목록"),
({"변수줄": [{"이름": "1가", "식": "1"}]}, "이름 꼴"),
({"변수줄": [{"이름": "가", "식": "1"}, {"이름": "가", "식": "2"}]}, "같은 이름"),
({"변수줄": [{"이름": "가", "식": "1", "표시": 7}]}, "0~6"),
({"식덮개": {"mid:시공량": "1"}, "상수덮개": {"mid:시공량": {"0": 1}}}, "같이 못 둠"),
({"식덮개": {"labor:LB000007#0": "1"}, "덮개": {"labor:LB000007#0": {"qty": 1}}}, "qty"),
({"식덮개": {"엉뚱": "1"}}, "자리 꼴"),
({"식덮개": {"mid:시공량": "(" * 13}}, "괄호"),
plain = sd.clean(_sk_doc(FORM, F211), None, whole)
for bad in (
{"변수줄": [{"이름": "할증율", "식": "20"}]},
{"식덮개": {"mid:시공량": "1"}},
{"상수덮개": {"mid:시공량": {"0": 1}}},
{"표값덮개": {"mid:운반량": {"0": 30}}},
{"더한줄": [{"종류": "인력", "요소": "LB000002", "수량": 1, "수량식": "2"}]},
):
with pytest.raises(sd.DocError, match=why):
with pytest.raises(sd.DocError, match="옛 식 칸"):
sd.clean(_sk_doc(FORM, F211, **bad), None, whole)
empty = {"변수줄": [], "식덮개": {}, "상수덮개": {}, "표값덮개": {}}
assert sd.clean(_sk_doc(FORM, F211, **empty), None, whole) == plain # 빈 칸 = 옛 SK 그대로
# ── 옛 SK · 저장 · 셈 답 · 펼침 · 초기화 ─────────────────────────────────
# ── 초기화 · 지문 ─────────────────────────────────────────────────────
def _sk(folder, **doc):
with store.at(folder):
made = refs.create("sangeun", {"이름": "내 단가산출", "단위": "식", "더한줄": [], **doc})
return made["이름"]
def test_초기화_걷음():
doc = _sk_doc(CARRY, _carry(), 덮개={MAN: {"qty": 1}}, 까닭={MAN: "할증", "add:#0": "더함"})
got, n = flat.reset("sangeun", doc)
assert n == 1 and got["덮개"] == {} and got["까닭"] == {"add:#0": "더함"} # 더한줄 몫 까닭 남김
assert const.restore(doc)["뺀줄"] == [] and const.covers_n(doc) == 1
def _read(folder, key):
with store.at(folder):
return store.read("sangeun", key)["문서"]
def _calc(folder, doc):
with store.at(folder):
return calc.calc_doc(doc)
def test_펼침_막음_초기화_걷음(world):
mine = world["personal"]
a = _sk(mine, 바탕={"로직": CARRY}, 입력값=_carry(), 변수줄=[{"이름": "할증율", "식": "20"}])
with store.at(mine), pytest.raises(sd.DocError):
const.no_flat(_read(mine, a)) # 식 칸 SK = 안 펼침(저장 · 읽기 펼침 첫머리)
doc, n = flat.reset("sangeun", {**_plus(), "까닭": {MAN: "할증"}})
assert n == 1 and "식덮개" not in doc and "까닭" not in doc and doc["변수줄"]
assert const.restore(_plus(), MAN).get("식덮개") is None
assert const.covers_n(_plus()) == 1
# ── B09 사본 굳힘 ─────────────────────────────────────────────────────
def test_같은_내용_지문_식_칸_가림():
"""식 칸만 다른 SK = 다른 내용(409 같은 것 물음 안 함) · 옛 SK 지문 그대로."""
def test_같은_내용_지문_빈_옛_칸():
"""빈 옛 식 칸 = 옛 SK 지문 그대로."""
from M02_MasterTemplete import M02_Library_Same as same
plain = _doc(CARRY, _carry())
one, two = same.finger("sangeun", plain), same.finger("sangeun", _plus())
assert one and two and one != two
assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == one
assert same.finger("sangeun", {**plain, "식덮개": {}, "변수줄": []}) == same.finger(
"sangeun", plain
)
@@ -163,7 +163,6 @@ def test_북부청_18_줄_자리_셈_엑셀():
"more",
[
{"덮개": {"labor:형틀목공#0": {"qty": 0.2}}},
{"상수덮개": {BURN: {"0": 12}}},
{"뺀줄": [PLY]},
{"더한줄": [{"종류": "인력", "요소": MAN, "수량": 0.01}]},
],
@@ -5,16 +5,10 @@
블록 → 793-2a 내보내기 → 793-2 가져온 식 SK(만들 층 · 엑셀 단가 그대로 · 검산 = 엑셀) ·
같은 내용 = 그 SK 다시 씀 · 산근 없는 옛 HP = 409 · HP 지우면 산근도 지움 ·
STmate 블록 끝전 = 엑셀 계와 맞는 쪽
- 화면 소스 — 단가산출 탭 목록 [가져온 식으로 열기](`Hopyo_SheetSk`) · 시트 모달
(`Sangeun_Detail`) · 머리 판(검산 · [우리 단가로] / [엑셀 단가로] · [원본 글 보기] ·
[이음 고르기] · 소요량 이음) · 부품 상자만 · 700 줄
- 809-1 걷음(요구 703) — [우리 기초로 바꾸기] · 근거 세 단 · 입력 필요 · [이 줄에 잇기] · 옮기기 판정 길 없음
임시 storage(`client` 마당) · M01 원본 그대로.
"""
import re
from pathlib import Path
import helper_m02_hopyo_golden as golden
import pytest
@@ -26,15 +20,8 @@ from M02_MasterTemplete import M02_Template_Layers as layers
# ruff: noqa: F811
from resources.tester.test_m02_hopyo_excel import _post, client, master_hash # noqa: F401
ROOT = Path(__file__).resolve().parents[2]
M02 = ROOT / "M02_MasterTemplete"
API = "/api/m02/layers/personal"
KEY = "HP-000001"
MINE = ("Hopyo_Imported", "Hopyo_ImportedPanel", "Hopyo_SheetSk", "Hopyo_View")
def _src(name: str) -> str:
return (M02 / f"M02_MasterTemplete_{name}.ts").read_text(encoding="utf-8")
def _skcount() -> int:
@@ -97,44 +84,3 @@ def test_STmate_끝전_엑셀_계와_맞는_쪽(tag, code, rule):
got = sx.read(path.name, path.read_bytes())
assert got["옵션"]["SAN_TYP"] == xs.RULE[rule]
assert any(b["코드"] == code for b in got["산근"])
# ── 화면 소스 ─────────────────────────────────────────────────────────
def test_단산_줄_길_잇기():
sk, view = _src("Hopyo_SheetSk"), _src("Hopyo_View")
assert "openImported({" in sk and "dataset.skOpen" in sk # 단가산출 탭 목록 = 가져온 식 모달
assert (
'"/sangeun/from-hopyo"' not in view and "openImported({" in view
) # [수정] 단산 줄 = 가져온 식 모달(미리 보기 · 835-1)
imp = _src("Hopyo_Imported")
assert '"/sangeun/from-hopyo/preview"' in imp and '"/sangeun/from-hopyo"' in imp
assert "/sangeun/imported/${how}" in imp
assert "mountSangeunDetail(" in imp and "saveTemplate(" in imp and "openModal({" in imp
for how in ('run("price"', 'run("link"'):
assert how in imp, how
for gone in ("to-base", "toBase", "onLink", "skPick", "checkJudge", "readJudgeBlock"):
assert gone not in imp, gone # 809-1 · 요구 703
# 옛 M02 수식 나무 화면(「엑셀 원래」 위 줄) 걷음 — 수식 탭 = 공용 수식 문서 화면(802-4b-2)
assert not (M02 / "M02_MasterTemplete_Sangeun_Equation.ts").exists()
def test_머리_판_기초_없음():
panel = _src("Hopyo_ImportedPanel")
for word in ("ToOurs", "ToExcel", "Source", "Link", "Same", "Diff"):
assert f'tx("{word}")' in panel, word
for gone in ("ToBase", "PickBase", "data-basis-tiers", "우리 기초로 바꾸기", "근거 제안"):
assert gone not in panel, gone
model = (M02 / "logic/M02_Hopyo_Imported_Model.ts").read_text(encoding="utf-8")
assert "BasisCand" not in model and "skPick" not in model and "근거후보" not in model
assert not re.search(r"from \"@ui|document\.|fetch\(|sessionStorage\.", model) # 순수
def test_부품상자만_700줄_공용_안_고침():
for name in MINE:
text = _src(name)
assert len(text.splitlines()) <= 700, name
assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text), name
assert not re.search(r"""createElement\(\s*["'](button|input|select)["']""", text), name
assert "#" not in "".join(re.findall(r"color:\s*[^;]+", text)), name
for name in ("Labor_Rows", "Labor_SkEdit", "Sangeun_Detail", "Sangeun_Tabs"):
assert "Hopyo_Imported" not in _src(name), name # 공용 쪽은 새 모달을 모름
+15 -8
View File
@@ -47,9 +47,18 @@ def _fake(monkeypatch, rows=(), drop=()):
from M02_MasterTemplete import M02_Doc_Copy as dc
files, live = m01.loaded()
fake = skc.Copy(live, [copy.deepcopy(r) for r in rows])
fake = copy.copy(
live
) # M01 꼴 그대로(값 사본 색인 `skc.Copy` 로 만들면 `dc.base` 가 벗김 · 855 L2 ⓑ)
fake.index = {t: dict(v) for t, v in live.index.items()}
fake.numbers = {t: dict(v) for t, v in live.numbers.items()}
for row in rows:
row, key = copy.deepcopy(row), str(row["키"])
fake.index.setdefault(key[:2], {})[key] = row
if row.get("원문번호"):
fake.numbers.setdefault(key[:2], {})[str(row["원문번호"])] = row
for key in drop:
skc.Copy._own(fake.index, live.index, key[:2]).pop(key, None)
fake.index.get(key[:2], {}).pop(key, None)
monkeypatch.setattr(m01, "loaded", lambda: (files, fake))
docs = {k: v for k, v in dc.folder().items() if k not in drop}
docs |= {str(r["키"]): dc.cv.convert(fake, copy.deepcopy(r))[0] for r in rows if "호표" in r}
@@ -93,7 +102,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch):
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
got = skc.held(_doc(me, key))
assert PCT in {r["키"] for r in got["로직"]}
assert PCT not in {r["키"] for r in got["로직"]} # 로직 줄 = 문서 사본(855 L2 ⓑ)
assert got["단가"] and all(r["키"][:2] in skc.RES for r in got["단가"])
assert not any(r["키"][:2] in skc.RES for r in got["로직"])
first = _calc(me, _doc(me, key))
@@ -130,17 +139,15 @@ def test_price_refresh_only_on_press(world, monkeypatch):
def test_deleted_keys_keep_last_value(world, monkeypatch):
"""⑤ 사본이 부르는 M01 키(바탕 로직 · 노임)가 지워져도 마지막 값 · 지운키 표지."""
"""⑤ 사본이 부르는 M01 노임이 지워져도 마지막 값 · 지운키 표지(바탕 로직 = M01 이 지우기 막음 409)."""
me = world["personal"]
key = _sk(me, 바탕={"로직": PCT})
was = _sum(me, key)
lb = next(r["키"] for r in skc.held(_doc(me, key))["단가"] if r["키"].startswith("LB"))
_fake(monkeypatch, drop=[PCT, lb])
with pytest.raises(Exception):
m01.loaded()[1].logic(PCT)
_fake(monkeypatch, drop=[lb])
now = _calc(me, _doc(me, key))
assert now["기준"]["계"] == was
assert {PCT, lb} <= set(now["사본"]["지운키"])
assert {lb} <= set(now["사본"]["지운키"])
with store.at(me):
got = path.preview(key, {"할일": skc.PRICE})
assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"]
+2 -1
View File
@@ -20,6 +20,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Hopyo_Store as hs
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as machine
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_Emit as em
@@ -142,7 +143,7 @@ def test_nested_stmate_follows_inner(world) -> None:
assert made["검산"]["같음"] is True and made["검산"]["셈"]["계"] == 67383
assert _money(doc) == 67383
assert fh.make(folder, KEY, 2200)["이름"] == made["이름"] # 다시 올려도 같은 SK
assert refs.users(ref) # 쓰는 곳에 바깥 SK
assert library_uses.users(ref) # 쓰는 곳에 바깥 SK
with pytest.raises(store.StoreError) as why:
refs.refuse_used(folder, "sangeun", ref["키"])
assert why.value.status == 409
-34
View File
@@ -45,25 +45,6 @@ def test_조합_상세_카드_서고_한_부품():
assert "openQtyModal({" in combo and "linkAreaCell(" in combo and "saveTemplate(" in combo
def test_단가산출_줄은_SK_문서_모달_저장은_그_SK():
table = _src("M02_MasterTemplete_Labor_Table.ts")
modal = _src("M02_MasterTemplete_Labor_SkEdit.ts")
assert 'ref.키.startsWith("SK-")' in modal # SK 참조 줄만
assert "if (isSkRef(row.참조) && !opt.calc)" in table # 셈 주입(프로젝트 복사본)엔 옛 줄 모달
assert "readOnly: !edit || row.참조.층 !== opt.layer," in table # 위 층 SK = 읽기만
assert re.search(r'readTemplate\(layer, "sangeun", opt\.ref\.키, null, opt\.ref\.주인\)', modal)
assert re.search(
r'saveTemplate\(\s*layer,\s*"sangeun",\s*opt\.ref\.키', modal
) # 저장 = 그 SK 문서
assert (
"mountSangeunDetail(host, doc," in modal and 'mode: "page"' in modal
) # 수식 탭 부품 그대로
assert "await handle.flush();" in modal # 수식 저장 먼저 → 문서 저장
assert "if (!opt.readOnly) head.append(ok);" in modal # 읽기만 = [저장] 없음
assert "if (opened.has(at)) return;" in modal # 빨리 두 번 눌러도 하나
assert "closed: (done) => alive && done && recalc()," in table # 저장했으면 금액 다시 셈
def test_부품상자만_700줄_명사형():
for name in (
"M02_MasterTemplete_Labor_Table.ts",
@@ -119,18 +100,3 @@ def test_옛_판_저장_409(world):
with pytest.raises(store.StoreError) as why:
store.write("sangeun", key, got["판"], got["문서"])
assert why.value.status == 409
def test_808_1_모달_머리_일원화():
"""808-1(요구 701-4 · 5) — 단가산출 줄 모달 머리 = 페이지 머리(보기 고르기 · [단가 갱신] · [재생성]) ·
로직 줄 모달(저장된 일위대가 줄 = 펼친 로직 줄 · 740-1) = 옛 [옵션] · [단가산출로도 저장] · [항목 추가] · [율 줄 추가] 없음 ·
보기 고르기 없이 상세만 + 안내(온 단가산출) · 줄 문서 키 SK-000000 = 수식 문서 안 읽음(404 없음)."""
sk = _src("M02_MasterTemplete_Labor_SkEdit.ts")
assert "slot,\n" in sk and "head.append(slot);" in sk
row = _src("M02_MasterTemplete_Labor_RowModal.ts")
for gone in ("AlsoSk", "createCheckbox", "openLaborInput", "saveAsSk", "Labor_Option"):
assert gone not in row, gone
assert 't("FromSk")' in row
detail = _src("M02_MasterTemplete_Sangeun_Detail.ts")
assert "...(opt.slot ? [] : [" in detail # 머리 칸 있으면 머리 줄 없음
assert "children: [tabs.tools]" in detail and "tabs.picker" not in detail
@@ -145,16 +145,3 @@ def test_origin_card_and_clauses(world) -> None:
("임도품셈", "5-1-2", 4),
]
assert plain is None # 우리 SK = 카드 없음(원문 먼저)
def test_source_find_on_m01_and_m02_panels() -> None:
m02 = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Side.ts").read_text("utf-8")
m01 = (ROOT / "M01_MasterData/M01_MasterData_UI_LogicLab_Side.ts").read_text("utf-8")
assert "createSourceFind" in m02 and "createSourceFind" in m01
assert "originOf" in m02
sheet = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_Mine.ts").read_text("utf-8")
block = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Hopyo_SheetSk.ts").read_text("utf-8")
assert "/hopyo-build-all" in sheet and "번: h.번" in sheet
assert '{ layer: "personal", owner: null }' in block and "openImported" in block
detail = (ROOT / "M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts").read_text("utf-8")
assert "], doc);" in detail # 원문 패널에 SK 문서(가져온 머리 · 810-4 가져온보관)를 넘김
-10
View File
@@ -122,16 +122,6 @@ def test_마스터_층_단가산출_로직_줄_0():
def test_화면_줄_넣기_SK_사본_참조_부품():
table = _src("M02_MasterTemplete_Labor_Table.ts")
pick = _src("M02_MasterTemplete_Labor_SkPick.ts")
assert 'opt.layer !== "project" && !opt.calc ? { layer: opt.layer' in table # 프로젝트 = 옛 길
assert "return void skFromLogic(own, x.키).then(" in table # M01 기초 = SK 사본
assert "own && isSkRef(ref)" in table and "void ownSk(own, ref)" in table # 다른 층 = 사본
assert "if (isSkRef(row.참조) && !opt.calc)" in table # 줄 누름 = SK 수식 모달
assert "/sangeun/from-logic" in pick and "{ 본뜬 }" in pick and "withSameAsk(" in pick
assert (
"fetchSessionUser()" in pick
) # 주인 null = 자기 층 → 서버 참조 꼴(같은 층 SK 를 사본으로 안 만듦)
combo = _src("M02_MasterTemplete_Labor_Combo.ts")
assert "...refCards(doc, calc)" in combo and "key: r.참조.키," in combo # 다이어그램 참조 카드
for text in (table, pick):
assert len(text.splitlines()) <= 700
assert not re.search(r"""\bel\(\s*["'](button|input|select)["']""", text)
+5 -4
View File
@@ -11,6 +11,7 @@ import pytest
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
@@ -26,15 +27,15 @@ LIB = ("sangeun", "precombo", "labor")
def fresh(world, monkeypatch): # noqa: F811
"""색인 기억 비움 — 시험끼리 안 섞임."""
monkeypatch.setattr(index, "_MEM", {})
monkeypatch.setattr(index, "_IDS_LOADED", [])
monkeypatch.setattr(refs, "_IDS", {})
monkeypatch.setattr(library_uses, "_LOADED", [])
monkeypatch.setattr(library_uses, "_IDS", {})
return world
def _forget():
index._MEM.clear()
index._IDS_LOADED.clear()
refs._IDS.clear()
library_uses._LOADED.clear()
library_uses._IDS.clear()
def _sk(folder, name, extra=None):
@@ -18,6 +18,7 @@ from fastapi import HTTPException
from M02_MasterTemplete import M02_Doc_Router as doc_route
from M02_MasterTemplete import M02_Doc_Sk_Path as path
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Machine_Hourly as mh
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
@@ -104,7 +105,7 @@ def test_save_creates_links_and_stamps(world):
assert f"'개인 {key}'" in text
assert key in [r["키"] for r in saved["단가"]] # 사본에 박힘
assert after["셈"]["계"] == look["셈"]["계"] and after["사본"]["단가새값"] is False
assert _at(me, mym.uses)[key] == [{"키": sk, "이름": "sub1임시"}]
assert _at(me, library_uses.machines)[key] == [{"키": sk, "이름": "sub1임시"}]
def test_same_draft_two_lines(world):
@@ -21,26 +21,3 @@ def test_불러오기_길_층_고정(monkeypatch):
hopyo._root({}, layer, owner, write=True)
hopyo._root({}, layer, owner)
assert seen == [("personal", None, True), ("personal", None, False)] * 3
def test_라우터_루트_모두_고정_함수():
src = (ROOT / "M02_MasterTemplete" / "M02_Hopyo_Router.py").read_text(encoding="utf-8")
assert "import _root as _layer_root" in src
assert "_layer_root(" in src.split("def _root(")[1].split("\n\n")[0]
assert src.count("_layer_root(") == 1 # 층 고르는 길은 이 한 곳뿐
def test_단산_블록_만들기_개인_층만():
src = (ROOT / "M02_MasterTemplete" / "M02_Sangeun_Router.py").read_text(encoding="utf-8")
for fn in ("def sangeun_from_hopyo(", "def sangeun_from_hopyo_preview("):
body = src.split(fn)[1].split("\n@router")[0]
assert "body.층" not in body and "_root(session, layer" not in body, fn
assert '_root(session, "personal", None' in body, fn
def test_화면_층_고름_없음():
m02 = ROOT / "M02_MasterTemplete"
side = (m02 / "M02_MasterTemplete_Hopyo_Side.ts").read_text(encoding="utf-8")
imp = (m02 / "M02_MasterTemplete_Hopyo_Import.ts").read_text(encoding="utf-8")
assert "createSegment" not in side and "writableLayers" not in side + imp
assert '"회사"' not in side + imp and '"마스터"' not in side + imp
+1 -1
View File
@@ -149,7 +149,7 @@ def test_기준_목록_금액_문서_셈():
whole = m01.loaded()[1]
docs, links, _ = world()
for key in ("GF000220", "GC000404", "GX000004"):
for row in st._rows_of(whole, whole.logic(key), False, links):
for row in st._rows_of(whole, docs[key], False, links):
given = st._given(whole, docs[key], row["바꿈"])[0]
want = mc.calc(docs[key], links, given)
assert row["금액"] == round(float(want["계"]), 2), (key, row["규격"])
+111
View File
@@ -0,0 +1,111 @@
"""855-E 2-E4 준비 지킴 — 바탕 기반(`master_base`)만으로 새 계산기가 셈.
- 새 해석기(자식)가 scripts 길만 두고 `master_base` · `master_doc_link` · `master_doc_calc` 를 읽어
견본 로직(기본 + 옵션 표본)을 셈 → 옛 엔진 몸(`master_formula` 무리)이 한 번도 안 읽힘.
- 그 답 지문 = 골든(`golden_855_engine.json` · `test_855_golden` 과 같은 지문 규칙)과 같음.
"""
from __future__ import annotations
import hashlib
import json
import os
import subprocess
import sys
from decimal import Decimal
from pathlib import Path
HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[1]
SCRIPTS = ROOT / "resources" / "master_data" / "scripts"
N = 24 # 견본 로직 수(키 차례 고르게)
ENGINE = ( # 엔진 몸 — 자식에서 읽히면 실패
"master_formula",
"master_formula_check",
"master_formula_sum",
"master_cut",
"master_text",
"master_text_item",
"master_auto",
"master_combo",
"master_sheet_line",
"master_gate",
"master_equation",
"check_master",
)
def _enc(v):
if isinstance(v, Decimal):
return {"$d": str(v)}
raise TypeError(type(v).__name__)
def _dec(d: dict):
return Decimal(d["$d"]) if set(d) == {"$d"} else d
def _child() -> None:
"""자식 — 표준 입력 {키: [[옵션 글, 바뀐 입력]]} → {답: {키: [[옵션 글, 셈 답]]}, 읽힌 엔진: [...]}."""
sys.path.insert(0, str(SCRIPTS))
import master_base as mb
import master_doc_calc as mc
import master_doc_link as ml
import master_machine_files as mmf
folder = Path(os.environ.get("AISLO_MASTER_DIR") or SCRIPTS.parent).resolve()
files = {}
for name in mmf.names(folder): # `M01_MasterData_Store_Cache.loaded` 와 같은 읽기
if name == mmf.NAME and mmf.here(folder):
files[name] = mmf.table(folder)[0]
elif not name.startswith("_"):
raw = (folder / name).read_bytes()
files[name] = json.loads(raw, parse_float=Decimal, parse_int=Decimal)
docs = ml.load_all()
links = ml.Links(mb.Master(files), docs)
want = json.loads(sys.stdin.buffer.read().decode("utf-8"), object_hook=_dec)
out = {}
for key, cases in want.items():
rows = []
for label, changed in cases:
try:
got = mc.calc(docs[key], links, changed)
except Exception:
got = None
rows.append([label, got if got and got.get("셈됨") else None])
out[key] = rows
body = {"답": out, "읽힌 엔진": sorted(m for m in ENGINE if m in sys.modules)}
sys.stdout.buffer.write(json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"))
def test_바탕_기반만으로_새_계산기_지문_골든과_같음():
import helper_855_engine as h
from helper_test_all import spread
rows, _, docs, _ = h.world()
rows = spread([r for r in rows if str(r["키"]) in docs], N)
want = {
str(r["키"]): [[label, changed] for label, _, changed in h.cases(r, True)] for r in rows
}
run = subprocess.run(
[sys.executable, str(Path(__file__)), "--child"],
input=json.dumps(want, ensure_ascii=False, default=_enc).encode("utf-8"),
capture_output=True,
cwd=str(ROOT),
timeout=600,
)
assert run.returncode == 0, run.stderr.decode("utf-8", "replace")[-2000:]
body = json.loads(run.stdout.decode("utf-8"))
assert body["읽힌 엔진"] == [], f"엔진 몸이 읽힘 {body['읽힌 엔진']}"
golden = json.loads((HERE / "golden_855_engine.json").read_text("utf-8"))["지문"]
diff = []
for key, cases in body["답"].items():
got = [[label, h.answer(g)] for label, g in cases]
raw = json.dumps(got, ensure_ascii=False, sort_keys=True)
if hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16] != golden[key]:
diff.append(key)
assert len(body["답"]) == len(rows) and not diff, f"지문 다름 {diff}"
if __name__ == "__main__" and "--child" in sys.argv:
_child()
@@ -0,0 +1,50 @@
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
"""855 L2 ⓑ-1 — 단가산출 값 사본에 M01 로직 줄(GF · GC · GX)을 안 담음 · 옛 저장본의 로직 줄은 안 읽음 ·
일위대가(SC) 값 사본은 로직 줄 담음(프로젝트 사본 묶음이 읽음 — B9-6 뒤 뺌).
임시 storage · 개인 층. 셈 = 수식 문서 사본(`부름`) · 로직 줄 값 사본이 없어도 금액 같음.
"""
from __future__ import annotations
import copy
import json
from decimal import Decimal
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from resources.tester.test_795_1_sk_copy import _doc, _sk
from resources.tester.test_795_2_sc_copy import PCT, _read, _sc
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
def _logic_rows(doc: dict) -> list[str]:
rows = [r for slot in ("수식", "사본") for r in ((doc.get(slot) or {}).get("로직") or [])]
return [str(r["키"]) for r in rows if str(r["키"])[:2] in skc.LOGIC]
def _sum(folder, doc) -> Decimal:
with store.at(folder):
return Decimal(str(calc.run(doc, m01.loaded()[1])["기준"]["계"]))
def test_저장본에_로직줄_없음_금액_같음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
sc = _read(me, "precombo", _sc(me, [{"로직": PCT, "수량": {"손": 1}}]))
assert _logic_rows(sk) == [] and PCT in _logic_rows(sc)
assert _sum(me, sk) > 0
def test_옛_저장본_로직줄은_안_읽음(world):
me = world["personal"]
sk = _doc(me, _sk(me, 바탕={"로직": PCT}))
was = _sum(me, sk)
old = copy.deepcopy(sk) # 옛 꼴 — 값 사본에 바탕 로직 줄(값을 틀리게 바꾼 것)
row = json.loads(json.dumps(m01.loaded()[1].logic(PCT), default=str))
row["호표"] = row["호표"][:1]
old["수식"]["로직"] = [*old["수식"]["로직"], row]
assert skc.held(old)["로직"] == skc.held(sk)["로직"]
assert _sum(me, old) == was
+37 -9
View File
@@ -2,10 +2,11 @@
"""PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`).
① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 0(856-2) · 숨은 상세 몸 DOM · 줄 쌓기 그림
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 = 안내 · 프로젝트 사본 = 보기만(856-3)
③ 머리 띠(까닭 · M01 개정 · 빠진 줄)가 뜨는 경우 — 줄 쌓기 셈 답 · 사본 표지 견본(856-2 · 짝 잃음 = 덮개 없음)
④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기
⑤ 줄 쌓기 [+ 줄] 찾아 넣기 — 빈 낱말로 열어도 종류마다 서버 찾기 · 목록이 그려짐(856-F)
⑥ 머리 칸 고침 — 이름 · 단위 change 뒤 머리 칸 그대로(Tab 으로 옮긴 다음 칸 초점 유지 · 856-G) · 환산만 새로
"""
from __future__ import annotations
@@ -44,20 +45,37 @@ def test_sk_page_open_calls_and_hidden_body() -> None:
def test_labor_row_click() -> None:
sk, logic = _run()["labor"]
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 · 고칠 수 있음([저장] 있음)
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
assert sk["stack"]["draws"] == ["SK-000010"] and sk["calc"] == 0
# M01 로직 줄 = 줄 모달(안내 한 줄) · 상세 몸 · 줄 쌓기 · 셈 없음(856-1)
assert logic["skModal"] == 0 and logic["stack"] is None
assert logic["body"] == 0 and logic["banners"] == ["info"] and logic["calc"] == 0
assert sk["admin"] is True and sk["save"] == 1 and sk["files"] == {"reads": 1, "saves": 0}
# M01 로직 줄 = 창 없음 · 안내 알림 한 줄(856-3) · 셈 없음
assert logic["modal"] is None and logic["stack"] is None
assert logic["toasts"] == ["info"] and logic["calc"] == 0
def test_labor_row_click_inject() -> None:
sk, logic = _run()["labor_inject"]
# 셈 주입(프로젝트 사본) = 줄 모달 · 안내 한 줄(856-3 까지) · 셈 없음
for row in (sk, logic):
assert row["modal"] and row["stack"] is None
assert row["body"] == 0 and row["banners"] == ["info"] and row["calc"] == 0
# 셈 주입 원본 층 카드(보기만 표) = 그 층 SK 줄 쌓기 읽기만 · [저장] 없음
assert sk["skModal"] == 1 and sk["stack"]["draws"] == ["SK-000010"]
assert sk["admin"] is False and sk["save"] == 0 and sk["files"]["saves"] == 0
assert logic["modal"] is None and logic["toasts"] == ["info"]
def test_labor_row_click_project_copy() -> None:
got = _run()
sk, logic = got["labor_copy"]
# 856-3 프로젝트 사본 = 그 사본의 굳힌 SK 문서째 줄 쌓기 보기만 — 빈 키 + 문서째(memory) ·
# 고침 칸 잠김 · [저장] 없음 · 층 파일 읽기 · 저장 0 · 서버 셈 길 0
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
assert sk["stack"]["draws"] == [""] and sk["memory"] == [True]
assert sk["admin"] is False and sk["save"] == 0
assert sk["files"] == {"reads": 0, "saves": 0} and sk["calc"] == 0
assert got["labor_copy_asked"] == ["SK-000010"]
assert logic["modal"] is None and logic["toasts"] == ["info"]
# 사본에 그 문서가 없음 = 창 없음 · 알림(error)
none = got["labor_copy_none"][0]
assert none["modal"] is None and none["toasts"] == ["error"]
def test_head_bands() -> None:
@@ -100,3 +118,13 @@ def test_stack_find_lists_each_kind() -> None:
got = find[f"{side}_{kind}"]
assert got["paths"] == paths, (side, kind, got)
assert got["rows"] >= 1, (side, kind, got)
def test_head_edit_keeps_fields() -> None:
got = _run()["head"]
assert got["order"] == ["이름", "단위"]
# 이름 고침 → 머리를 다시 그리지 않음 = Tab 으로 간 단위 칸이 같은 칸(초점 · 타자 유지) · 고침 알림
assert got["afterName"] == {"same": True, "swaps": 0, "dirty": True}
# 단위 고침 → 칸 그대로 · 환산 자리만 새로 그림
assert got["afterUnit"] == {"same": True, "swaps": 1, "shown": 1}
assert got["doc"] == ["고친 이름", "m2"]
+1 -35
View File
@@ -258,8 +258,6 @@ def test_요소_찾기_기계는_구분_상세구분_실림(client: TestClient)
def test_단가_자동_요소_찾기_저장전_시험계산(client: TestClient) -> None:
one = _get(client, "/api/m01/logic", key=LOGIC_KEY)
labor = one["prices"][key_of("LB:1016")]
assert labor["이름"] == "화약취급공" and labor["값"] > 0
found = _get(client, "/api/m01/elements", group="인력", q="보통인부")
assert key_of("LB:1002") in [x["ref"] for x in found["items"]]
tables = _get(client, "/api/m01/elements", group="소요량", q="암발파", limit=5)
@@ -387,21 +385,11 @@ def test_구분_목록(client: TestClient) -> None:
assert steel["details"]
def test_재료_고르기_줄_단가는_검색어_첫째_자재품목의_낮은_값(client: TestClient) -> None:
"""옛 대표 키 줄이 기본 검색어로 바뀜(PLAN 8-3) — 값은 검색어 첫째(옛 대표) 줄의 낮은 값."""
one = _get(client, "/api/m01/logic", key=key_of("GC000628"))
cond = {"구분": "시멘트·골재", "상세구분": "시멘트", "검색어": "시멘트 전국"}
cement = one["prices"][store.cm.mf.cond_text(cond)]
assert cement["ref"] == "MT004176" and cement["값"] > 0 and cement["후보"] >= 1
def test_전력은_계약종별을_골라야_값이_섬(client: TestClient) -> None:
"""후보 조건 「계약종별: 입력」(PLAN 7-4b 뒤 절반 — 품셈재료 간접 없이 호표에 바로 박음) —
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인). 화면 단가 미리보기(_pick_brief)는
구분·상세구분 자리로만 후보를 찾아 지역·계약종별 조건은 아직 못 다뤄 None — 아는 구멍."""
계산은 로직 입력으로 값이 섬(mf.element 로 직접 확인)."""
one = _get(client, "/api/m01/logic", key=key_of("GC000893"))
cond = {"이름": "전력량요금", "계약종별": "입력"}
assert one["prices"][store.cm.mf.cond_text(cond)] is None
assert "전력 계약종별" in {x["이름"] for x in one["logic"]["입력"]}
with pytest.raises(store.cm.mf.FormulaError, match="전력 계약종별"):
store.cm.mf.element(store.cm.master(), cond, {})
@@ -531,25 +519,3 @@ def test_재료_고르기_후보_다섯_값(client: TestClient) -> None:
}
assert first["값"] == 18000 and first["관급"] is True # 조달청 100 은 낮은 값에 안 듦
assert second["ref"] == blank["키"] and second["값"] is None
def test_로직_고르기_줄_단가_미리보기(client: TestClient) -> None:
"""호표 요소가 고르기 조건인 줄 — `prices` 열쇠 = 조건 글 · 후보 수와 값 열 다섯."""
for path in sorted(store.FOLDER.glob("로직_*.json")):
rows = json.loads(path.read_text(encoding="utf-8"))["줄"]
hit = next(
(
(row, item["요소"])
for row in rows
for item in row.get("호표") or []
if isinstance(item.get("요소"), dict)
),
None,
)
if hit:
break
row, cond = hit
got = _get(client, "/api/m01/logic", key=row["키"])
brief = got["prices"][store.cm.mf.cond_text(cond)]
assert brief["조건"] == cond and brief["후보"] >= 1
assert set(brief["값들"]) == set(store.cm.mf.SLOTS)
-58
View File
@@ -1,58 +0,0 @@
"""일위대가 실무자료 화면(PLAN 324-4 · 718-1 · 785-4) — 좌측 판 자리 · 권한 · 불러오기 본 칸 · [끝내기] · 떠남.
옛 확인 창 · 고르기 창 · [로직 추가] 「실무 호표」 · 엑셀 보기 모달 시험은 785-7 에서 지움(판정 화면 = `test_642_6_screen`).
"""
import os
from pathlib import Path
HERE = os.path.dirname(os.path.abspath(__file__))
M02 = Path(HERE).parents[1] / "M02_MasterTemplete"
def _text(name: str) -> str:
return (M02 / name).read_text(encoding="utf-8")
def test_좌측_판_자리와_권한():
side = _text("M02_MasterTemplete_UI_Side.ts")
assert 'import { buildHopyoSection } from "./M02_MasterTemplete_Hopyo_Side";' in side
host = side.split('className: "m02-side__lists ui-sidebar-panel"')[1]
# 716-3 차례 — 일위대가 › 구조물 조합 › 구분선 › 일위대가 불러오기 › 도면 양식
order = ("precomboSec,", "summary,", "createDivider(),", "section(hopyo.title, hopyo.body),")
assert [host.index(k) for k in order] == sorted(host.index(k) for k in order)
assert host.index("section(hopyo.title, hopyo.body),") < host.index("drawing,")
assert "canWrite: opt.canWrite," not in side # 옛 [별칭 장부] 걷음(815-2)
assert "hopyo.paint();" in side.split("function paint(): void {")[1]
hopyo_side = _text("M02_MasterTemplete_Hopyo_Side.ts")
# 718-1 · 785-4 — 제목 = 화면 글 키 · [불러오기] = 구조물 조합 층 단추 꼴 → 바로 파일 고르기 → 본 칸 불러오기 보기
assert 'L("M02_HopyoImport")' in hopyo_side and "일위대가 실무자료" not in hopyo_side
start = hopyo_side.split("const start = createButton({")[1].split("start.title")[0]
assert 'label: "불러오기"' in start and 'start.classList.add("m02-layers__btn");' in start
assert "buildHopyoImport({" in hopyo_side and "Hopyo_Wizard" not in hopyo_side
assert not (M02 / "M02_MasterTemplete_Hopyo_Wizard.ts").exists() # 가운데 상세 페이지 없음
assert "uploadHopyo(" in hopyo_side and "openHopyoSheet" not in hopyo_side
assert "buildHopyoLedger" not in hopyo_side and "data-hopyo-ledger" not in hopyo_side
assert not (M02 / "M02_MasterTemplete_Hopyo_Ledger.ts").exists() # 옛 [별칭 장부] 걷음(815-2)
imp = _text("M02_MasterTemplete_Hopyo_Import.ts")
assert 'accept: ".xls,.xlsx,.estx,.stc"' in hopyo_side # 810-3 · 814-1 원파일도
assert "input.hidden = true;" in hopyo_side
choose = hopyo_side.split("async function choose()")[1].split("input.addEventListener")[0]
assert "input.click();" in choose # 누름 하나 — 바로 파일 고르기 창
assert "writableLayers" not in imp + hopyo_side # 837-1 층 고름 걷음 — 늘 개인 층
assert "uploadHopyo(MINE, file)" in hopyo_side
for gone in ("wantSangeun", "STEPS", "second(", "steps.set", "data-hopyo-sangeun"):
assert gone not in imp + hopyo_side, gone # 중간 걸음 · 단가산출 체크 없음
def test_372_2_저장은_개인_층에_삭제는_화면_층_권한():
"""718-1 — 만들 층 = 올린 층 · [끝내기] 로 올린 파일 지움 → 빈 본 칸(785-4: 엑셀 보기 [삭제] 걷음) ·
743-1 — 떠남(화면 바뀜 · 페이지 닫음) = 쥔 파일 지움."""
imp = _text("M02_MasterTemplete_Hopyo_Import.ts")
open_ = imp.split("m.buildHopyoSheet({")[1].split("});")[0]
assert "target: scope," in open_ and "canWrite: true," in open_
assert "onDeleted" not in imp and "dropButton" not in _text("M02_MasterTemplete_Hopyo_Sheet.ts")
assert "a.onEnded();" in imp and "held = false;" in imp
assert 'addEventListener("pagehide", leave)' in imp and " leave,\n" in imp
panel = _text("M02_MasterTemplete_Hopyo_Side.ts")
assert panel.count("open?.imp?.leave()") == 1 and panel.count("open.imp?.leave()") == 1
@@ -142,16 +142,3 @@ def test_입력이_바뀌면_걸린_고름만_풂_화면_짝():
def _src(name):
with open(os.path.join(HERE, "..", "..", "M02_MasterTemplete", name), encoding="utf-8") as f:
return f.read()
def test_로직_자재_줄_누름은_그_로직_옵션_모달_사용자_줄은_그대로():
"""148-1 — 고칠 때 · 읽기만 둘 다 `open: openRow` · 바꾸기 단추 칸은 swap 있을 때만 · 사용자 줄 = openMat."""
# 806-1 — 조합 · 서고 모두 일위대가표 부품 — 로직 자재 바꾸기 · 세 칸은 줄 모달(`Labor_RowModal`) 안
modal = _src("M02_MasterTemplete_Labor_RowModal.ts")
assert (
"open: () => undefined," in modal and "swap: (_r: number, at: number, key: string)" in modal
)
mats = _src("M02_MasterTemplete_Labor_LogicMats.ts")
assert "const tools = swap" in mats
assert 'tr.addEventListener("click", () => on.open(r))' in mats
assert '${on ? " is-open" : ""}' in mats
@@ -118,15 +118,6 @@ def _src(name):
def test_화면_칸_부품_사용자_줄_로직_줄_같은_칸():
marks = _src("M02_MasterTemplete_Labor_MatMarks.ts")
assert '"—"' not in marks # 「—」 항목 없음(162-1)
assert "e.stopPropagation()" in marks # 줄 누름과 따로
rows = _src("M02_MasterTemplete_Labor_MatTable.ts") # 717-3 자재목록 표 나눔
assert "...markCells(mat, on?.mark" in rows and "...markHeads()," in rows
assert "...markCells(" in _src("M02_MasterTemplete_Labor_LogicMats.ts")
modal = _src("M02_MasterTemplete_Labor_RowModal.ts") # 806-1 — 조합 · 서고 모두 줄 모달 안
assert "mark: (_r: number, at: number, key: MatMarkKey, v: string)" in modal
assert "mark: (_i, key, v) =>" in modal
# 서버 허용 값 = 화면 허용 값
api = _src("M02_MasterTemplete_Labor_Api.ts")
for key, allowed in labor.MARKS.items():
+5 -2
View File
@@ -13,6 +13,7 @@ import pytest
from M02_MasterTemplete import M02_Labor_Doc as labor
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_labor_calc_mirror import _same, _ts
@@ -324,10 +325,12 @@ def test_쓰는_곳_기억은_파일을_고치면_다시_읽음_818_1(world):
ref = {**SYS, "키": sc}
with store.at(world["personal"]):
store.write("labor", "x1", "", {"열": "x1", "담은로직": [{"참조": ref}], "자재": []})
assert len(refs.users(ref)) == 1 and refs.users(ref) == refs.users(ref, refs.use_files())
assert len(library_uses.users(ref)) == 1 and library_uses.users(ref) == library_uses.users(
ref, library_uses.files()
)
ver = store.read("labor", "x1")["판"]
store.write("labor", "x1", ver, {"열": "x1", "담은로직": [], "자재": []})
assert refs.users(ref) == []
assert library_uses.users(ref) == []
def test_복사는_못_읽는_참조를_같이_복사_본뜬(world):