Files
Aislo/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Imported.ts
T
eomsangdonandClaude Opus 5.5 2f3cc52118 refactor(861-2): 영어 글 걷기 ⓓ — M02 글 표 짝 → 한국어 글 하나
- M02 글 표 13 개(호표 · 노무 · 서고 · 단가산출 좌측 · 주 단추) 짝 327 개 → 문자열 하나 · 표 타입 → `string`
- 읽는 곳 `TEXT[k][currentLanguageIndex] ?? TEXT[k][0]` → `TEXT[k]` · 안 쓰게 된 import · 「[한국어, 영어]」 머리 주석 걷음
- 시험: 글 소스를 짝 꼴로 뽑거나 대조하던 4 개(test_860_3 · 721 · 804_7 · m02_labor_promote_flag)를 새 꼴로
- 표 값 대조 327 같음 · typecheck 0 · 관련 시험 132 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 08:57:04 +09:00

289 lines
11 KiB
TypeScript

/* =============================================================================
* M02_MasterTemplete_Hopyo_Imported.ts
* 불러오기 단산 블록 [가져온 식으로 열기] 모달(PLAN 793-3b · 809-1 · 요구 646 · 702) —
* 엑셀 보기 단가산출 탭 목록(`Hopyo_SheetSk`)이 엶 · 경쟁사 로직 그대로(기초로 바꾸기 없음 · 요구 703).
* · 열기 = 미리 보기(835-1 · 요구 852-1 — 층에 안 씀) 서버 `…/sangeun/from-hopyo/preview`(그 블록 → 가져온 식 문서 ·
* 엑셀 단가 그대로 · 같은 내용 SK 가 있으면 그 SK 를 읽음) → 우리 단가산출 화면(`Sangeun_Detail` 시트 · 고침 = 시트 그대로)
* + 머리 판(`Hopyo_ImportedPanel`)
* · [우리 단가로] · [엑셀 단가로] · [이음 고르기] = 서버 `…/sangeun/imported/{price|link}`
* (화면 캐시 문서 고침 · 저장 없음) → 시트 다시 엶
* · [이음 보기](797-2) = 소요량 · 계수 후보 모달(`Hopyo_QtyLinks`) — 고르기 · 버리기 = 서버 `…/imported/{qty|qty-pick|qty-drop}`(기록만 · 금액 그대로)
* · [저장] = 아직 없으면 `…/sangeun/from-hopyo` 몸 `문서`(고친 문서째 SK 만듦 · 재료 고름도 이때 저장) ·
* 있으면 그 SK 저장(서버가 다시 셈) — 보는 동안 디스크 쓰기 없음
* ========================================================================== */
import { createButton } from "@ui/ui_template_button";
import { el, showToast } from "@ui/ui_template_elements";
import { loadingError, showLoading } from "@ui/ui_template_loading";
import { askConfirm, openModal } from "@ui/ui_template_modal";
import { call, readTemplate, saveTemplate } from "./M02_MasterTemplete_Api_Fetch";
import { openFindPicker } from "./M02_MasterTemplete_Find_Pick";
import { askSameFile } from "../A00_Common/line_stack_material";
import { at, type HopyoScope } from "./M02_MasterTemplete_Hopyo_Api";
import { importedPanel, type PanelState } from "./M02_MasterTemplete_Hopyo_ImportedPanel";
import { openQtyLinks, type QtyRow, type QtyTally } from "./M02_MasterTemplete_Hopyo_QtyLinks";
import { mountSangeunDetail } from "./M02_MasterTemplete_Sangeun_Detail";
import {
isImported,
isOldForm,
type ImportedDoc,
type Money4,
} from "./logic/M02_Hopyo_Imported_Model";
const TEXT = {
Title: "가져온 식 단가산출 — 단산{n}",
Reused: "같은 내용 {k} 를 다시 씀",
Made: "{k} 만듦(엑셀 단가 그대로)",
Have: "같은 내용 {k} 가 이미 있음 — 그것을 엶",
Save: "저장",
Saved: "{k} 저장함",
Discard: "저장 안 한 고침이 있음 — 버리고 닫을까?",
Close: "닫기",
} as const satisfies Record<string, string>;
const t = (k: keyof typeof TEXT): string => TEXT[k];
const why = (e: unknown): string => (e instanceof Error ? e.message : String(e));
export interface ImportedOptions {
/** 실무자료 파일 층 */
file: HopyoScope;
key: string;
/** 단산 블록 번 */
no: number;
/** SK 를 만들 층 */
target: HopyoScope;
canWrite: boolean;
/** 827-3 저장 안 한 재료 고름(만들 때 서버가 저장 · 그 고름째 만듦) */
picks?: Record<string, unknown>;
/** 만들었음(재료 판 다시 읽기) */
onMade?: () => void;
/** 이 블록으로 만든 SK(860-3 출처 짝 · 목록 「만든 SK」) — 있으면 미리 보기 대신 그것을 엶(수식을 고쳐도) */
made?: string | null;
}
interface Made {
이름: string;
다시씀: boolean;
}
/** 미리 보기 답(835-1) — 같은것 = 같은 내용 SK 키(있으면 그것을 엶) */
interface Draft {
문서: ImportedDoc;
같은것: string | null;
}
/** 서버 몸 — 파일 층 · HP · 블록 · 저장 안 한 재료 고름 · `문서` = [저장] 때 고친 문서 */
const fromBody = (o: ImportedOptions, doc?: ImportedDoc): string =>
JSON.stringify({ 층: o.file.layer, ...(o.file.owner ? { 주인: o.file.owner } : {}), 키: o.key, 번: o.no, ...(o.picks ? { 고름: o.picks } : {}), ...(doc ? { 문서: doc } : {}) }); // prettier-ignore
/** 보기(쓰기 없음) */
export const previewImported = (o: ImportedOptions): Promise<Draft> =>
call(at(o.target, "/sangeun/from-hopyo/preview"), { method: "POST", body: fromBody(o) });
/** [저장] 처음 — 고친 문서째 SK 만듦 */
const fromHopyo = (o: ImportedOptions, doc: ImportedDoc): Promise<Made> =>
call(at(o.target, "/sangeun/from-hopyo"), { method: "POST", body: fromBody(o, doc) });
interface EditAnswer {
문서: ImportedDoc;
전?: Money4 | null;
후?: Money4 | null;
이음없음?: { 자리: string; 이름: string; 까닭?: string; 견적?: boolean; 종?: string }[];
/** qty 답(797-2) */
줄?: QtyRow[];
집계?: QtyTally;
}
export function openImported(o: ImportedOptions): void {
const readOnly = !o.canWrite;
const root = el("div", {
className: "m02-hopyo",
attrs: { "data-imported": `${o.key}|${o.no}` },
});
const top = el("div");
const host = el("div", { attrs: { "data-sk-body": "" } });
let sk = "";
let 판 = "";
let dirty = false;
let handle: ReturnType<typeof mountSangeunDetail> | null = null;
const st: PanelState = { doc: {}, unlinked: [], qty: null, price: null, busy: false, readOnly }; // prettier-ignore
const edit = (how: string, body: Record<string, unknown>): Promise<EditAnswer> =>
call(at(o.target, `/sangeun/imported/${how}`), { method: "POST", body: JSON.stringify(body) });
function mount(doc: ImportedDoc): void {
handle?.destroy();
st.doc = doc;
handle = mountSangeunDetail(host, doc, {
layer: o.target.layer,
owner: o.target.owner,
readOnly,
mode: sk ? "ref" : "memory", // 856-1 저장 전 = 가져온 식 문서째 보기
onChanged: (d) => (dirty ||= d),
onVersion: (v) => (판 = v), // 수식 저장 뒤 새 판(860-3 · 아래 [저장] 409 막음)
});
draw();
}
const now = (): ImportedDoc => (handle?.getDoc() as ImportedDoc | undefined) ?? st.doc;
function draw(): void {
st.draft = !sk;
top.replaceChildren(importedPanel(st, { price, link, qty: openQty }));
saveBtn.disabled = readOnly || st.busy;
}
/** 서버 고침 한 번(눌림 막음) → 시트 다시 엶 */
async function run(
how: string,
body: Record<string, unknown>,
from: ImportedDoc = now(),
): Promise<EditAnswer | null> {
st.busy = true;
draw();
try {
const got = await edit(how, { 문서: from, ...body });
dirty = true;
mount(got.문서);
return got;
} catch (e) {
showToast(why(e), "error");
return null;
} finally {
st.busy = false;
draw();
}
}
/** 이음 없는 자원 — 단가 기준 그대로 price 답(전 · 후 = 지금) */
async function unlinked(): Promise<void> {
if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.unlinked = []);
const got = await edit("price", { 문서: st.doc, 기준: st.doc.가져온?.단가기준 ?? "엑셀" }).catch(() => null); // prettier-ignore
st.unlinked = got?.이음없음 ?? [];
draw();
}
/** 소요량 · 계수 이음 집계(797-2) — 가져온 식일 때만 */
async function qtyTally(): Promise<void> {
if (!isImported(st.doc) || isOldForm(st.doc)) return void (st.qty = null);
const got = await edit("qty", { 문서: st.doc }).catch(() => null);
st.qty = got?.집계 ?? null;
draw();
}
function openQty(): void {
openQtyLinks(
{
view: async () => {
const got = await edit("qty", { 문서: now() });
return { 줄: got.줄 ?? [], 집계: got.집계! };
},
pick: async (spot, c) => {
await run("qty-pick", { 자리: spot, 칸: { 표: c.표, 줄: c.줄, 칸: c.칸 } });
await qtyTally();
},
drop: async (spot, undo) => {
await run("qty-drop", { 자리: spot, 되돌리기: undo });
await qtyTally();
},
},
readOnly,
);
}
async function price(basis: "엑셀" | "우리"): Promise<void> {
const got = await run("price", { 기준: basis });
if (got) st.price = { 전: got.전 ?? null, 후: got.후 ?? null };
draw();
}
function link(spot: string, name: string): void {
const done = (code: string): void => void run("link", { 자리: spot, 이음: code }).then(() => unlinked()); // prettier-ignore
const kind = st.unlinked.find((u) => u.자리 === spot)?.종; // 827-3 재료 줄 = 같은 파일 물음
const src = (st.doc.가져온 as { 원본?: { 지문?: string; 파일?: string } } | undefined)?.원본;
const same = (e: { 코드: string; 이름: string; 규격?: string; 단위?: string }): void => {
if (kind && src?.지문 && !readOnly)
void askSameFile({ scope: o.target, me: sk, 지문: src.지문, 파일: src.파일 ?? "", 종: kind, 원래: name, p: { ...e, 키: e.코드 } }); // prettier-ignore
};
openFindPicker({
layer: o.target.layer,
owner: o.target.owner,
query: name,
logic: (x) => done(`로직(${x.키})`),
element: (e) => {
done(e.코드);
same(e);
},
machine: (e) => done(e.코드),
oil: (e) => done(e.코드),
});
}
async function save(): Promise<boolean> {
try {
if (!sk) {
const made = await fromHopyo(o, now()); // 처음 [저장] = 만듦(835-1)
o.onMade?.();
sk = made.이름;
const got = await readTemplate(o.target.layer, "sangeun", sk, null, o.target.owner);
판 = got.판 ?? "";
mount(got.문서 as ImportedDoc);
dirty = false;
showToast((made.다시씀 ? t("Reused") : t("Made")).replace("{k}", sk), "success");
return true;
}
await handle?.flush(); // 줄 쌓기 수식 고침 먼저 — 단가산출 화면 [저장] 과 같은 길(860-3 · 새 판 = onVersion)
const doc = now();
const info = await saveTemplate(o.target.layer, "sangeun", sk, null, 판, doc, o.target.owner);
판 = info.판;
st.doc = doc;
dirty = false;
showToast(t("Saved").replace("{k}", sk), "success");
return true;
} catch (e) {
showToast(why(e), "error");
return false;
}
}
const saveBtn = createButton({ label: t("Save"), variant: "filled", onClick: () => void save() });
saveBtn.dataset.importedSave = "";
saveBtn.disabled = true;
async function load(): Promise<void> {
const stop = showLoading(root);
try {
const got = await previewImported(o); // 보기 = 쓰기 없음(835-1)
sk = o.made || got.같은것 || "";
const have = sk ? await readTemplate(o.target.layer, "sangeun", sk, null, o.target.owner) : null; // prettier-ignore
판 = have?.판 ?? "";
if (sk) showToast(t("Have").replace("{k}", sk), "info");
root.replaceChildren(top, host);
mount((have?.문서 ?? got.문서) as ImportedDoc);
void unlinked();
void qtyTally();
} catch (e) {
root.replaceChildren(loadingError(why(e), () => void load()));
} finally {
stop();
}
}
openModal({
title: t("Title").replace("{n}", String(o.no)),
closeLabel: t("Close"),
width: "1400px",
wide: true,
dialogClass: "m02-modal m02-hopyo__imported-modal",
actions: [saveBtn],
beforeClose: async () => {
const edited = dirty || Boolean(handle?.isDirty()); // 줄 쌓기 수식 고침은 `onChanged` 가 안 닿음
if (edited && !readOnly && !(await askConfirm({ message: t("Discard"), danger: true })))
return false;
handle?.destroy();
return true;
},
mount: (body) => body.append(root),
});
void load();
}