Merge branch 'sub_laptop_3' of C:/Aislo_wt/sub_laptop_3 into main_laptop_1
This commit is contained in:
@@ -178,7 +178,8 @@ def remove(
|
||||
at = refs.folder_of(r["층"], r["주인"]) / r["문서종류"] / f"{r['문서']}.json"
|
||||
files[at] = r
|
||||
done: list[dict[str, Any]] = []
|
||||
# ponytail: 여러 파일을 차례로 씀(잠금 없음) — 실패하면 앞서 고친 파일을 앞판 바이트로 되돌림
|
||||
# ponytail: 부르는 곳(`Precombo_Folders.edit`)의 `store.batch` 안 — 실패하면 앞서 고친 파일을
|
||||
# 앞판 바이트로 되돌림(되돌림 몸을 `batch` 로 옮기는 것은 5-8)
|
||||
for path, r in files.items():
|
||||
raw = path.read_bytes()
|
||||
try:
|
||||
|
||||
@@ -205,6 +205,12 @@ def find(folder: Path, kind: str) -> dict[str, Any]:
|
||||
|
||||
# ── 합치기 ────────────────────────────────────────────────────────────
|
||||
def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[str, Any]:
|
||||
"""판 대조부터 마지막 쓰기까지 `store.batch` — 같은 층 지우기 · 나무 고침과 겹치면 진 쪽 409."""
|
||||
with store.batch():
|
||||
return _merge(session, folder, kind, body)
|
||||
|
||||
|
||||
def _merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[str, Any]:
|
||||
mine = refs.where(folder)
|
||||
raw = body.남김 or {}
|
||||
keep_at: refs.Here = (str(raw.get("층") or ""), raw.get("주인") or None)
|
||||
@@ -216,13 +222,13 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st
|
||||
gone = list(dict.fromkeys(str(k) for k in body.지움))
|
||||
if not gone or (keep_at == mine and keep["키"] in gone):
|
||||
raise _bad(400, "지울 문서를 고름 — 남김과 달라야 함")
|
||||
with store.at(folder):
|
||||
tree_doc, 판 = pre_folders._read(kind)
|
||||
if 판 != body.판: # 없는 문서 검사 앞 — 겹쳐 진 쪽(그새 지워짐)은 409
|
||||
raise _bad(409, {"stale": [pre_folders.file_of(kind)], "판": 판})
|
||||
have = dict(_docs(mine, kind))
|
||||
if miss := [k for k in gone if k not in have]:
|
||||
raise _bad(404, f"이 층에 없는 문서 「{' · '.join(miss)}」")
|
||||
with store.at(folder):
|
||||
tree_doc, 판 = pre_folders._read(kind)
|
||||
if 판 != body.판:
|
||||
raise _bad(409, {"stale": [pre_folders.file_of(kind)], "판": 판})
|
||||
marks = same.Same()
|
||||
mark = marks.finger(kind, keep_doc)
|
||||
if mark is None or any(marks.finger(kind, have[k]) != mark for k in gone):
|
||||
@@ -259,7 +265,6 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st
|
||||
places = dict(tree_doc.get("자리") or {})
|
||||
done, kept = [], []
|
||||
when = datetime.now().isoformat(timespec="seconds")
|
||||
# ponytail: 여러 파일을 차례로 씀(잠금 없음) — 동시에 같은 층을 합치면 앞 것이 이김
|
||||
for key in gone:
|
||||
if left[key]:
|
||||
kept.append({"키": key, "쓰는곳": left[key]})
|
||||
@@ -284,7 +289,13 @@ def merge(session: Session, folder: Path, kind: str, body: MergeBody) -> dict[st
|
||||
|
||||
|
||||
def undo(session: Session, folder: Path, kind: str, key: str) -> dict[str, Any]:
|
||||
"""`_합친것/<키>` 되돌림 — 문서 · 나무 자리 · 옮긴 참조(아직 남김을 가리키고 쓸 수 있는 곳)."""
|
||||
"""`_합친것/<키>` 되돌림 — 문서 · 나무 자리 · 옮긴 참조(아직 남김을 가리키고 쓸 수 있는 곳) ·
|
||||
한 `store.batch`(지움 기록 되돌림 `M02_Library_Delete.undo` 도 이 안)."""
|
||||
with store.batch():
|
||||
return _undo(session, folder, kind, key)
|
||||
|
||||
|
||||
def _undo(session: Session, folder: Path, kind: str, key: str) -> dict[str, Any]:
|
||||
mine = refs.where(folder)
|
||||
rec_path = folder / GONE / f"{key}.json"
|
||||
try:
|
||||
|
||||
@@ -76,8 +76,14 @@ _BAD_NAME = re.compile(r'[\\/:*?"<>|\x00-\x1f]|\.\.')
|
||||
# of undefined (reading 'length')") · CAD 쪽도 없으면 새로 채우지만(2026-09-27 sub1 고침)
|
||||
# 뿌리도 처음부터 채움
|
||||
_BLANK_LAYER = {"id": "기본", "name": "기본", "isVisible": True, "isLocked": False}
|
||||
# ponytail: 저장은 한 번에 하나(프로세스 안 잠금) · 서버를 여럿 띄우면 파일 잠금으로
|
||||
_LOCK = threading.Lock()
|
||||
# ponytail: 저장은 한 번에 하나(프로세스 안 잠금 · 다시 들어감) · 서버를 여럿 띄우면 파일 잠금으로
|
||||
_LOCK = threading.RLock()
|
||||
|
||||
|
||||
def batch() -> threading.RLock:
|
||||
"""여러 파일 쓰기 한 묶음(858 5-4) — 판 대조부터 마지막 쓰기까지 한 잠금 · 안에서 `write` ·
|
||||
`delete` 를 불러도 됨(다시 들어가는 잠금) · 겹친 쪽은 잠금 뒤 판 대조에서 409."""
|
||||
return _LOCK
|
||||
|
||||
|
||||
class StoreError(Exception):
|
||||
|
||||
@@ -181,7 +181,13 @@ def edit(
|
||||
body: dict[str, Any], kind: str = "precombo", session: dict[str, Any] | None = None
|
||||
) -> dict[str, Any]:
|
||||
"""지금 층 자리 파일을 고쳐 씀(지우기면 문서 파일째 · 쓰는 곳 = `deleting.remove` · 몸 `확인`) →
|
||||
새 나무 + 알림(지우기 = `기록` 되돌림 키) · 판 다르면 409."""
|
||||
새 나무 + 알림(지우기 = `기록` 되돌림 키) · 판 다르면 409 · 판 대조부터 쓰기까지
|
||||
`store.batch`."""
|
||||
with store.batch():
|
||||
return _edit(body, kind, session)
|
||||
|
||||
|
||||
def _edit(body: dict[str, Any], kind: str, session: dict[str, Any] | None) -> dict[str, Any]:
|
||||
doc, 판 = _read(kind)
|
||||
if 판 != str(body.get("판") or ""):
|
||||
raise store.StoreError(409, {"stale": [file_of(kind)], "판": 판})
|
||||
|
||||
@@ -0,0 +1,415 @@
|
||||
/* 856-0 헬퍼 — 단가산출 화면 · 일위대가 줄 누름 · 머리 띠 · M01 로직 상세(가짜 DOM · 진짜 코드)
|
||||
* 진짜 = M02 단가산출 화면(`Sangeun_Detail` 과 그 이웃) · 일위대가 표(`Labor_Table`) · 줄 모달 · M01 상세 그릇
|
||||
* 가짜 = 부품 상자(표지 붙은 빈 상자) · 줄 쌓기 화면(그린 키만 적음) · 서버 부름(길 · 몸을 적고 견본 답) */
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ROOT = path.resolve(__dirname, "..", "..");
|
||||
const ts = require(path.join(ROOT, "config", "node_modules", "typescript"));
|
||||
|
||||
const camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
|
||||
class Fake {
|
||||
constructor(tag) {
|
||||
this.tagName = String(tag).toUpperCase();
|
||||
this.children = [];
|
||||
this.parentElement = null;
|
||||
this.dataset = {};
|
||||
this.attrs = {};
|
||||
this.style = { setProperty() {} };
|
||||
this.hidden = false;
|
||||
this.className = "";
|
||||
this.textContent = "";
|
||||
this.value = "";
|
||||
this.disabled = false;
|
||||
this.classList = { add() {}, remove() {}, toggle() {}, contains: () => false };
|
||||
}
|
||||
append(...xs) {
|
||||
for (const x of xs)
|
||||
if (x instanceof Fake) {
|
||||
x.parentElement = this;
|
||||
this.children.push(x);
|
||||
}
|
||||
}
|
||||
prepend(...xs) {
|
||||
this.append(...xs);
|
||||
}
|
||||
replaceChildren(...xs) {
|
||||
this.children = [];
|
||||
this.append(...xs);
|
||||
}
|
||||
remove() {}
|
||||
get firstChild() {
|
||||
return this.children[0] ?? null;
|
||||
}
|
||||
addEventListener() {}
|
||||
removeEventListener() {}
|
||||
setAttribute(k, v) {
|
||||
this.attrs[k] = v;
|
||||
if (k.startsWith("data-")) this.dataset[camel(k.slice(5))] = v;
|
||||
}
|
||||
removeAttribute() {}
|
||||
contains() {
|
||||
return false;
|
||||
}
|
||||
querySelector() {
|
||||
return null;
|
||||
}
|
||||
focus() {}
|
||||
}
|
||||
globalThis.window = globalThis;
|
||||
globalThis.addEventListener = () => {};
|
||||
globalThis.removeEventListener = () => {};
|
||||
globalThis.getComputedStyle = () => ({ overflowY: "visible" });
|
||||
globalThis.requestAnimationFrame = (f) => setTimeout(f, 0);
|
||||
globalThis.HTMLElement = Fake;
|
||||
globalThis.HTMLInputElement = class extends Fake {};
|
||||
globalThis.HTMLTextAreaElement = class extends Fake {};
|
||||
globalThis.document = {
|
||||
createElement: (t) => new Fake(t),
|
||||
body: new Fake("body"),
|
||||
activeElement: null,
|
||||
};
|
||||
globalThis.sessionStorage = { getItem: () => null, setItem() {}, removeItem() {} };
|
||||
|
||||
/** 표지 붙은 빈 상자 */
|
||||
const box = (tag, mark = {}, text = "") => {
|
||||
const n = new Fake(tag);
|
||||
for (const [k, v] of Object.entries(mark)) n.setAttribute(k, v);
|
||||
n.textContent = text;
|
||||
return n;
|
||||
};
|
||||
const el = (tag, o = {}) => {
|
||||
const n = box(tag, o.attrs ?? {}, o.text ?? "");
|
||||
n.className = o.className ?? "";
|
||||
n.append(...(o.children ?? []));
|
||||
return n;
|
||||
};
|
||||
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 modals = []; // 열린 모달 — 제목 · 몸
|
||||
const ui = {
|
||||
ui_template_elements: {
|
||||
el,
|
||||
createButton: button,
|
||||
createInputField: input,
|
||||
showToast() {},
|
||||
showConfirmDialog: async () => true,
|
||||
},
|
||||
ui_template_button: { createButton: button },
|
||||
ui_template_input: { createInputField: input },
|
||||
ui_template_banner: { createBanner: (o) => box("div", { "data-banner": o.tone }, o.text) },
|
||||
ui_template_badge: { createBadge: (text, tone) => box("span", { "data-badge": tone }, text) },
|
||||
ui_template_text: { createText: (text) => box("span", {}, text) },
|
||||
ui_template_checkbox: { createCheckbox: () => ({ root: box("label") }) },
|
||||
ui_template_card: { createCard: () => box("div") },
|
||||
ui_template_locale: { t: (k) => k, currentLanguageIndex: 0 },
|
||||
ui_template_modal: {
|
||||
openModal: (o) => {
|
||||
const body = box("div", { "data-modal": o.title });
|
||||
const head = box("div");
|
||||
const close = () => {};
|
||||
o.mount?.(body, close, head);
|
||||
modals.push({ title: o.title, body, head, actions: o.actions ?? [] });
|
||||
return { close };
|
||||
},
|
||||
askConfirm: async () => true,
|
||||
askText: async () => null,
|
||||
showConfirmDialog: async () => true,
|
||||
},
|
||||
ui_template_side_panels: {
|
||||
createSidePanels: () => ({ current: () => null, root: box("div"), wrap: (m) => m }),
|
||||
},
|
||||
ui_template_hopyo_grid: {
|
||||
hopyoGrid: (blocks) => ({
|
||||
at: new Map(blocks[0].lines.map((_, i) => [i, [0, i]])),
|
||||
columns: [],
|
||||
rows: [],
|
||||
}),
|
||||
createHopyoGrid: (_blocks, o) => ((grid.onRowClick = o.onRowClick), { root: box("table") }),
|
||||
hopyoCellClass: () => "",
|
||||
},
|
||||
};
|
||||
const grid = { onRowClick: null };
|
||||
|
||||
// 줄 쌓기 화면 = 그린 키 · 저장 전 문서만 적음
|
||||
const stacks = [];
|
||||
const screen = {
|
||||
createStackScreen: (opt) => {
|
||||
const s = { root: box("div", { "data-stack": "" }), draws: [], opt };
|
||||
stacks.push(s);
|
||||
return {
|
||||
root: s.root,
|
||||
draw: (k) => s.draws.push({ key: k, memory: !k && !!opt.memory?.() }),
|
||||
dirty: () => false,
|
||||
save: async () => true,
|
||||
discard: async () => {},
|
||||
canLeave: async () => true,
|
||||
destroy() {},
|
||||
};
|
||||
},
|
||||
};
|
||||
|
||||
// 서버 부름 — 길 · 몸을 적고 견본 답
|
||||
const calls = [];
|
||||
let skAnswer = () => ({});
|
||||
const api = {
|
||||
call: async (p, init) => {
|
||||
calls.push({ path: p, body: init?.body ? JSON.parse(init.body) : null });
|
||||
if (p.includes("/sangeun/calc")) return skAnswer();
|
||||
if (p.includes("/labor/")) return { 줄: [], 자재: [], 알약: [] };
|
||||
return {};
|
||||
},
|
||||
readTemplate: async (_l, _k, key) => ({ 문서: { 키: key, 이름: "견본", 단위: "㎡" }, 판: "1" }),
|
||||
saveTemplate: async () => ({}),
|
||||
getActiveLayer: () => "system",
|
||||
getActiveOwner: () => null,
|
||||
};
|
||||
const logicApi = {
|
||||
fetchLogic: async (k) => ({
|
||||
logic: { 키: k, 이름: "기초", 결과단위: "원/㎡", 입력: [] },
|
||||
prices: {},
|
||||
file: "",
|
||||
reasons: [],
|
||||
}),
|
||||
fetchAuto: async () => ({}),
|
||||
setLogicApiPaths() {},
|
||||
ApiError: class extends Error {},
|
||||
};
|
||||
|
||||
const stubs = {
|
||||
...ui,
|
||||
line_stack_screen: screen,
|
||||
M02_MasterTemplete_Api_Fetch: api,
|
||||
M01_MasterData_UI_Logic_Api: logicApi,
|
||||
M02_MasterTemplete_Sangeun_Side: {
|
||||
createSangeunSide: () => ({ wrap: (m) => m, set() {} }),
|
||||
tabOf: () => ({}),
|
||||
},
|
||||
M01_MasterData_UI_LogicLab_Ho: { buildHo: () => [box("div", { "data-ho": "" })] },
|
||||
M02_MasterTemplete_Sangeun_Unit: { buildUnitSwap: () => null, baseUnitOf: () => "" },
|
||||
M02_MasterTemplete_Labor_LogicMats: { logicMatRows: () => [] },
|
||||
M02_Labor_Values_Model: {
|
||||
valueLine: () => ({ text: "", empty: 0 }),
|
||||
keepKnown: (_a, b) => ({ kept: b }),
|
||||
},
|
||||
M02_MasterTemplete_Labor_Grid: {
|
||||
laborBlock: (cur) => ({ lines: cur.담은로직.map(() => ({ note: "", amounts: { sum: 1 } })) }),
|
||||
},
|
||||
M02_DF_UnitPick: { createUnitPick: () => box("div"), NO_UNIT: "-" },
|
||||
M02_MasterTemplete_Labor_Unlinked: { unlinkedBar: () => null },
|
||||
M02_MasterTemplete_Labor_Text: { tc: (k) => k },
|
||||
M02_MasterTemplete_Labor_LibMeta: { libMeta: () => [] },
|
||||
M02_MasterTemplete_Labor_National: { nationalRows: () => [] },
|
||||
};
|
||||
const real = new Set([
|
||||
"M02_MasterTemplete_Sangeun_Detail",
|
||||
"M02_MasterTemplete_Sangeun_Tabs",
|
||||
"M02_MasterTemplete_Sangeun_Cover",
|
||||
"M02_MasterTemplete_Sangeun_BaseHead",
|
||||
"M02_Sangeun_Cover_Model",
|
||||
"M02_Sangeun_Undo",
|
||||
"M02_Born_Tag",
|
||||
"M01_MasterData_UI_LogicLab_Detail",
|
||||
"M02_MasterTemplete_Labor_Table",
|
||||
"M02_MasterTemplete_Labor_SkEdit",
|
||||
"M02_MasterTemplete_Labor_RowModal",
|
||||
"M02_MasterTemplete_Labor_RowSk",
|
||||
"M02_MasterTemplete_Labor_Api",
|
||||
"M02_MasterTemplete_Labor_Calc",
|
||||
]);
|
||||
|
||||
const empty = () =>
|
||||
new Proxy(function () {}, {
|
||||
get: (_, k) => (k === "then" ? undefined : empty()),
|
||||
apply: () => undefined,
|
||||
});
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const mod = { exports: {} };
|
||||
cache.set(at, mod.exports);
|
||||
const need = (p) => {
|
||||
if (p.endsWith(".css")) return {};
|
||||
const name = path.basename(p);
|
||||
if (stubs[name]) return stubs[name];
|
||||
if (p.startsWith("@config/")) return { API_BASE_URL: "" };
|
||||
if (!p.startsWith(".")) return empty();
|
||||
const r = `${path.resolve(path.dirname(at), p)}.ts`;
|
||||
return real.has(path.basename(r, ".ts")) && fs.existsSync(r) ? load(r) : empty();
|
||||
};
|
||||
new Function("exports", "module", "require", js)(mod.exports, mod, need);
|
||||
return mod.exports;
|
||||
}
|
||||
const M = (rel) => load(path.join(ROOT, rel));
|
||||
const tick = () => new Promise((r) => setTimeout(r, 0));
|
||||
const settle = async () => {
|
||||
for (let i = 0; i < 20; i++) await tick();
|
||||
};
|
||||
const walk = (n, fn) => {
|
||||
fn(n);
|
||||
for (const c of n.children) walk(c, fn);
|
||||
};
|
||||
const all = (root, pred) => {
|
||||
const out = [];
|
||||
walk(root, (n) => pred(n) && out.push(n));
|
||||
return out;
|
||||
};
|
||||
/** 숨은 조상까지 보고 보이는가 */
|
||||
const shown = (n) => {
|
||||
for (let x = n; x; x = x.parentElement) if (x.hidden) return false;
|
||||
return true;
|
||||
};
|
||||
const skCalls = () => calls.filter((c) => c.path.includes("/sangeun/calc"));
|
||||
const plainAns = (o = {}) => ({
|
||||
기준: null,
|
||||
줄: [
|
||||
{ 이름: "보통인부", cid: "labor:LB1#0", 수량: 1, 단가: 100, 금액: 100, 비목: { 노무비: 100 } },
|
||||
],
|
||||
정체: ["labor:LB1#0"],
|
||||
짝잃음: [],
|
||||
빠진줄: [],
|
||||
바탕판: "v1",
|
||||
...o,
|
||||
});
|
||||
|
||||
/** 단가산출 화면 한 벌 열기 — 부름 수 · 숨은 몸 · 줄 쌓기 그림 · 띠 */
|
||||
async function openSk(doc, opt = {}) {
|
||||
calls.length = 0;
|
||||
stacks.length = 0;
|
||||
const { mountSangeunDetail } = M("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts");
|
||||
const host = box("div");
|
||||
const h = mountSangeunDetail(host, doc, {
|
||||
layer: "system",
|
||||
owner: null,
|
||||
readOnly: false,
|
||||
onChanged() {},
|
||||
...opt,
|
||||
});
|
||||
await settle();
|
||||
const s = stacks[stacks.length - 1];
|
||||
const r = {
|
||||
calc: skCalls().length,
|
||||
body: all(host, (n) => "skCover" in n.dataset || "ho" in n.dataset).length, // 몸 DOM(덮개 그릇 · 호표)
|
||||
bodyShown: all(host, (n) => "skCover" in n.dataset && shown(n)).length,
|
||||
stack: s ? { shown: shown(s.root), draws: s.draws } : null,
|
||||
banners: all(host, (n) => "banner" in n.dataset).map((n) => n.dataset.banner),
|
||||
badges: all(host, (n) => "badge" in n.dataset).map((n) => [n.dataset.badge, n.textContent]),
|
||||
};
|
||||
h.destroy();
|
||||
return r;
|
||||
}
|
||||
|
||||
(async () => {
|
||||
const out = {};
|
||||
skAnswer = () => plainAns();
|
||||
// ① 단가산출 화면(페이지) — 바탕 있음 · 없음
|
||||
out.page_base = await openSk(
|
||||
{ 키: "SK-000001", 이름: "견본", 단위: "㎡", 바탕: { 로직: "GC001109" } },
|
||||
{ source: true },
|
||||
);
|
||||
out.page_nobase = await openSk({ 키: "SK-000002", 이름: "견본", 단위: "㎡" }, { source: true });
|
||||
// 불러오기 미리 보기(저장 전 가져온 식)
|
||||
out.memory = await openSk({ 이름: "가져온", 단위: "식", 가져온: { 파일: "x" } });
|
||||
|
||||
// ③ 머리 띠 넷(견본 답) — 까닭 · M01 개정 · 빠진 줄 · 짝 잃음 + 머리 배지
|
||||
skAnswer = () =>
|
||||
plainAns({
|
||||
까닭: "못 셈",
|
||||
빠진줄: [{ cid: "labor:LB2#1", 이름: "특별인부", 까닭: "입력 없음" }],
|
||||
짝잃음: [{ cid: "labor:LB9#0", 까닭: "줄 없음" }],
|
||||
바탕판: "v2",
|
||||
머리: "계",
|
||||
});
|
||||
out.bands = await openSk(
|
||||
{ 키: "SK-000003", 이름: "띠", 단위: "㎡", 바탕: { 로직: "GC001109" }, 바탕판: "v1" },
|
||||
{ source: true },
|
||||
);
|
||||
skAnswer = () => {
|
||||
throw new Error("서버 못 닿음");
|
||||
};
|
||||
out.bands_fail = await openSk({ 키: "SK-000004", 이름: "띠", 단위: "㎡" }, { source: true });
|
||||
skAnswer = () => plainAns();
|
||||
|
||||
// ② 일위대가 표 줄 누름 — SK 참조 줄 · M01 로직 줄 · 셈 주입(프로젝트 사본) SK 줄
|
||||
const { mountLaborTable } = M("M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts");
|
||||
const rows = [
|
||||
{
|
||||
참조: { 층: "system", 주인: null, 키: "SK-000010" },
|
||||
별칭: null,
|
||||
메모: null,
|
||||
수량: { 손: 1 },
|
||||
},
|
||||
{ 로직: "GC001109", 별칭: null, 메모: null, 입력값: {}, 수량: { 손: 1 } },
|
||||
];
|
||||
const click = async (calc) => {
|
||||
const res = [];
|
||||
for (let i = 0; i < rows.length; i++) {
|
||||
const t = mountLaborTable(
|
||||
box("div"),
|
||||
{ 담은로직: JSON.parse(JSON.stringify(rows)), 자재: [], 단위: "㎡" },
|
||||
{
|
||||
mode: "precombo",
|
||||
layer: "system",
|
||||
column: "공통",
|
||||
readOnly: false,
|
||||
owner: null,
|
||||
onChanged() {},
|
||||
...(calc ? { calc: async () => ({ 줄: [], 자재: [] }) } : {}),
|
||||
},
|
||||
);
|
||||
await settle();
|
||||
modals.length = 0;
|
||||
stacks.length = 0;
|
||||
calls.length = 0;
|
||||
grid.onRowClick(i);
|
||||
await settle();
|
||||
const m = modals[0];
|
||||
const s = stacks[0];
|
||||
res.push({
|
||||
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,
|
||||
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,
|
||||
});
|
||||
t.destroy?.();
|
||||
}
|
||||
return res;
|
||||
};
|
||||
out.labor = await click(false);
|
||||
out.labor_inject = await click(true);
|
||||
|
||||
// ④ M01 로직 상세 그릇 — 기본정보 접힘 + 줄 쌓기
|
||||
const { buildLabDetail } = M("M01_MasterData/M01_MasterData_UI_LogicLab_Detail.ts");
|
||||
const host = box("div");
|
||||
const stack = box("div", { "data-stack": "" });
|
||||
buildLabDetail(host, {
|
||||
row: {
|
||||
키: "GC001109",
|
||||
원문번호: "1-1",
|
||||
이름: "기초",
|
||||
결과단위: "원/㎡",
|
||||
입력: [],
|
||||
중간: [],
|
||||
호표: [],
|
||||
덧줄: [],
|
||||
},
|
||||
file: "f.json",
|
||||
reasons: ["막힘"],
|
||||
ownHost: box("div"),
|
||||
onChange() {},
|
||||
stack,
|
||||
});
|
||||
out.m01 = host.children.map((n) => n.tagName + (n.dataset.stack !== undefined ? ":stack" : ""));
|
||||
console.log(JSON.stringify(out));
|
||||
})().catch((e) => {
|
||||
console.error(e.stack || String(e));
|
||||
process.exit(1);
|
||||
});
|
||||
@@ -0,0 +1,77 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""PLAN 856-0 — 단가산출 화면 지킴(가짜 DOM · 진짜 코드 · `helper_856_0_sk_screen.cjs`).
|
||||
|
||||
① 단가산출 화면을 열 때 서버 `/sangeun/calc` 부름 수 · 숨은 상세 몸 DOM · 줄 쌓기 그림
|
||||
② 일위대가 표 줄 누름 — 단가산출(SK) 참조 줄 = 그 SK 줄 쌓기 · M01 로직 줄 · 셈 주입(프로젝트 사본) 줄
|
||||
③ 머리 띠 넷(까닭 · M01 개정 · 빠진 줄 · 짝 잃음)이 뜨는 경우 — 견본 답
|
||||
④ M01 로직 상세 그릇 = 기본정보 접힘 + 줄 쌓기
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from functools import lru_cache
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def _run() -> dict:
|
||||
proc = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_856_0_sk_screen.cjs")],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
)
|
||||
assert proc.returncode == 0, proc.stderr[-3000:]
|
||||
return json.loads(proc.stdout)
|
||||
|
||||
|
||||
def test_sk_page_open_calls_and_hidden_body() -> None:
|
||||
got = _run()
|
||||
# 바탕 있는 SK = 셈 두 번(바탕 원값 bare) · 바탕 없음 = 한 번 · 상세 몸 DOM 둘(덮개 그릇 · 호표) 숨김
|
||||
assert got["page_base"]["calc"] == 2
|
||||
assert got["page_nobase"]["calc"] == 1
|
||||
for k in ("page_base", "page_nobase", "memory"):
|
||||
assert got[k]["body"] == 2, k
|
||||
assert got[k]["bodyShown"] == 0, k
|
||||
assert got[k]["stack"]["shown"] is True, k
|
||||
assert {d["key"] for d in got["page_base"]["stack"]["draws"]} == {"SK-000001"}
|
||||
# 불러오기 미리 보기(저장 전 가져온 식) = 빈 키 + 문서째
|
||||
assert all(d == {"key": "", "memory": True} for d in got["memory"]["stack"]["draws"])
|
||||
assert got["memory"]["calc"] == 1
|
||||
|
||||
|
||||
def test_labor_row_click() -> None:
|
||||
sk, logic = _run()["labor"]
|
||||
# 단가산출 참조 줄 = 그 SK 문서 모달 · 줄 쌓기가 그 키로 보임 · 몸 안 보임
|
||||
assert sk["skModal"] == 1 and sk["stack"]["shown"] is True
|
||||
assert set(sk["stack"]["draws"]) == {"SK-000010"} and sk["body"] == 0
|
||||
# M01 로직 줄 = 옛 줄 모달 — 줄 쌓기 숨김 · 상세 몸 보임 · 안내 띠 하나 · 셈 둘(정체 + 상세)
|
||||
assert logic["skModal"] == 0 and logic["stack"]["shown"] is False
|
||||
assert logic["body"] == 1 and logic["banners"] == ["info"] and logic["calc"] == 2
|
||||
|
||||
|
||||
def test_labor_row_click_inject() -> None:
|
||||
sk, logic = _run()["labor_inject"]
|
||||
# 셈 주입(프로젝트 사본) = 옛 줄 모달 · 상세 없음 · 안내 띠 없음 · 셈 없음
|
||||
for row in (sk, logic):
|
||||
assert row["modal"] and row["stack"] is None
|
||||
assert row["body"] == 0 and row["banners"] == [] and row["calc"] == 0
|
||||
|
||||
|
||||
def test_head_bands_four() -> None:
|
||||
got = _run()
|
||||
# 까닭(빨강) · M01 개정 · 빠진 줄 · 짝 잃음(노랑) + 머리 배지 · 개정 배지
|
||||
assert got["bands"]["banners"] == ["danger", "warning", "warning", "warning"]
|
||||
assert got["bands"]["badges"] == [["info", "계"], ["danger", "M02_SangeunRevisedBase"]]
|
||||
# 서버 못 닿음 = 빨강 하나
|
||||
assert got["bands_fail"]["banners"] == ["danger"]
|
||||
assert got["page_base"]["banners"] == [] and got["page_base"]["badges"] == []
|
||||
|
||||
|
||||
def test_m01_logic_detail_shape() -> None:
|
||||
# 기본정보 접힘 · 막힘 까닭 · 줄 쌓기 — 단가산출 상세 몸 칸 없음
|
||||
assert _run()["m01"] == ["DETAILS", "DIV", "DIV:stack"]
|
||||
@@ -7,9 +7,8 @@
|
||||
다르면 갈래 이름 + 지금 답 + 다시 뜨는 법으로 실패(건너뛰지 않음). 다시 뜸 =
|
||||
`SHELF_858_WRITE=1 ./venv/Scripts/python.exe -m pytest resources/tester/test_858_shelf_golden.py`
|
||||
(뜻한 바뀜일 때만 · 커밋 글에 까닭). 답 통째 전후 대조 = `SHELF_858_DUMP=tmp/<파일>.json`.
|
||||
② 동시 쓰기 — 잠금 없는 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 지금 사실을
|
||||
그대로 단언(나무 = 둘 다 됨 · 뒤 것이 이김 · 지우기 + 합치기 = 앞 것이 이기고 뒤 것은 터짐) —
|
||||
「5-4 에서 뒤집을 단언」 표시 줄은 5-4 가 바꿈.
|
||||
② 동시 쓰기 — 나무 고침 · 나무 지우기 · 합치기를 같은 판으로 겹쳐 부름. 한 잠금(`store.batch` ·
|
||||
5-4) 안에서 판 대조 → 앞 것만 이기고 뒤 것은 409 · 파일은 앞 것이 쓴 그대로(반쯤 써짐 없음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -354,45 +353,36 @@ def test_서고_길_답_지문(shelf, world):
|
||||
)
|
||||
|
||||
|
||||
# ── ② 동시 쓰기 — 잠금 없는 여러 파일 쓰기(설계 858 1-4 「잠금 없는 쓰기」 · 5-4 몫) ─────────
|
||||
def _two(first, second, meet: list[tuple[Any, str]], late: tuple[Any, str]):
|
||||
"""둘을 같이 돌림 — 둘 다 판 대조를 지난 뒤 `meet` 함수 앞에서 만나고, 그 뒤 `second` 쪽
|
||||
`late` 함수를 늦춤 → (먼저 답 · 나중 답 — 예외면 예외)."""
|
||||
gate = threading.Barrier(2, timeout=10)
|
||||
slow = threading.local()
|
||||
saved = [(late[0], late[1], getattr(*late))] + [(o, n, None) for o, n in meet]
|
||||
# ── ② 동시 쓰기 — 여러 파일 쓰기 한 잠금(설계 858 1-4 「잠금 없는 쓰기」 · 5-4) ─────────
|
||||
def _race(win, lose, inside: tuple[Any, str]):
|
||||
"""`win` 을 먼저 돌려 `inside`(판 대조 뒤 · 쓰기 앞) 안에서 붙잡아 둔 사이 `lose` 를 돌림 →
|
||||
(win 답 · lose 답 — 예외면 예외). 잠금이 없으면 `lose` 도 옛 판으로 대조를 지나 둘 다 됨."""
|
||||
entered = threading.Event()
|
||||
held = threading.local()
|
||||
real = getattr(*inside)
|
||||
|
||||
def later(*a, _real=saved[0][2], **k):
|
||||
if getattr(slow, "on", False):
|
||||
def hold(*a, **k):
|
||||
if getattr(held, "on", False):
|
||||
entered.set()
|
||||
threading.Event().wait(0.3)
|
||||
return _real(*a, **k)
|
||||
return real(*a, **k)
|
||||
|
||||
setattr(*late, later) # 안쪽 = 늦춤 · 바깥 = 만남(같은 함수면 만난 뒤 늦춤)
|
||||
for i, (owner, name, _) in enumerate(saved[1:], 1):
|
||||
inner = getattr(owner, name)
|
||||
saved[i] = (owner, name, inner)
|
||||
|
||||
def wait(*a, _inner=inner, **k):
|
||||
gate.wait()
|
||||
return _inner(*a, **k)
|
||||
|
||||
setattr(owner, name, wait)
|
||||
|
||||
def run(fn, is_late):
|
||||
slow.on = is_late
|
||||
def run(fn, is_win):
|
||||
held.on = is_win
|
||||
try:
|
||||
return fn()
|
||||
except Exception as error: # 지금 사실(터짐)도 답으로
|
||||
except Exception as error: # 진 쪽 409 도 답으로
|
||||
return error
|
||||
|
||||
setattr(*inside, hold)
|
||||
try:
|
||||
with ThreadPoolExecutor(2) as pool:
|
||||
a = pool.submit(run, first, False)
|
||||
b = pool.submit(run, second, True)
|
||||
a = pool.submit(run, win, True)
|
||||
assert entered.wait(10), "앞 것이 쓰기 자리에 못 닿음"
|
||||
b = pool.submit(run, lose, False)
|
||||
return a.result(), b.result()
|
||||
finally:
|
||||
for owner, name, real in reversed(saved):
|
||||
setattr(owner, name, real)
|
||||
setattr(*inside, real)
|
||||
|
||||
|
||||
def _sk(me: Path, name: str, price: int, again: bool = False) -> str:
|
||||
@@ -415,37 +405,40 @@ def _folders(me: Path) -> list[list[str]]:
|
||||
return pre_folders.view("sangeun")["폴더"]
|
||||
|
||||
|
||||
def test_동시_나무_고침_둘_다_됨_뒤_것이_이김(world):
|
||||
def _lost(answer) -> bool:
|
||||
return isinstance(answer, store.StoreError) and answer.status == 409
|
||||
|
||||
|
||||
def test_동시_나무_고침_앞_것만_됨_뒤_것은_409(world):
|
||||
me = world["personal"]
|
||||
with store.at(me):
|
||||
판 = pre_folders.view("sangeun")["판"]
|
||||
first, second = _two(
|
||||
first, second = _race(
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "나", "판": 판}),
|
||||
[(pre_folders, "apply_many")],
|
||||
(pre_folders, "atomic_write_json"),
|
||||
(pre_folders, "apply_many"),
|
||||
)
|
||||
assert first["알림"]["경로"] == ["가"] and second["알림"]["경로"] == ["나"] # 둘 다 됨
|
||||
assert _folders(me) == [["나"]] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것이 이김(앞 「가」 사라짐)
|
||||
assert first["알림"]["경로"] == ["가"] and _lost(second)
|
||||
assert _folders(me) == [["가"]] # 앞 것만 — 뒤 「나」 는 판이 달라 안 씀
|
||||
|
||||
|
||||
def test_동시_나무_지우기와_고침_둘_다_됨_뒤_것이_이김(world):
|
||||
def test_동시_나무_고침과_지우기_앞_것만_됨_뒤_지우기는_409(world):
|
||||
me = world["personal"]
|
||||
gone = _sk(me, "지울것", 1000)
|
||||
with store.at(me):
|
||||
판 = pre_folders.view("sangeun")["판"]
|
||||
first, second = _two(
|
||||
first, second = _race(
|
||||
_edit(me, {"op": "add-folder", "경로": [], "이름": "가", "판": 판}),
|
||||
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
|
||||
[(pre_folders, "apply_many")],
|
||||
(pre_folders, "atomic_write_json"),
|
||||
(pre_folders, "apply_many"),
|
||||
)
|
||||
assert first["알림"]["경로"] == ["가"] and second["알림"]["기록"] # 둘 다 됨
|
||||
assert not (me / "sangeun" / f"{gone}.json").exists()
|
||||
assert _folders(me) == [] # 5-4 에서 뒤집을 단언 — 지금은 뒤 것(지우기)이 이김(「가」 사라짐)
|
||||
assert first["알림"]["경로"] == ["가"] and _lost(second)
|
||||
assert (me / "sangeun" / f"{gone}.json").is_file() # 지우기 = 안 됨 · 문서 그대로
|
||||
assert _folders(me) == [["가"]]
|
||||
assert not (me / same_router.GONE).exists() or not list((me / same_router.GONE).glob("*.json"))
|
||||
|
||||
|
||||
def test_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(world):
|
||||
def test_동시_지우기와_합치기_앞_것만_됨_뒤_합치기는_409(world):
|
||||
me = world["personal"]
|
||||
gone = _sk(me, "겹침", 1000)
|
||||
keep = _sk(me, "겹침", 1000, again=True)
|
||||
@@ -454,16 +447,13 @@ def test_동시_지우기와_합치기_앞_것이_이기고_뒤_것은_터짐(wo
|
||||
body = same_router.MergeBody(
|
||||
남김={"층": "personal", "주인": "7/42", "키": keep}, 지움=[gone], 판=판
|
||||
)
|
||||
first, second = _two(
|
||||
first, second = _race(
|
||||
_edit(me, {"op": "delete", "대상": [{"키": gone}], "판": 판}),
|
||||
lambda: same_router.merge(dict(USER), me, "sangeun", body),
|
||||
[(pre_folders, "apply_many"), (same_router, "_user_index")],
|
||||
(same_router, "_user_index"),
|
||||
(pre_folders, "apply_many"),
|
||||
)
|
||||
assert first["알림"]["기록"] == gone # 지우기 = 됨(기록 키 = 그 문서)
|
||||
# 5-4 에서 뒤집을 단언 — 지금은 뒤 합치기가 판 · 지문 대조를 지난 뒤 사라진 파일에서 터짐
|
||||
# (화면 = 500) · 5-4 뒤 = 409 · 파일 앞판 그대로
|
||||
assert isinstance(second, FileNotFoundError)
|
||||
assert _lost(second) # 뒤 합치기 = 판이 달라 409(옛 = 사라진 파일에서 터짐 · 화면 500)
|
||||
assert not (me / "sangeun" / f"{gone}.json").exists()
|
||||
assert (me / "sangeun" / f"{keep}.json").is_file()
|
||||
assert [p.stem for p in (me / same_router.GONE).glob("*.json")] == [gone] # 지우기 기록만
|
||||
|
||||
Reference in New Issue
Block a user