From 5e86f705a312b4caed1a5f9f4ab9fe9cc88fc84c Mon Sep 17 00:00:00 2001 From: umsangdon Date: Sat, 10 Oct 2026 13:00:34 +0900 Subject: [PATCH] =?UTF-8?q?feat(b09):=20=EC=84=A4=EA=B3=84=EB=82=B4?= =?UTF-8?q?=EC=97=AD=EC=84=9C=20=EC=9E=90=EC=9C=A0=20=ED=8E=B8=EC=A7=91=20?= =?UTF-8?q?=ED=99=94=EB=A9=B4=20=E2=80=94=20=EB=AA=A8=EB=93=A0=20=EC=A4=84?= =?UTF-8?q?=20=EC=9A=B0=ED=81=B4=EB=A6=AD=20=EB=A9=94=EB=89=B4=20=C2=B7=20?= =?UTF-8?q?=EC=9E=90=EB=8F=99=20=EC=A4=84=20=EC=B9=B8=20=EB=8D=AE=EA=B0=9C?= =?UTF-8?q?=20=C2=B7=20gone=20=C2=B7=20=EC=9C=84=EB=A1=9C=20=C2=B7=20?= =?UTF-8?q?=EC=95=84=EB=9E=98=EB=A1=9C=20=C2=B7=20=EC=83=88=20=EA=B3=B5?= =?UTF-8?q?=EC=A2=85=20=C2=B7=20=EC=9E=90=EB=8F=99=EA=B0=92=EC=9C=BC?= =?UTF-8?q?=EB=A1=9C=20=C2=B7=20=EA=B3=A0=EC=B9=9C=20=EC=B9=B8=20=EA=B0=95?= =?UTF-8?q?=EC=A1=B0=20=C2=B7=20=EB=82=B4=EC=97=AD=20=EC=B4=88=EA=B8=B0?= =?UTF-8?q?=ED=99=94=20=C2=B7=20=EC=97=B0=EA=B2=B0=20=EA=B3=A0=EB=A5=B4?= =?UTF-8?q?=EA=B8=B0=20=EC=B0=BD=20=EB=96=BC=EC=96=B4=20=EB=83=84(184-3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01SE9MxeXTu2uaDZ55BJowAY --- B09_Estimation/B09_Estimation_UI_Page.css | 5 + B09_Estimation/B09_Estimation_UI_Shell.ts | 18 +- B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts | 63 +- .../B09_Estimation_UI_Tabs_Bill_Edit.ts | 553 +++++++++--------- .../B09_Estimation_UI_Tabs_Bill_Link.ts | 104 ++++ resources/tester/test_184_3_b09_bill_menu.py | 291 +++++++++ 6 files changed, 720 insertions(+), 314 deletions(-) create mode 100644 B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts create mode 100644 resources/tester/test_184_3_b09_bill_menu.py diff --git a/B09_Estimation/B09_Estimation_UI_Page.css b/B09_Estimation/B09_Estimation_UI_Page.css index 67219f9e2..1c800ed2f 100644 --- a/B09_Estimation/B09_Estimation_UI_Page.css +++ b/B09_Estimation/B09_Estimation_UI_Page.css @@ -112,3 +112,8 @@ background: color-mix(in srgb, var(--color-accent) 22%, var(--color-canvas)); font-weight: var(--font-weight-bold); } + +/* 184-3 설계내역서 고친 칸 — 자동 값과 다른 칸(풍선 = 자동 값) */ +.b09-estimation .ui-data-table__table tbody td.is-edited { + background: color-mix(in srgb, var(--color-warning) 22%, var(--color-canvas)); +} diff --git a/B09_Estimation/B09_Estimation_UI_Shell.ts b/B09_Estimation/B09_Estimation_UI_Shell.ts index 7147fe004..12919bfaf 100644 --- a/B09_Estimation/B09_Estimation_UI_Shell.ts +++ b/B09_Estimation/B09_Estimation_UI_Shell.ts @@ -15,6 +15,7 @@ import { createWorkflowLayout } from "@ui/ui_template_workflow_layout"; import { createButton, hideLoadingOverlay, + showConfirmDialog, showLoadingOverlay, showToast, } from "@ui/ui_template_elements"; @@ -297,6 +298,21 @@ export function renderB09Estimation(root: HTMLElement): void { void run("/estimation/prices", "POST", "단가를 지금 M01 값으로 새로 굳혔습니다."), }); refresh.dataset.b09Refresh = ""; + // 184-3 내역 초기화 — 설계내역서 덮개(user.bill) 지우고 바로 저장 → 기본 로직 내역 + const reset = createButton({ + label: "내역 초기화", + variant: "ghost", + onClick: () => + void showConfirmDialog( + "설계내역서에서 고친 칸 · 더한 줄 · 지운 줄 · 차례를 모두 지우고 기본 로직 내역으로 되돌립니다. 바로 저장됩니다.", + "초기화", + ).then((ok) => { + if (!ok) return; + const { bill: _bill, ...rest } = user; + void run("/estimation", "PUT", "설계내역서를 초기값으로 되돌렸습니다.", { user: rest }); + }), + }); + reset.dataset.b09BillReset = ""; const section = document.createElement("section"); section.className = "ui-collapsible ui-sidebar-section ui-sidebar-card"; const heading = document.createElement("h3"); @@ -305,7 +321,7 @@ export function renderB09Estimation(root: HTMLElement): void { section.append(heading, made, refresh); const actions = document.createElement("div"); actions.className = "ui-sidebar-actions"; - actions.append(save); + actions.append(save, reset); const left = document.createElement("div"); left.className = "ui-sidebar-panel b09-options"; left.append(section, actions); diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts index c9e2fce17..c14b71c14 100644 --- a/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts +++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill.ts @@ -1,14 +1,14 @@ /* ============================================================================= * B09_Estimation_UI_Tabs_Bill.ts - * B09 설계내역서 탭(PLAN 145-3) — 실무 엑셀 꼴(공종 · 명칭 · 규격 · 수량 · 단위 · 합계 · 노무 · 재료 · 경비 · 비고). + * B09 설계내역서 탭(PLAN 145-3 · 184-3) — 실무 엑셀 꼴 칸(공종 · 명칭 · 규격 · 수량 · 단위 · 합계 · 노무 · 재료 · 경비 · 비고). * * 값 = `B09_Estimation_Calc_Bill`(조작 중 브라우저 · [저장] 때 서버 정본) - * 고칠 칸 = 관급자재대 조달수수료 율(%) · 항목 수량(166-2 · 덮어쓰기 · 빈칸 = 자동) · - * 손 줄 명칭 · 규격 · 단위 · 수량 · 빈칸 = 「연결 없음」(수량 · 단가 원천 없음) + * 초기값 = 기본 로직이 B08 수량으로 짠 줄 · 모든 줄 고침 · 더함 · 지움 · 옮김 자유(184 · `…_UI_Tabs_Bill_Edit`) + * 고칠 칸 = 항목 줄 명칭 · 규격 · 단위 · 수량 · 묶음 줄 이름 · 조달수수료 율(%) — 자동 줄은 덮개 + * 고친 칸 = 칸 강조(셈 줄 `auto_{칸}` 있음) · 풍선 = 자동 값 * 줄 누름 = 단가를 낸 탭 줄(자재 → 재료비목록표 · 구조물 → 일위대가목록표) - * 우클릭 = 줄 추가 · 지우기 · 연결 · 레벨(`…_UI_Tabs_Bill_Edit`) - * 레벨(182) = 줄 `level`(셈이 냄) → class is-lvN · 글자 크기 · 첫 칸 들여쓰기(CSS) · 묶음 줄 = 이름만 고침 - * 「연결 ▾」 칸(182) = 손 항목 줄만 · 누름 = 우클릭 [연결] 과 같은 메뉴(연결됨 = 호표 번호) + * 레벨 = 줄 `level`(셈이 냄) → class is-lvN · 글자 크기 · 첫 칸 들여쓰기(CSS) + * 「연결 ▾」 칸 = 항목 줄(자재 · 조달수수료 빼고) · 누름 = 우클릭 [연결] 과 같은 메뉴 * ========================================================================== */ import type { DataRow } from "@ui/ui_template_data_table"; @@ -16,25 +16,32 @@ import type { Row } from "./B09_Estimation_Calc_Base"; import { money, parseNumber, qty, text, type TabBuild, type TabId } from "./B09_Estimation_UI_Tabs"; import { billMenu, - editQty, - editText, - handEditable, + editCell, + linkable, openLinkMenu, type BillTable, } from "./B09_Estimation_UI_Tabs_Bill_Edit"; +const TEXT_KEYS = ["name", "spec", "unit"]; + export const buildBill: TabBuild = (ctx): BillTable => { const { sheets, user, setUser } = ctx; const bill: Row = sheets.bill || { rows: [], totals: null }; - const rows: DataRow[] = bill.rows.map((r: Row) => ({ + // 손질 · 메뉴 = 셈 줄 그대로(raw) · 표 = 번호 붙인 이름(no = 레벨 1 · 2 묶음 차례) + const raw: DataRow[] = bill.rows; + const rows: DataRow[] = raw.map((r: Row) => ({ ...r, - connect: r.hand && r.kind === "item" ? `${r.note || "연결"} ▾` : "", + name: r.no ? `${r.no} ${r.name}` : r.name, + connect: linkable(r) ? `${!r.auto && r.note ? r.note : r.ref ? "연결됨" : "연결"} ▾` : "", })); const direct: Row = bill.totals?.direct || {}; const pair = (key: string, label: string) => [ money(`price_${key}`, "단가", [label]), money(key, "금액", [label]), ]; + /** 고친 칸 — 셈 줄에 자동 값(auto_칸)이 있음 · 연결 칸 = auto_ref */ + const edited = (r: DataRow | undefined, key: string): boolean => + !!r && `auto_${key === "connect" ? "ref" : key}` in r; return { columns: [ text("name", "공종 · 명칭", 220), @@ -52,41 +59,45 @@ export const buildBill: TabBuild = (ctx): BillTable => { total: { name: "순공사비 계(관급 제외)", ...direct }, frozen: 1, hint: - "공종 나무 = 엑셀 꼴 고정 · 금액 = ROUNDDOWN(단가 × 수량, 0) 비목마다 · 4 자재대 = 대비표 「별도」 · 관급자재대 = 「관급」 표시 자재 · 조달수수료 율(%)은 수량 칸에 넣음 · " + - "수량 칸 = 덮어쓰기(빈칸 = 자동) · 우클릭 · 「연결 ▾」 = 줄 추가 · 지우기 · 일위대가 · 단가산출 연결(새 산근 단가 = [저장] 뒤) · " + - "레벨 = 우클릭 묶음 줄로 · 하위 줄 추가 · 들여쓰기 · 내어쓰기(묶음 금액 = 아래 항목 합 · 공종 합은 항목만) · " + + "기본 로직이 짠 내역 = 초기값 · 모든 줄 고침 · 더함 · 지움 · 옮김 자유(우클릭 · 고친 칸 = 색 칸 · 풍선 = 자동 값) · " + + "금액 = ROUNDDOWN(단가 × 수량, 0) 비목마다 · 묶음 금액 = 아래 항목 합 · 4 자재대 = 대비표 「별도」 · 관급자재대 = 「관급」 표시 자재(관급자재대 밖으로 못 옮김) · " + + "조달수수료 율(%)은 수량 칸 · 「연결 ▾」 = 일위대가 · 단가산출 연결(새 산근 단가 = [저장] 뒤) · 처음으로 = 왼쪽 [내역 초기화] · " + `빈 줄 ${direct.blank ?? 0} — 계는 아는 금액만 · 원가계산서는 빈 줄이 없을 때만 받음`, editable: (i, key) => { const r = rows[i]; - if (r?.kind === "group") return key === "name"; - if (!r || r.kind !== "item") return false; - return r.hand ? handEditable(key) : key === "qty"; + if (!r) return false; + if (r.key === "fee") return key === "qty"; + if (r.kind !== "item") return key === "name"; + return key === "qty" || TEXT_KEYS.includes(key); }, onEdit: (i, key, value) => { const r = rows[i]; if (!r) return; - if (r.hand && key !== "qty") return editText(ctx, String(r.key), key, value); - if (key !== "qty") return; + // 번호 = 셈이 붙임 — 고친 이름 앞 번호는 뗌 + const head = `${r.no} `; + if (key === "name" && r.no && value.startsWith(head)) value = value.slice(head.length); + if (key !== "qty") return editCell(ctx, raw, i, key, value.trim()); const v = parseNumber(value); if (v === undefined) return; - if (r.key !== "fee") return editQty(ctx, r, v); + if (r.key !== "fee") return editCell(ctx, raw, i, key, v); setUser({ ...user, estimate: { ...(user.estimate || {}), procurement_fee_pct: v } }); }, + cellClass: (i, key) => (edited(rows[i], key) ? "is-edited" : null), tip: (i, key) => { const r = rows[i]; - if (key !== "qty" || !r || !("qty_auto" in r)) return null; - return `자동 값 ${r.qty_auto ?? "빈칸"} — 우클릭 [수량 자동으로 되돌리기]`; + if (!r || !edited(r, key)) return null; + const auto = key === "connect" ? (r.auto_ref as Row | null)?.key : r[`auto_${key}`]; + return `자동 값 ${auto ?? "빈칸"} — 우클릭 [자동값으로 되돌리기]`; }, - // 182 레벨 — 글자 크기 · 들여쓰기(is-lvN) · 제목 · 묶음 줄 굵게 rowClass: (i) => { const r = rows[i]; if (!r) return null; const title = r.kind === "title" ? "is-title" : r.kind === "group" ? "is-group" : ""; - return [`is-lv${r.level ?? 1}`, title, r.hand ? "is-hand" : ""].filter((c) => c).join(" "); + return [`is-lv${r.level ?? 1}`, title, r.auto ? "" : "is-hand"].filter((c) => c).join(" "); }, - menu: (i) => billMenu(ctx, rows, i), + menu: (i) => billMenu(ctx, raw, i), onCell: (i, key) => { - if (key === "connect") openLinkMenu(ctx, rows, i); + if (key === "connect") openLinkMenu(ctx, raw, i); }, link: (i, key) => { if (key === "connect") return null; // 「연결 ▾」 = 메뉴(이동 안 함) diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts index 51e586c27..105b3ff80 100644 --- a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts +++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Edit.ts @@ -1,14 +1,16 @@ /* ============================================================================= * B09_Estimation_UI_Tabs_Bill_Edit.ts - * B09 설계내역서 손질(PLAN 166-2) — 우클릭 메뉴 · 손 줄 더하기 · 지우기 · 연결 고르기 · 수량 덮어쓰기. + * B09 설계내역서 손질(PLAN 166-2 · 182 · 184-3) — 모든 줄 우클릭 메뉴 · 칸 고침 · 연결 · 차례 · 레벨. * - * 저장 = 사용자 값 `user.bill`(캐시 → [저장] 때 `user_values.json`) — 셈은 짝 `Calc_Bill` 이 바로 다시 - * qty{줄 키: 수} = 자동 줄 수량 덮어쓰기(빈칸 · [수량 자동으로] = 키 지움 → B08 값) - * rows[] = 손 줄 {key hand:… · section · after(앞 줄 키 · 제목 = sec:공종) · 명칭 · 규격 · 단위 · 수량 · ref} - * 연결 = 있는 호표(일위대가목록표 dg · 단가산출근거목록표 sg) · M01 로직(새 산근 = 서버 셈 · [저장] 뒤 단가) - * 우클릭 = 공용 메뉴(`ui_template_context_menu` · 화면 고정 자리) · 로직 고르기 · 입력값 = M02 창 재사용 - * 레벨(182) = 손 줄 kind(group = 묶음 줄 · 이름만) · parent(묶음 손 줄 키) — 하위 줄 추가 · 묶음 줄로 · - * 항목으로 · 들여쓰기 · 내어쓰기 · 손 묶음 깊이 2 · 「연결 ▾」 칸 = 우클릭 [연결] 과 같은 메뉴 + * 저장 = 사용자 값 `user.bill` v2(캐시 → [저장] 때 `user_values.json`) — 셈은 짝 `Calc_Bill` 이 바로 다시 + * {v: 2, rows: [표 차례 {key · parent(없음 = 맨 위) · 고친 칸만}], gone: [지운 자동 줄 키]} + * 자동 줄 = 키 · 부모 + 고친 칸(name · spec · unit · qty · ref · null = 일부러 빈칸 · 없음 = 원천) + * 새 줄 = hand:… · 모든 칸 + kind group(묶음) | 없음 = 항목 · 새 공종 = 맨 위 묶음 · cost direct + * 첫 손질 = 보이는 줄의 키 · 부모 · 차례만 v2 로 굳힘(옛 꼴 qty · 손 줄 칸은 옮김 · 자동 값은 안 옮김) + * 계약 = `Calc_Bill.py` 머리 — 셈 출력 줄 parent · auto(기본 로직 줄) · auto_{칸}(고친 칸의 자동 값) · level · + * 막음 = 조달수수료 · 관급자재대 제목 옮기기 · 지우기 · 자재(mat:) 줄 맨 위 묶음 돈 갈래(관급 · 직접비) + * 바뀌는 옮김 · 자재 줄 지우기(주인 = 대비표 표시) · 깊이 5 넘음 · 자식 있는 맨 위 묶음 지우기 + * 연결 고르기 창 = `…_UI_Tabs_Bill_Link` · 우클릭 = 공용 메뉴(`ui_template_context_menu` · 화면 고정 자리) * ========================================================================== */ import type { DataRow } from "@ui/ui_template_data_table"; @@ -17,322 +19,300 @@ import { type MapContextMenu, type MapContextMenuItem, } from "@ui/ui_template_context_menu"; -import { showToast } from "@ui/ui_template_elements"; -import { createFindList } from "@ui/ui_template_find_list"; -import { openModal } from "@ui/ui_template_modal"; -import { fetchLogicInputs } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api"; -import { openLaborInput } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Input"; -import { openLogicPicker } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Pick"; import type { Row } from "./B09_Estimation_Calc_Base"; import type { TabContext, TabTable } from "./B09_Estimation_UI_Tabs"; +import { linkItems, type ApplyRef } from "./B09_Estimation_UI_Tabs_Bill_Link"; /** 설계내역서 표 = 탭 표 + 줄 우클릭 메뉴 */ export type BillTable = TabTable & { menu?: (index: number) => MapContextMenuItem[] }; const NEW_NAME = "새 줄"; -const TEXT_KEYS = ["name", "spec", "unit"]; -/** 182 손 묶음 깊이 — 묶음 안 묶음까지 */ -const MAX_GROUP = 2; +const NEW_SECTION = "새 공종"; +/** 고칠 칸 — 자동 줄은 덮개 */ +const FIELDS = ["name", "spec", "unit", "qty", "ref"]; +/** 깊이 한도 — 1 = 맨 위 공종 */ +const MAX_LEVEL = 5; interface Bill { - qty: Record; + v: 2; rows: Row[]; + gone: string[]; } -function billOf(user: Row): Bill { +/** 손질 한 번 = 굳힌 덮개 + 보이는 줄(키 → 셈 출력 줄) */ +interface Work { + bill: Bill; + shown: Map; +} + +/** 옮기기 · 지우기 · 연결 없는 줄 — 조달수수료 · 관급자재대 제목 */ +const fixed = (key: string): boolean => key === "fee" || key === "sec:G"; + +/** 연결 ▾ 있는 줄 — 항목 줄(자재 = 대비표 단가 · 조달수수료 = 율 빼고) */ +export const linkable = (row: DataRow | undefined): boolean => + row?.kind === "item" && !fixed(String(row.key)) && !String(row.key).startsWith("mat:"); + +const find = (list: Row[], key: string): number => list.findIndex((e) => e.key === key); +const pull = (list: Row[], key: string): Row => list.splice(find(list, key), 1)[0]; +const same = (a: unknown, b: unknown): boolean => + JSON.stringify(a ?? null) === JSON.stringify(b ?? null); + +/** 옛 꼴(166-2 · 182) 줄 → v2 칸 — 자동 줄 = 수량 덮어쓰기 · 손 줄 = 모든 칸 */ +function oldEntry(row: DataRow, bill: Row): Row { + const key = String(row.key); + if (row.auto) return key in (bill.qty || {}) ? { qty: bill.qty[key] } : {}; + const hand: Row = (bill.rows || []).find((h: Row) => h.key === key) || {}; + const out: Row = row.kind === "item" ? {} : { kind: "group" }; + for (const f of FIELDS) if (f in hand) out[f] = hand[f]; + return out; +} + +/** 굳힘 — v2 면 그대로 + 덮개에 없는 보이는 줄(새 자동 줄)을 보이는 앞 줄 뒤에 · 옛 꼴이면 보이는 줄로 */ +function freeze(user: Row, rows: DataRow[]): Work { const bill: Row = user.bill || {}; - return { qty: { ...(bill.qty || {}) }, rows: (bill.rows || []).map((r: Row) => ({ ...r })) }; + const v2 = bill.v === 2; + const list: Row[] = v2 ? (bill.rows || []).map((e: Row) => ({ ...e })) : []; + const gone: string[] = v2 ? [...(bill.gone || [])] : []; + const shown = new Map(rows.map((r) => [String(r.key), r])); + let prev = -1; + for (const row of rows) { + const key = String(row.key); + if (key === "fee") continue; // 셈이 관급 묶음 끝에 둠 + let at = find(list, key); + if (at < 0 && !gone.includes(key)) { + const entry: Row = { key, ...(row.parent ? { parent: row.parent } : {}) }; + list.splice(prev + 1, 0, v2 ? entry : { ...entry, ...oldEntry(row, bill) }); + at = prev + 1; + } + if (at >= 0) prev = at; + } + return { bill: { v: 2, rows: list, gone }, shown }; } function put(ctx: TabContext, bill: Bill): void { ctx.setUser({ ...ctx.user, bill }); } -/** 손 줄 고칠 칸 — 명칭 · 규격 · 단위 · 수량 */ -export const handEditable = (key: string): boolean => key === "qty" || TEXT_KEYS.includes(key); - -/** 수량 고침 — 손 줄 = 그 줄 수량 · 자동 줄 = 덮어쓰기(빈칸 = 자동으로) */ -export function editQty(ctx: TabContext, row: DataRow, value: number | null): void { - const bill = billOf(ctx.user); - const key = String(row.key); - if (row.hand) { - const own = bill.rows.find((h) => h.key === key); - if (!own) return; - own.qty = value; - } else if (value === null) delete bill.qty[key]; - else bill.qty[key] = value; - put(ctx, bill); -} - -/** 손 줄 글 칸(명칭 · 규격 · 단위) */ -export function editText(ctx: TabContext, key: string, field: string, value: string): void { - const bill = billOf(ctx.user); - const own = bill.rows.find((h) => h.key === key); - if (!own || !TEXT_KEYS.includes(field)) return; - own[field] = value.trim(); - put(ctx, bill); -} - -const lv = (row: DataRow | undefined): number => Number(row?.level ?? 0); - -/** 줄 i 자손 끝(다음 줄 번호) — 더 깊은 레벨 줄이 이어지는 데까지 */ -function subtreeEnd(rows: DataRow[], i: number): number { - let k = i + 1; - while (k < rows.length && lv(rows[k]) > lv(rows[i])) k += 1; - return k; -} - -/** 부모 바꿈 — 없음 = 공종 바로 아래(키 지움) */ -function reparent(h: Row, parent: unknown): void { - if (parent) h.parent = parent; - else delete h.parent; -} - -/** 손 묶음 깊이 지킴 — 묶음 줄 위 묶음 ≤ 1 · 항목 위 묶음 ≤ 2(도는 부모는 셈이 끊음 · 여기선 멈춤) */ -function fits(bill: Bill): boolean { - const byKey = new Map(bill.rows.map((h) => [String(h.key), h])); - return bill.rows.every((h) => { - let n = 0; - const seen = new Set([h.key]); - let at = byKey.get(String(h.parent ?? "")); - while (at && at.kind === "group" && !seen.has(at.key)) { - seen.add(at.key); - n += 1; - at = byKey.get(String(at.parent ?? "")); - } - return n <= (h.kind === "group" ? MAX_GROUP - 1 : MAX_GROUP); - }); -} - -/** 새 줄 자리 — 공종 · 앞 줄 키(위 = 앞 줄 · 공종 첫 줄이면 제목 sec:공종 · 아래 = 자손 끝) · 부모 = 그 줄 부모 */ -function slot(rows: DataRow[], i: number, below: boolean): Row { - const row = rows[i]; - const section = String(row.section); - if (row.kind === "title") return { section, after: `sec:${section}` }; - const parent = row.hand && row.parent ? { parent: String(row.parent) } : {}; - if (below) return { section, after: String(rows[subtreeEnd(rows, i) - 1].key), ...parent }; - const prev = rows[i - 1]; - const same = prev && prev.kind !== "title" && prev.section === section; - return { section, after: same ? String(prev.key) : `sec:${section}`, ...parent }; -} - -function newRow(ctx: TabContext, at: Row): void { - const bill = billOf(ctx.user); - const key = `hand:${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`; - bill.rows.push({ key, ...at, name: NEW_NAME, spec: "", unit: "", qty: null, ref: null }); - put(ctx, bill); -} - -function addRow(ctx: TabContext, rows: DataRow[], i: number, below: boolean): void { - newRow(ctx, slot(rows, i, below)); -} - -/** 묶음 줄 아래 하위 줄 — 자리 = 마지막 자손 뒤 */ -function addChild(ctx: TabContext, rows: DataRow[], i: number): void { - const after = String(rows[subtreeEnd(rows, i) - 1].key); - newRow(ctx, { section: String(rows[i].section), after, parent: String(rows[i].key) }); -} - -/** 손 줄 지움 — 그 줄 뒤에 붙던 손 줄은 지운 줄 자리로 · 자식은 지운 줄 부모로 옮김 */ -function removeRow(ctx: TabContext, key: string): void { - const bill = billOf(ctx.user); - const gone = bill.rows.find((h) => h.key === key); - if (!gone) return; - bill.rows = bill.rows.filter((h) => h.key !== key); - for (const h of bill.rows) if (h.after === key) h.after = gone.after; - for (const h of bill.rows) if (h.parent === key) reparent(h, gone.parent); - put(ctx, bill); -} - -/** 레벨 바꿈 — 깊이 한도 안이면 [동작] · 넘으면 null(메뉴에 안 보임) */ -function levelAction( - ctx: TabContext, - key: string, - change: (own: Row, bill: Bill) => void, -): (() => void) | null { - const bill = billOf(ctx.user); - const own = bill.rows.find((h) => h.key === key); - if (!own) return null; - change(own, bill); - return fits(bill) ? () => put(ctx, bill) : null; -} - -/** 들여쓰기 대상 — 바로 위 같은 레벨 형제가 같은 공종 묶음 줄이면 그 줄 */ -function indentTarget(rows: DataRow[], i: number): DataRow | null { - const row = rows[i]; - for (let j = i - 1; j >= 0; j -= 1) { - const r = rows[j]; - if (lv(r) > lv(row)) continue; - return lv(r) === lv(row) && r.kind === "group" && r.section === row.section ? r : null; +/** 위로 올라가는 줄 — [자기, 부모, …, 맨 위] */ +function chain(list: Row[], key: string): Row[] { + const out: Row[] = []; + let at: Row | undefined = list[find(list, key)]; + while (at && out.length <= list.length) { + out.push(at); + at = at.parent ? list[find(list, at.parent)] : undefined; } - return null; -} - -/** 레벨 메뉴 — 묶음 줄로 · 항목으로 · 들여쓰기 → · 내어쓰기 ←(막내만 · 자리 안 어긋남) */ -function levelMenu(ctx: TabContext, rows: DataRow[], i: number): MapContextMenuItem[] { - const row = rows[i]; - const key = String(row.key); - const out: MapContextMenuItem[] = []; - const add = (label: string, action: (() => void) | null): void => { - if (action) out.push([label, action]); - }; - if (row.kind === "group") - add( - "항목으로 바꾸기", - levelAction(ctx, key, (own, bill) => { - delete own.kind; - for (const h of bill.rows) if (h.parent === key) reparent(h, own.parent); - }), - ); - else - add( - "묶음 줄로 바꾸기", - levelAction(ctx, key, (own) => Object.assign(own, { kind: "group", qty: null, ref: null })), - ); - const target = indentTarget(rows, i); - if (target) - add( - "들여쓰기 →", - levelAction(ctx, key, (own) => reparent(own, String(target.key))), - ); - if (row.parent && lv(rows[subtreeEnd(rows, i)]) < lv(row)) - add( - "내어쓰기 ←", - levelAction(ctx, key, (own, bill) => - reparent(own, bill.rows.find((h) => h.key === row.parent)?.parent), - ), - ); return out; } -/** 연결 — 명칭이 비었거나 「새 줄」이면 고른 호표 명칭 · 규격 · 단위를 채움 */ -function setRef(ctx: TabContext, key: string, ref: Row | null, from?: Row): void { - const bill = billOf(ctx.user); - const own = bill.rows.find((h) => h.key === key); - if (!own) return; - own.ref = ref; - if (from && (!own.name || own.name === NEW_NAME)) { - own.name = from.name || own.name; - own.spec = own.spec || from.spec || ""; - own.unit = own.unit || from.unit || ""; - } - put(ctx, bill); +/** 차례 바로잡음 — 부모 먼저 · 자손 이어서(목록 차례 = 형제 차례) · 못 찾는 부모 · 돎 = 맨 위 */ +function tidy(list: Row[]): Row[] { + const keys = new Set(list.map((e) => e.key)); + for (const e of list) if (!e.parent || !keys.has(e.parent)) delete e.parent; + for (const e of list) if (chain(list, e.key).length > list.length) delete e.parent; + const out: Row[] = []; + // ponytail: 형제 찾기 O(n²) — 내역 줄 수(수백)면 충분 + const walk = (parent?: string): void => { + for (const e of list) + if (e.parent === parent) { + out.push(e); + walk(e.key); + } + }; + walk(); + return out; } -/** 있는 호표 고르기 창 — 일위대가목록표(dg) · 단가산출근거목록표(sg) */ -function pickHopyo(ctx: TabContext, key: string, tab: "dg" | "sg"): void { - const listing: Row[] = (tab === "dg" ? ctx.sheets.daega : ctx.sheets.sg_list) || []; - if (!listing.length) return showToast("고를 호표 없음 — 연결된 구조물 조합 사본이 없음", "error"); - const label = (r: Row): string => (tab === "dg" ? `대가${r.no}` : `산근 ${r.no}호표`); - openModal({ - title: tab === "dg" ? "일위대가 호표 고르기" : "단가산출 호표 고르기", - closeLabel: "닫기", - mount: (body, close) => { - const finder = createFindList({ placeholder: "호표 · 명칭 · 규격 찾기" }); - const find = (): void => { - const q = finder.search.value.trim().toLowerCase(); - const found = listing.filter( - (r) => !q || `${label(r)} ${r.name} ${r.spec}`.toLowerCase().includes(q), - ); - finder.hint.textContent = `${found.length} / ${listing.length}`; - finder.setRows( - found.map((r) => ({ - key: String(r.key), - tag: label(r), - name: String(r.name || ""), - sub: String(r.spec || ""), - unit: String(r.unit || ""), - onPick: () => { - close(); - setRef(ctx, key, { tab, key: r.key }, r); - }, - })), - ); - }; - finder.search.addEventListener("input", find); - find(); - body.append(finder.root); - requestAnimationFrame(() => finder.search.focus()); - }, - }); +/** 맨 위 묶음 돈 갈래 — direct(직접비) | supply(관급자재대) */ +function costOf(w: Work, list: Row[], key: string): string { + const top = chain(list, key).at(-1); + return top?.cost ?? w.shown.get(String(top?.key))?.cost ?? "direct"; } -/** M01 로직 → 입력값 창 → 손 줄 연결(새 산근 · 단가는 [저장] 뒤 서버 셈) */ -function askInputs(ctx: TabContext, key: string, code: string, name: string, old?: Row): void { - fetchLogicInputs([code]).then( - (got) => { - const logic = got.로직[0] ?? null; - openLaborInput({ - title: `${code} ${name}`.trim(), - logic, - values: old?.given || {}, - memo: null, - rate: old?.rate ?? null, - readOnly: false, - okLabel: "연결", - notice: "새 산근 = 단가산출근거 뒤 번호 · 단가는 [저장] 뒤 서버가 셈", - done: (next) => { - const unit = String(logic?.결과단위 || "") - .replace(/^원\//, "") - .replace(/^[\d.]+/, ""); - const ref = { tab: "logic", code, name, given: next.입력값, rate: next.켜쌓기율 }; - setRef(ctx, key, { ...ref, picks: old?.picks ?? null }, { name, unit }); - showToast("연결함 — 새 산근 단가는 [저장] 뒤에 채워짐", "success"); - }, - }); - }, - (error: unknown) => showToast(`로직 입력을 못 읽음 — ${String(error)}`, "error"), +/** 바꾼 뒤 지킬 것 — 깊이 5 · 자재 줄 돈 갈래 그대로 */ +function fits(w: Work, before: Row[]): boolean { + return w.bill.rows.every( + (e) => + chain(w.bill.rows, e.key).length <= MAX_LEVEL && + (!String(e.key).startsWith("mat:") || + costOf(w, w.bill.rows, e.key) === costOf(w, before, e.key)), ); } -function pickLogic(ctx: TabContext, key: string): void { - openLogicPicker((logic) => askInputs(ctx, key, logic.키, logic.이름)); +/** 손질 시도 — 지킬 것 안이면 [동작] · 아니면 null(메뉴에 안 보임) */ +function attempt( + ctx: TabContext, + rows: DataRow[], + change: (w: Work) => boolean | void, +): (() => void) | null { + const w = freeze(ctx.user, rows); + const before = w.bill.rows.map((e) => ({ ...e })); + if (change(w) === false) return null; + w.bill.rows = tidy(w.bill.rows); + return fits(w, before) ? () => put(ctx, w.bill) : null; } -type Leaf = [string, () => void]; +const entryOf = (w: Work, key: string): Row | undefined => w.bill.rows[find(w.bill.rows, key)]; +const isGroup = (w: Work, key: string): boolean => + (entryOf(w, key)?.kind ?? w.shown.get(key)?.kind ?? "item") !== "item"; +/** 보이는 형제(차례대로) */ +const siblings = (w: Work, parent: unknown): Row[] => + w.bill.rows.filter((e) => (e.parent ?? null) === (parent ?? null) && w.shown.has(e.key)); -/** 손 항목 줄 연결 — [고르기 셋, 그 밖(로직 입력값 · 연결 풀기)] */ -function linkItems(ctx: TabContext, key: string): [Leaf[], Leaf[]] { - const ref: Row | null = billOf(ctx.user).rows.find((h) => h.key === key)?.ref ?? null; - const more: Leaf[] = []; - if (ref?.tab === "logic") - more.push(["로직 입력값 고치기", () => askInputs(ctx, key, ref.code, ref.name || "", ref)]); - if (ref) more.push(["연결 풀기", () => setRef(ctx, key, null)]); - const picks: Leaf[] = [ - ["일위대가 호표", () => pickHopyo(ctx, key, "dg")], - ["단가산출 호표", () => pickHopyo(ctx, key, "sg")], - ["단가산출 로직(M01 · 새 산근)", () => pickLogic(ctx, key)], - ]; - return [picks, more]; +const newKey = (): string => + `hand:${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`; +const newItem = (parent?: string): Row => ({ + key: newKey(), + ...(parent ? { parent } : {}), + name: NEW_NAME, + spec: "", + unit: "", + qty: null, + ref: null, +}); + +/** 칸 고침 — 자동 줄은 덮개(자동 값과 같으면 덮개 지움) · 새 줄은 그 칸 */ +export function editCell( + ctx: TabContext, + rows: DataRow[], + i: number, + field: string, + value: unknown, +): void { + const row = rows[i]; + if (!row || !FIELDS.includes(field)) return; + const w = freeze(ctx.user, rows); + const e = entryOf(w, String(row.key)); + if (!e) return; + const auto = `auto_${field}` in row ? row[`auto_${field}`] : row[field]; + if (row.auto && same(auto, value)) delete e[field]; + else e[field] = value; + put(ctx, w.bill); } -/** 줄 우클릭 메뉴 — 위 · 아래(· 하위) 줄 추가 · (손 줄) 연결 · 연결 풀기 · 레벨 · 지우기 · (자동 줄) 수량 자동으로 */ +/** 연결 적용 — 새 줄이 「새 줄」 · 빈 이름이면 고른 호표 명칭 · 규격 · 단위를 채움 */ +function applyRef(ctx: TabContext, rows: DataRow[], i: number): ApplyRef { + return (ref, from) => { + const row = rows[i]; + const w = freeze(ctx.user, rows); + const e = entryOf(w, String(row?.key)); + if (!row || !e) return; + e.ref = ref; + if (from && !row.auto && (!e.name || e.name === NEW_NAME)) { + e.name = from.name || e.name; + e.spec = e.spec || from.spec || ""; + e.unit = e.unit || from.unit || ""; + } + put(ctx, w.bill); + }; +} + +/** 줄 연결 메뉴 — 지금 연결 = 덮개(로직 입력값 등) 있으면 덮개 · 없으면 셈 줄 */ +function linkFor(ctx: TabContext, rows: DataRow[], i: number) { + const row = rows[i]; + const e = entryOf(freeze(ctx.user, rows), String(row.key)); + const ref: Row | null = e && "ref" in e ? e.ref : (row.ref ?? null); + return linkItems(ctx, ref, applyRef(ctx, rows, i)); +} + +/** 줄 우클릭 메뉴 — 더함 · 연결 · 옮김 · 레벨 · 자동값으로 · 지움(모든 줄 · 지킬 것 안만) */ export function billMenu(ctx: TabContext, rows: DataRow[], i: number): MapContextMenuItem[] { const row = rows[i]; if (!row) return []; const key = String(row.key); - const bill = billOf(ctx.user); - const items: MapContextMenuItem[] = []; - if (row.kind !== "title") items.push(["위에 줄 추가", () => addRow(ctx, rows, i, false)]); - items.push(["아래에 줄 추가", () => addRow(ctx, rows, i, true)]); - if (row.kind === "group") items.push(["아래에 하위 줄 추가", () => addChild(ctx, rows, i)]); - if (row.hand) { - if (row.kind !== "group") { - const [picks, more] = linkItems(ctx, key); - items.push("-", { label: "연결", children: picks }, ...more); - } - items.push("-", ...levelMenu(ctx, rows, i)); - items.push("-", ["줄 지우기", () => removeRow(ctx, key)]); - } else if (row.kind === "item" && key in bill.qty) { - items.push("-", [ - "수량 자동으로 되돌리기", - () => { - delete bill.qty[key]; - put(ctx, bill); - }, - ]); + const parts: MapContextMenuItem[][] = [[], [], [], []]; + const add = (part: number, label: string, change: (w: Work, e: Row) => boolean | void): void => { + const run = attempt(ctx, rows, (w) => { + // 조달수수료 = 차례에 없음(셈이 관급자재대 끝에 둠) — 부모만 빌림 + const e = entryOf(w, key) ?? (key === "fee" ? { key, parent: row.parent } : undefined); + return e ? change(w, e) : false; + }); + if (run) parts[part].push([label, run]); + }; + + // 더함 — 위 · 아래(같은 부모) · 하위(묶음) · 새 공종(맨 위 · 관급자재대 앞) + add(0, "위에 줄 추가", (w, e) => { + if (!e.parent) return false; + const at = find(w.bill.rows, key); + w.bill.rows.splice(at < 0 ? w.bill.rows.length : at, 0, newItem(e.parent)); + }); + add(0, "아래에 줄 추가", (w, e) => { + if (!e.parent || key === "fee") return false; + w.bill.rows.splice(find(w.bill.rows, key) + 1, 0, newItem(e.parent)); + }); + add(0, "아래에 하위 줄 추가", (w) => { + if (!isGroup(w, key)) return false; + w.bill.rows.push(newItem(key)); + }); + add(0, "새 공종 추가(1단)", (w, e) => { + const list = w.bill.rows; + const from = find(list, key) < 0 ? String(e.parent) : key; + const top = chain(list, from).at(-1)!; + const at = find(list, top.key) + (costOf(w, list, from) === "supply" ? 0 : 1); + list.splice(at, 0, { key: newKey(), kind: "group", cost: "direct", name: NEW_SECTION }); + }); + if (linkable(row)) { + const [picks, more] = linkFor(ctx, rows, i); + parts[1].push({ label: "연결", children: picks }, ...more); } - return items; + // 옮김 · 레벨 — 같은 부모 형제와 자손째 + if (!fixed(key)) { + add(2, "위로 ↑", (w, e) => { + const sib = siblings(w, e.parent); + const k = sib.indexOf(e); + if (k < 1) return false; + pull(w.bill.rows, key); + w.bill.rows.splice(find(w.bill.rows, sib[k - 1].key), 0, e); + }); + add(2, "아래로 ↓", (w, e) => { + const sib = siblings(w, e.parent); + const k = sib.indexOf(e); + if (k < 0 || k + 1 >= sib.length) return false; + pull(w.bill.rows, key); + w.bill.rows.splice(find(w.bill.rows, sib[k + 1].key) + 1, 0, e); + }); + add(2, "들여쓰기 →", (w, e) => { + const sib = siblings(w, e.parent); + const up = sib[sib.indexOf(e) - 1]; + if (!up || !isGroup(w, up.key)) return false; + e.parent = up.key; + w.bill.rows.push(pull(w.bill.rows, key)); + }); + add(2, "내어쓰기 ←", (w, e) => { + const up = e.parent ? entryOf(w, e.parent) : undefined; + if (!up?.parent) return false; // 맨 위로는 안 냄(새 공종 = 메뉴) + e.parent = up.parent; + pull(w.bill.rows, key); + w.bill.rows.splice(find(w.bill.rows, up.key) + 1, 0, e); + }); + } + if (!row.auto && row.kind === "item") + add(2, "묶음 줄로 바꾸기", (_w, e) => { + Object.assign(e, { kind: "group", qty: null, ref: null }); + }); + if (!row.auto && row.kind !== "item") + add(2, "항목으로 바꾸기", (w, e) => { + if (!e.parent) return false; + delete e.kind; + for (const c of w.bill.rows) if (c.parent === key) c.parent = e.parent; + }); + // 자동값으로 — 그 줄 고친 칸 지움(차례 · 부모는 그대로) + if (row.auto && FIELDS.some((f) => `auto_${f}` in row)) + add(3, "자동값으로 되돌리기", (_w, e) => { + for (const f of FIELDS) delete e[f]; + }); + // 지움 — 자식은 지운 줄 부모로 · 자동 줄 = gone · 자식 있는 맨 위 묶음은 못 지움 + if (!fixed(key) && !key.startsWith("mat:")) + add(3, "줄 지우기", (w, e) => { + const list = w.bill.rows; + if (!e.parent && list.some((c) => c.parent === key)) return false; + for (const c of list) if (c.parent === key) c.parent = e.parent; + pull(list, key); + if (row.auto) w.bill.gone.push(key); + }); + const out: MapContextMenuItem[] = []; + for (const part of parts) + if (part.length) out.push(...(out.length ? ["-" as const] : []), ...part); + return out; } let shared: MapContextMenu | null = null; @@ -341,10 +321,9 @@ let lastCell: Element | null = null; /** 「연결 ▾」 칸 누름(182) — 우클릭 [연결] 과 같은 메뉴를 그 칸 아래에 엶 */ export function openLinkMenu(ctx: TabContext, rows: DataRow[], i: number): void { - const row = rows[i]; const box = lastCell?.getBoundingClientRect(); - if (!shared || !box || !row?.hand || row.kind !== "item") return; - const [picks, more] = linkItems(ctx, String(row.key)); + if (!shared || !box || !linkable(rows[i])) return; + const [picks, more] = linkFor(ctx, rows, i); shared.open(box.left, box.bottom, more.length ? [...picks, "-", ...more] : picks); } diff --git a/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts new file mode 100644 index 000000000..4bd17684e --- /dev/null +++ b/B09_Estimation/B09_Estimation_UI_Tabs_Bill_Link.ts @@ -0,0 +1,104 @@ +/* ============================================================================= + * B09_Estimation_UI_Tabs_Bill_Link.ts + * B09 설계내역서 연결 고르기(166-2 · 184-3) — 있는 호표(일위대가목록표 dg · 단가산출근거목록표 sg) · + * M01 로직(새 산근 = 서버 셈 · [저장] 뒤 단가) · 로직 입력값 고치기 · 연결 풀기. + * + * 줄에 적는 일 = 부르는 쪽 `apply(ref, from)`(`…_UI_Tabs_Bill_Edit` · 저장 꼴 모름) + * 로직 고르기 · 입력값 = M02 창 재사용 + * ========================================================================== */ + +import { showToast } from "@ui/ui_template_elements"; +import { createFindList } from "@ui/ui_template_find_list"; +import { openModal } from "@ui/ui_template_modal"; +import { fetchLogicInputs } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Api"; +import { openLaborInput } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Input"; +import { openLogicPicker } from "../M02_MasterTemplete/M02_MasterTemplete_Labor_Pick"; +import type { Row } from "./B09_Estimation_Calc_Base"; +import type { TabContext } from "./B09_Estimation_UI_Tabs"; + +/** 연결 적용 — ref = null 이면 풀기 · from = 고른 호표(명칭 · 규격 · 단위 채움) */ +export type ApplyRef = (ref: Row | null, from?: Row) => void; +export type Leaf = [string, () => void]; + +/** 있는 호표 고르기 창 — 일위대가목록표(dg) · 단가산출근거목록표(sg) */ +function pickHopyo(ctx: TabContext, apply: ApplyRef, tab: "dg" | "sg"): void { + const listing: Row[] = (tab === "dg" ? ctx.sheets.daega : ctx.sheets.sg_list) || []; + if (!listing.length) return showToast("고를 호표 없음 — 연결된 구조물 조합 사본이 없음", "error"); + const label = (r: Row): string => (tab === "dg" ? `대가${r.no}` : `산근 ${r.no}호표`); + openModal({ + title: tab === "dg" ? "일위대가 호표 고르기" : "단가산출 호표 고르기", + closeLabel: "닫기", + mount: (body, close) => { + const finder = createFindList({ placeholder: "호표 · 명칭 · 규격 찾기" }); + const find = (): void => { + const q = finder.search.value.trim().toLowerCase(); + const found = listing.filter( + (r) => !q || `${label(r)} ${r.name} ${r.spec}`.toLowerCase().includes(q), + ); + finder.hint.textContent = `${found.length} / ${listing.length}`; + finder.setRows( + found.map((r) => ({ + key: String(r.key), + tag: label(r), + name: String(r.name || ""), + sub: String(r.spec || ""), + unit: String(r.unit || ""), + onPick: () => { + close(); + apply({ tab, key: r.key }, r); + }, + })), + ); + }; + finder.search.addEventListener("input", find); + find(); + body.append(finder.root); + requestAnimationFrame(() => finder.search.focus()); + }, + }); +} + +/** M01 로직 → 입력값 창 → 연결(새 산근 · 단가는 [저장] 뒤 서버 셈) */ +function askInputs(apply: ApplyRef, code: string, name: string, old?: Row): void { + fetchLogicInputs([code]).then( + (got) => { + const logic = got.로직[0] ?? null; + openLaborInput({ + title: `${code} ${name}`.trim(), + logic, + values: old?.given || {}, + memo: null, + rate: old?.rate ?? null, + readOnly: false, + okLabel: "연결", + notice: "새 산근 = 단가산출근거 뒤 번호 · 단가는 [저장] 뒤 서버가 셈", + done: (next) => { + const unit = String(logic?.결과단위 || "") + .replace(/^원\//, "") + .replace(/^[\d.]+/, ""); + const ref = { tab: "logic", code, name, given: next.입력값, rate: next.켜쌓기율 }; + apply({ ...ref, picks: old?.picks ?? null }, { name, unit }); + showToast("연결함 — 새 산근 단가는 [저장] 뒤에 채워짐", "success"); + }, + }); + }, + (error: unknown) => showToast(`로직 입력을 못 읽음 — ${String(error)}`, "error"), + ); +} + +/** 항목 줄 연결 메뉴 — [고르기 셋, 그 밖(로직 입력값 · 연결 풀기)] · ref = 지금 연결 */ +export function linkItems(ctx: TabContext, ref: Row | null, apply: ApplyRef): [Leaf[], Leaf[]] { + const more: Leaf[] = []; + if (ref?.tab === "logic") + more.push(["로직 입력값 고치기", () => askInputs(apply, ref.code, ref.name || "", ref)]); + if (ref) more.push(["연결 풀기", () => apply(null)]); + const picks: Leaf[] = [ + ["일위대가 호표", () => pickHopyo(ctx, apply, "dg")], + ["단가산출 호표", () => pickHopyo(ctx, apply, "sg")], + [ + "단가산출 로직(M01 · 새 산근)", + () => openLogicPicker((logic) => askInputs(apply, logic.키, logic.이름)), + ], + ]; + return [picks, more]; +} diff --git a/resources/tester/test_184_3_b09_bill_menu.py b/resources/tester/test_184_3_b09_bill_menu.py new file mode 100644 index 000000000..c9062f9a3 --- /dev/null +++ b/resources/tester/test_184_3_b09_bill_menu.py @@ -0,0 +1,291 @@ +"""184-3 B09 설계내역서 자유 편집 화면 — 모든 줄 우클릭 메뉴 · 칸 고침 → 덮개 · 지움 → gone · 옮김 · 새 공종 · +자동값으로 · 관급 옮김 막힘 · 깊이 5 · 고친 칸 강조 · [내역 초기화] 배선. + +- 셈 출력 줄 = 계약 꼴(`Calc_Bill.py` 머리 · parent · auto · auto_{칸} · level · no · cost) 가짜 줄 +- 저장 = `user.bill` v2 {v: 2, rows: 표 차례 {key · parent · 고친 칸}, gone} +""" + +import json +import re +import subprocess +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +IMPORTS = re.compile(r"^import[^;]*;\r?\n", re.MULTILINE) + +DG = {"tab": "dg", "key": "DG:a"} + + +def _row(key, parent, level, kind="item", cost="direct", **more): + auto = not key.startswith("hand:") + row = {"key": key, "kind": kind, "parent": parent, "level": level, "cost": cost, "no": "", + "name": key, "spec": "", "unit": "", "qty": None, "ref": None, "note": ""} # fmt: skip + return {**row, **({"auto": True} if auto else {"hand": True}), **more} + + +ROWS = [ + _row("sec:1", None, 1, "title", no="1", name="토공사"), + _row("sec:1.2", "sec:1", 2, "title", no="1.1", name="절토"), + _row("earth:4", "sec:1.2", 3, qty=10, ref={"tab": "sg_list", "key": "D01341"}), + _row("earth:5", "sec:1.2", 3, qty=9, auto_qty=5), + _row("hand:g", "sec:1.2", 3, "group"), + _row("hand:a", "hand:g", 4, ref=DG, note="대가3"), + _row("hand:b", "sec:1.2", 3), + _row("sec:4", None, 1, "title", no="4", name="자재대"), + _row("mat:M1", "sec:4", 2, qty=3), + _row("sec:G", None, 1, "title", "supply", name="관급자재대"), + _row("mat:M2", "sec:G", 2, cost="supply", qty=4), + _row("fee", "sec:G", 2, cost="supply", qty=None), +] +#: 옛 꼴 덮개(166-2 · 182) — 자동 줄 수량 · 손 줄 +OLD = { + "bill": { + "qty": {"earth:5": 9}, + "rows": [ + {"key": "hand:g", "section": "1.2", "after": "earth:5", "kind": "group", "name": "g"}, + {"key": "hand:a", "section": "1.2", "after": "hand:g", "parent": "hand:g", "name": "a", + "qty": 2, "ref": DG}, + {"key": "hand:b", "section": "1.2", "after": "hand:a", "name": "b", "qty": 1}, + ], + } +} # fmt: skip + +MENU_JS = """ +const rows = __ROWS__; +const start = __USER__; +let user = start; +const ctx = { sheets: {}, payload: {}, get user() { return user; }, setUser: (u) => (user = u) }; +const name = (x) => (x === "-" ? "-" : Array.isArray(x) ? x[0] : x.label); +const at = (key) => rows.findIndex((r) => r.key === key); +const labels = (key) => billMenu(ctx, rows, at(key)).map(name); +const run = (key, label) => { + user = start; + const item = billMenu(ctx, rows, at(key)).find((x) => Array.isArray(x) && x[0] === label); + if (!item) return null; + item[1](); + return user.bill; +}; +const edit = (key, field, value) => { + user = start; + editCell(ctx, rows, at(key), field, value); + return user.bill; +}; +const out = { labels: {}, runs: {}, edits: {} }; +for (const key of __LABELS__) out.labels[key] = labels(key); +for (const [key, label] of __RUNS__) out.runs[`${key}|${label}`] = run(key, label); +for (const [key, field, value] of __EDITS__) out.edits[`${key}|${field}`] = edit(key, field, value); +console.log(JSON.stringify(out)); +""" + + +def _node(source: str) -> str: + result = subprocess.run( + ["node", "--experimental-strip-types", "--no-warnings", + "--input-type=module-typescript"], + input=source, capture_output=True, text=True, encoding="utf-8", timeout=60, + ) # fmt: skip + assert result.returncode == 0, result.stderr + return result.stdout + + +def _ts(names: list[str]) -> str: + return "".join( + IMPORTS.sub("", (ROOT / "B09_Estimation" / f"B09_Estimation_{n}.ts").read_text("utf-8")) + for n in names + ) + + +SRC = ["UI_Tabs", "UI_Tabs_Bill_Link", "UI_Tabs_Bill_Edit"] + + +def _menu(user, labels=(), runs=(), edits=(), rows=ROWS): + body = ( + MENU_JS.replace("__ROWS__", json.dumps(rows, ensure_ascii=False)) + .replace("__USER__", json.dumps(user, ensure_ascii=False)) + .replace("__LABELS__", json.dumps(list(labels), ensure_ascii=False)) + .replace("__RUNS__", json.dumps([list(r) for r in runs], ensure_ascii=False)) + .replace("__EDITS__", json.dumps([list(e) for e in edits], ensure_ascii=False)) + ) + return json.loads(_node(_ts(SRC) + body)) + + +def _order(bill): + return [(e["key"], e.get("parent")) for e in bill["rows"]] + + +ORDER = [(r["key"], r["parent"]) for r in ROWS if r["key"] != "fee"] + + +def test_메뉴_모든_줄(): + out = _menu({}, labels=["sec:1", "earth:4", "earth:5", "hand:g", "hand:a", "fee", "mat:M2", + "mat:M1", "sec:G"])["labels"] # fmt: skip + add = ["위에 줄 추가", "아래에 줄 추가"] + # 맨 위 제목 = 하위 줄 · 새 공종 · 아래로(자식 있는 맨 위 = 못 지움) + assert out["sec:1"] == ["아래에 하위 줄 추가", "새 공종 추가(1단)", "-", "아래로 ↓"] + # 자동 항목 = 더함 · 연결 · 옮김 · 지움(고친 칸 없음 = 자동값으로 없음) + assert out["earth:4"] == [*add, "새 공종 추가(1단)", "-", "연결", "연결 풀기", "-", + "아래로 ↓", "내어쓰기 ←", "-", "줄 지우기"] # fmt: skip + assert out["earth:5"] == [*add, "새 공종 추가(1단)", "-", "연결", "-", "위로 ↑", "아래로 ↓", + "내어쓰기 ←", "-", "자동값으로 되돌리기", "줄 지우기"] # fmt: skip + assert out["hand:g"] == [*add, "아래에 하위 줄 추가", "새 공종 추가(1단)", "-", "위로 ↑", + "아래로 ↓", "내어쓰기 ←", "항목으로 바꾸기", "-", "줄 지우기"] # fmt: skip + assert out["hand:a"] == [*add, "새 공종 추가(1단)", "-", "연결", "연결 풀기", "-", "내어쓰기 ←", + "묶음 줄로 바꾸기", "-", "줄 지우기"] # fmt: skip + # 조달수수료 · 관급 자재 = 연결 · 옮김 · 지움 없음 · 관급자재대 제목 = 옮김 · 지움 없음 + assert out["fee"] == ["위에 줄 추가", "새 공종 추가(1단)"] # 조달수수료 = 관급자재대 끝 고정 + assert out["mat:M2"] == [*add, "새 공종 추가(1단)"] + assert out["mat:M1"] == [*add, "새 공종 추가(1단)"] + assert out["sec:G"] == ["아래에 하위 줄 추가", "새 공종 추가(1단)"] + + +def test_칸_고침_덮개_옛_꼴_굳힘(): + out = _menu(OLD, edits=[("earth:4", "name", "절토A"), ("earth:5", "qty", 5), + ("earth:4", "qty", 10), ("earth:4", "spec", None), + ("hand:a", "qty", 7), ("sec:1.2", "name", "절토공")])["edits"] # fmt: skip + bill = out["earth:4|name"] + # 첫 손질 = 보이는 줄 키 · 부모 · 차례로 v2(조달수수료 빼고) · 옛 손 줄 칸 · 수량 덮개 옮김 + assert (bill["v"], bill["gone"], _order(bill)) == (2, [], ORDER) + rows = {e["key"]: e for e in bill["rows"]} + assert rows["earth:4"] == {"key": "earth:4", "parent": "sec:1.2", "name": "절토A"} + assert rows["earth:5"] == {"key": "earth:5", "parent": "sec:1.2", "qty": 9} + assert rows["hand:g"] == {"key": "hand:g", "parent": "sec:1.2", "kind": "group", "name": "g"} + assert rows["hand:a"] == {"key": "hand:a", "parent": "hand:g", "name": "a", "qty": 2, "ref": DG} + assert "section" not in rows["hand:b"] and "after" not in rows["hand:b"] + # 자동 값과 같게 고침 = 덮개 지움 · 안 고친 값 그대로 = 덮개 안 생김 · null = 일부러 빈칸 + assert "qty" not in {e["key"]: e for e in out["earth:5|qty"]["rows"]}["earth:5"] + assert "qty" not in {e["key"]: e for e in out["earth:4|qty"]["rows"]}["earth:4"] + assert {e["key"]: e for e in out["earth:4|spec"]["rows"]}["earth:4"]["spec"] is None + assert {e["key"]: e for e in out["hand:a|qty"]["rows"]}["hand:a"]["qty"] == 7 + assert {e["key"]: e for e in out["sec:1.2|name"]["rows"]}["sec:1.2"]["name"] == "절토공" + + +V2 = {"bill": {"v": 2, "rows": [{"key": k, **({"parent": p} if p else {})} for k, p in ORDER + if k != "hand:b"], "gone": []}} # fmt: skip + + +def test_지움_옮김_새_공종_자동값으로(): + user = {"bill": {**V2["bill"], "rows": [ + {**e, **({"qty": 9} if e["key"] == "earth:5" else {})} for e in V2["bill"]["rows"]]}} # fmt: skip + runs = [("earth:4", "줄 지우기"), ("hand:g", "줄 지우기"), ("earth:5", "위로 ↑"), + ("earth:4", "아래로 ↓"), ("earth:4", "새 공종 추가(1단)"), + ("mat:M2", "새 공종 추가(1단)"), ("earth:5", "자동값으로 되돌리기"), + ("hand:b", "들여쓰기 →"), ("hand:a", "내어쓰기 ←"), ("sec:1.2", "아래에 하위 줄 추가"), + ("earth:4", "위에 줄 추가"), ("hand:a", "묶음 줄로 바꾸기"), ("hand:g", "항목으로 바꾸기"), + ("earth:4", "연결 풀기"), ("earth:4", "내어쓰기 ←"), ("fee", "위에 줄 추가"), + ("fee", "새 공종 추가(1단)")] # fmt: skip + out = _menu(user, runs=runs)["runs"] + keys = lambda b: [k for k, _ in _order(b)] # noqa: E731 + # 덮개에 없는 보이는 줄(hand:b · 새 자동 줄) = 보이는 앞 줄 뒤에 굳힘 + base = keys(out["earth:5|위로 ↑"]) + assert "hand:b" in base and base.index("hand:b") == base.index("hand:a") + 1 + # 지움 — 자동 줄 = gone · 새 줄 = 자식은 지운 줄 부모로 + b = out["earth:4|줄 지우기"] + assert b["gone"] == ["earth:4"] and "earth:4" not in keys(b) + b = out["hand:g|줄 지우기"] + assert b["gone"] == [] and ("hand:a", "sec:1.2") in _order(b) and "hand:g" not in keys(b) + # 위로 · 아래로 = 같은 부모 형제와 자리 바꿈 + for k in ("earth:5|위로 ↑", "earth:4|아래로 ↓"): + got = keys(out[k]) + assert got[got.index("earth:5") + 1] == "earth:4" + # 새 공종 = 맨 위 묶음 · cost direct · 그 맨 위 공종 뒤 / 관급자재대 앞 + b = out["earth:4|새 공종 추가(1단)"] + new = [e for e in b["rows"] if e["key"].startswith("hand:") and e.get("cost")][0] + assert (new["kind"], new["cost"], new["name"], "parent" in new) == ( + "group", "direct", "새 공종", False) # fmt: skip + assert keys(b)[keys(b).index(new["key"]) + 1] == "sec:4" + b = out["mat:M2|새 공종 추가(1단)"] + assert keys(b)[keys(b).index("sec:G") - 1].startswith("hand:") + # 자동값으로 = 고친 칸 지움(차례 · 부모 그대로) + b = out["earth:5|자동값으로 되돌리기"] + assert {e["key"]: e for e in b["rows"]}["earth:5"] == {"key": "earth:5", "parent": "sec:1.2"} + # 들여쓰기 · 내어쓰기 + assert ("hand:b", "hand:g") in _order(out["hand:b|들여쓰기 →"]) + got = _order(out["hand:a|내어쓰기 ←"]) + assert got[got.index(("hand:g", "sec:1.2")) + 1] == ("hand:a", "sec:1.2") + got = _order(out["earth:4|내어쓰기 ←"]) # 1.1 → 1 아래(제목 뒤) + assert got[got.index(("sec:1.2", "sec:1")) + 1 :].index(("earth:4", "sec:1")) >= 0 + # 하위 줄 = 마지막 자식 뒤 · 위에 줄 = 같은 부모 앞 · 새 줄 = kind 없음(항목) + got = out["sec:1.2|아래에 하위 줄 추가"]["rows"] + kids = [e for e in got if e.get("parent") == "sec:1.2"] + assert kids[-1]["name"] == "새 줄" and "kind" not in kids[-1] + got = out["earth:4|위에 줄 추가"]["rows"] + at = [e["key"] for e in got].index("earth:4") + assert (got[at - 1]["name"], got[at - 1]["parent"]) == ("새 줄", "sec:1.2") + a = {e["key"]: e for e in out["hand:a|묶음 줄로 바꾸기"]["rows"]}["hand:a"] + assert (a["kind"], a["qty"], a["ref"]) == ("group", None, None) + got = {e["key"]: e for e in out["hand:g|항목으로 바꾸기"]["rows"]} + assert "kind" not in got["hand:g"] and got["hand:a"]["parent"] == "sec:1.2" + # 자동 줄 연결 풀기 = ref 덮개 null + assert {e["key"]: e for e in out["earth:4|연결 풀기"]["rows"]}["earth:4"]["ref"] is None + # 조달수수료 위 = 관급자재대 마지막 자식(조달수수료는 셈이 끝에 둠) · 새 공종 = 관급자재대 앞 + got = out["fee|위에 줄 추가"]["rows"] + assert (got[-1]["name"], got[-1]["parent"], got[-2]["key"]) == ("새 줄", "sec:G", "mat:M2") + assert keys(out["fee|새 공종 추가(1단)"])[-3].startswith("hand:") # … 새 공종 · sec:G · mat:M2 + + +def test_관급_옮김_막힘_깊이_5(): + # 차례 = 1 · 관급자재대 · 4 자재대(별도 자재 mat:M1) · 새 공종(자재 없음) + order = [*[(k, p) for k, p in ORDER if not k.startswith(("sec:4", "mat:M1"))], + ("sec:4", None), ("mat:M1", "sec:4"), ("hand:n", None)] # fmt: skip + by = {r["key"]: r for r in ROWS} + rows = [by.get(k) or _row(k, None, 1, "group") for k, _ in order] + user = {"bill": {"v": 2, "rows": [{"key": k, **({"parent": p} if p else {})} for k, p in order], + "gone": []}} # fmt: skip + out = _menu(user, labels=["sec:4", "hand:n"], rows=rows)["labels"] + assert "들여쓰기 →" not in out["sec:4"] # 별도 자재가 관급자재대 안으로 → 막음 + assert "들여쓰기 →" in out["hand:n"] # 자재 없는 묶음 = 들여쓰기 됨(위 형제 4 자재대) + # 깊이 5 — 레벨 5 묶음에 하위 줄 · 레벨 5 줄 들여쓰기 = 막음 + deep = [ + _row("sec:1", None, 1, "title"), _row("sec:1.2", "sec:1", 2, "title"), + _row("hand:g", "sec:1.2", 3, "group"), _row("hand:g2", "hand:g", 4, "group"), + _row("hand:g3", "hand:g2", 5, "group"), _row("hand:z", "hand:g2", 5), + ] # fmt: skip + out = _menu({}, labels=["hand:g3", "hand:z", "hand:g2"], rows=deep)["labels"] + assert "아래에 하위 줄 추가" not in out["hand:g3"] and "들여쓰기 →" not in out["hand:z"] + assert "아래에 하위 줄 추가" in out["hand:g2"] + + +TABLE_JS = """ +let user = __USER__; +const ctx = { sheets: { bill: { rows: __ROWS__, totals: null } }, payload: {}, + get user() { return user; }, setUser: (u) => (user = u) }; +const table = buildBill(ctx); +const at = (key) => table.rows.findIndex((r) => r.key === key); +const out = { + names: ["sec:1", "sec:1.2", "earth:4"].map((k) => table.rows[at(k)].name), + connect: ["earth:4", "earth:5", "hand:a", "mat:M1", "fee", "sec:1"].map((k) => table.rows[at(k)].connect), + cls: [["earth:5", "qty"], ["earth:5", "name"], ["earth:4", "qty"]].map(([k, c]) => table.cellClass(at(k), c)), + tip: table.tip(at("earth:5"), "qty"), + edit: [["sec:1", "name"], ["sec:1", "qty"], ["earth:4", "spec"], ["fee", "qty"], ["fee", "name"]] + .map(([k, c]) => table.editable(at(k), c)), + hint: table.hint, +}; +table.onEdit(at("sec:1.2"), "name", "1.1 절토공"); +out.renamed = user.bill.rows.find((e) => e.key === "sec:1.2").name; +console.log(JSON.stringify(out)); +""" + + +def test_표_칸_강조_번호_연결_칸(): + body = TABLE_JS.replace("__ROWS__", json.dumps(ROWS, ensure_ascii=False)).replace( + "__USER__", "{}" + ) + out = json.loads(_node(_ts([*SRC, "UI_Tabs_Bill"]) + body)) + assert out["names"] == ["1 토공사", "1.1 절토", "earth:4"] # 번호 = 셈 no + assert out["connect"] == ["연결됨 ▾", "연결 ▾", "대가3 ▾", "", "", ""] + assert out["cls"] == ["is-edited", None, None] + assert out["tip"] == "자동 값 5 — 우클릭 [자동값으로 되돌리기]" + assert out["edit"] == [True, False, True, True, False] + assert "엑셀 꼴 고정" not in out["hint"] and "내역 초기화" in out["hint"] + assert out["renamed"] == "절토공" # 번호는 떼고 이름만 + + +def test_내역_초기화_배선(): + src = (ROOT / "B09_Estimation" / "B09_Estimation_UI_Shell.ts").read_text("utf-8") + block = src[src.index('label: "내역 초기화"') :] + block = block[: block.index("b09BillReset")] + # 확인 창 → bill 뺀 사용자 값으로 바로 PUT(덮개 빔) · 좌측 단추 줄 + assert "showConfirmDialog(" in block and "if (!ok) return;" in block + assert "const { bill: _bill, ...rest } = user;" in block + assert 'run("/estimation", "PUT"' in block and "{ user: rest }" in block + assert "actions.append(save, reset);" in src