505 lines
19 KiB
JavaScript
505 lines
19 KiB
JavaScript
/* -*- coding: utf-8 -*- */
|
||
/**
|
||
* 실행예산 계산 (exec_calc.js) — 원본 반올림 원형(MROUNDUD·ADDBJVAL·OPTIMIZ) · 중기 실행단가 · 실행단가·실행수량 할증
|
||
* 근거: 지식DB STmate/REA 분석/32_실행계약단계_작업자료_20261114 (정적 분석 · 주소는 그 문서 표)
|
||
* · MROUNDUD(값, 자릿수, 선택) = DP_Common 0x454044 — 선택 0 = 절사(0 쪽) · 1 = 사사오입(첫 버림 자리 ≥5)
|
||
* · 자릿수 양수 = 소수 자리 · 음수 = 10^|d| 단위 · 문자열 변환 전 부동소수 잡음 미소값 더함
|
||
* · ADDBJVAL = DP_Common 0x4565f8 — 크기 비례 미소값을 부호 방향으로 더함(곱 뒤 절사 오차 막이)
|
||
* · OPTIMIZ = ST_Func_C 0x48094c — 성분 MROUNDUD · 비목별 우선이면 총액 = 성분 합 · 아니면 총액 절사 뒤
|
||
* 남는 단위를 소수부(소수 둘째 절사) 큰 성분부터 하나씩(같으면 OPTNM 차례 앞 · L/M/S 뒤 A)
|
||
* · 중기 실행단가 = ST_Boq TwM_Boq_ExecX.wNe_AutoCost 0x4da7a8
|
||
* 목표 X = MROUNDUD(1단위당 사용료 ÷ 1단위 시간, 0, 0) · 성분 = 최초단가 × X/최초합계(비례)
|
||
* → OPTIMIZ(총액 우선 · 자릿수 = 절사 기준 0~−5) → 성분 합 ≠ X 이면 차액 X − 나머지 두 성분 = 보정 성분
|
||
* · 보정 성분 = 노/재/경 고름 · 기본보정 = 설정 OPTNM 첫 글자(L→노 · M→재 · 그 밖→경, 기본 SML → 경)
|
||
* · 실행수량 = 1단위 시간 × 단위 수(0x4dab5c) · 실행금액 = OPTIMIZ(ADDBJVAL(수량 × 단가), CHNNM)
|
||
* · 실행단가·실행수량 할증 = ST_Boq TwBoq.Act_Rate_Execute 0x512a80 → 0x511fa8
|
||
* 실행수량 = MROUNDUD(최초수량 × 율/100, 자릿수 0~4, 절사/반올림) · 실행단가 = MROUNDUD(최초단가 × 율/100, …)
|
||
* · 율은 코드 머리글자 갈래(L 노무비 · M 재료비 · X 중장비 · 그 밖 W)마다 하나 · 단가 할증은 단위 % 줄 제외
|
||
* · 행 금액 = ST_Boq 0x456504 가 행을 계산 묶음에 싣고 공용 행 계산(0x433490 Q·A 줄 · 0x44019c → 0x43dee8)
|
||
* 을 수량칸마다 부름 — 설계 내역과 같은 엔진(CHNNM 전달) · 앱은 OPTIMIZ(CHNNM, 0자리) 대입
|
||
* · 실행예산서 Ⅰ·Ⅱ = ST_P_Nae Prn_Nae_Cont1·2(0x4c27f8 · 모드 1·2 · 같은 PM_Nae_Cont 양식)
|
||
* Ⅰ = 모든 줄(출력 설정 켬이면 실행수량 0 공종 뺌) · Ⅱ = 계표시 줄(T·E·C) + RS=1 줄 · 소계 닫음(C1·E1) 안 찍음
|
||
* 앱 확장(원본 없음): 비목별 율(rateM·rateL·rateS) · 원 단위 절사(jeol) — 옛 화면·시험 호환
|
||
* 시험: resources/tester/test_stmate_stage_exec_rea.py (원본 규칙 손계산 대조)
|
||
*/
|
||
const StmateExec = (() => {
|
||
const Calc = (typeof window !== "undefined" && window.STMATE_CALC) || require("./calc.js");
|
||
const Change =
|
||
(typeof window !== "undefined" && window.STMATE_CHANGE) || require("./change_calc.js");
|
||
const { roundDown } = Calc;
|
||
const n0 = (v) => Number(v) || 0;
|
||
// 절사 기준 6택 — wCm_Jeol Values '0'·'-1'…'-5'(= MROUNDUD 자릿수) · 화면 1원~100,000원 미만 절사
|
||
const JEOL = [1, 10, 100, 1000, 10000, 100000];
|
||
// 차액 보정 순서 — wCm_OPT Values 0~3
|
||
const ORDERS = [
|
||
["base", "기본보정"],
|
||
["l", "노무비"],
|
||
["m", "재료비"],
|
||
["s", "경비"],
|
||
];
|
||
const cut = (v, j) => Math.trunc(n0(v) / (n0(j) || 1) + 1e-9) * (n0(j) || 1);
|
||
const jeolDigits = (j) => -Math.round(Math.log10(n0(j) || 1));
|
||
|
||
// FormatFloat('0.###…', a) 꼴 — n 자리 반올림 뒤 끝 0 지움
|
||
function fmtHash(a, n) {
|
||
const s = a.toFixed(Math.min(n, 20));
|
||
return s.includes(".") ? s.replace(/0+$/, "").replace(/\.$/, "") : s;
|
||
}
|
||
// 부동소수 잡음 미소값 — '.' 자리(1부터) 2~9 → 10^(자리−13) · 10~13 → 1e-4 · 그 밖 1e-9 (0x4541ad)
|
||
function noiseEps(pos) {
|
||
if (pos < 2) return 0;
|
||
if (pos <= 9) return Math.pow(10, pos - 13);
|
||
return pos <= 13 ? 1e-4 : 1e-9;
|
||
}
|
||
|
||
// MROUNDUD(v, d, sel) — DP_Common 0x454044
|
||
function mroundud(v, d = 0, sel = 0) {
|
||
v = n0(v);
|
||
d = Math.trunc(n0(d));
|
||
if (v === 0) return 0;
|
||
const a = Math.abs(v);
|
||
const n = d > 11 && a <= 1 ? 15 : 13;
|
||
const s0 = fmtHash(a, n);
|
||
let pos = s0.indexOf(".") + 1;
|
||
// 유효 숫자 11개 미만이면 미소값 없음(0x454154~0x4541ab)
|
||
if (pos > 0 && s0.length - pos < 11) {
|
||
const first = s0.search(/[1-9]/) + 1;
|
||
if (first > 0 && s0.length - first < 11) pos = 0;
|
||
}
|
||
if (pos === 0 && d >= 0 && !s0.includes(".")) return v;
|
||
const eps = pos === 0 ? 0 : noiseEps(pos);
|
||
let s = fmtHash(a + eps, n);
|
||
if (!s.includes(".")) s += ".0";
|
||
const p = s.indexOf(".") + 1;
|
||
const ch = (i) => s.charAt(i - 1);
|
||
let frac, body, e;
|
||
if (d === 0) ((frac = "0." + ch(p + 1)), (body = s.slice(0, p - 1)), (e = 0));
|
||
else if (d > 0) {
|
||
frac = "0." + ch(p + d + 1);
|
||
body = s.slice(0, p - 1) + "." + s.slice(p, p + d);
|
||
e = -d;
|
||
} else {
|
||
const D = -d;
|
||
if (p - 1 > D) ((frac = "0." + ch(p - D)), (body = s.slice(0, p - D - 1) + "0".repeat(D)));
|
||
else if (p - 1 === D) ((frac = "0." + ch(1)), (body = "0"));
|
||
else ((frac = "0.0"), (body = "0"));
|
||
e = D;
|
||
}
|
||
// 사사오입 = Round(StrToFloat(frac + '1')) × 10^e — '1' 덧붙여 은행가 동률 피함
|
||
const add = sel ? Math.round(Number(frac + "1")) * Math.pow(10, e) : 0;
|
||
// 원본은 확장 정밀도 합 → binary64 저장 · 여기서는 자릿수로 다시 맞춰 이진 잡음 지움
|
||
const r = d > 0 ? Number((Number(body) + add).toFixed(Math.min(d, 20))) : Number(body) + add;
|
||
return v > 0 ? r : -r;
|
||
}
|
||
|
||
// MROUNDUP(v, d) — DP_Common 0x4547ac (REA MCP Ghidra 의사코드로 확인)
|
||
// FormatFloat('0.0#########', |v| + 미소값) → d 자리에서 자름 → 버린 다음 숫자들(최대 10자리)을
|
||
// '0.' 뒤에 붙여 Ceil(0x4297f4 = Trunc + (Frac > 0)) → 하나라도 0 이 아니면 한 단위 올림(0 반대쪽)
|
||
function mroundup(v, d = 0) {
|
||
v = n0(v);
|
||
d = Math.trunc(n0(d));
|
||
if (v === 0) return 0;
|
||
const a = Math.abs(v);
|
||
const s0 = fmtHash(a, 10);
|
||
let pos = s0.indexOf(".") + 1;
|
||
if (pos > 0 && s0.length - pos < 11) {
|
||
const first = s0.search(/[1-9]/) + 1;
|
||
if (first > 0 && s0.length - first < 11) pos = 0;
|
||
}
|
||
if (pos === 0 && d >= 0 && !s0.includes(".")) return v;
|
||
const s = fmtHash(a + (pos === 0 ? 0 : noiseEps(pos)), 10);
|
||
const [ip, fp = ""] = s.split(".");
|
||
let body, rest, e;
|
||
if (d >= 0) {
|
||
body = ip + (d ? "." + fp.slice(0, d).padEnd(d, "0") : "");
|
||
rest = fp.slice(d, d + 10);
|
||
e = -d;
|
||
} else {
|
||
const D = -d;
|
||
if (ip.length > D)
|
||
((body = ip.slice(0, ip.length - D) + "0".repeat(D)), (rest = ip.slice(-D) + fp));
|
||
else ((body = "0"), (rest = ip + fp));
|
||
e = D;
|
||
}
|
||
const sum = Number(body) + (/[1-9]/.test(rest) ? Math.pow(10, e) : 0);
|
||
const r = d > 0 ? Number(sum.toFixed(Math.min(d, 20))) : sum;
|
||
return v > 0 ? r : -r;
|
||
}
|
||
|
||
// ADDBJVAL(v) — DP_Common 0x4565f8 · '.' 자리 기준 미소값을 부호 방향으로 더함
|
||
function addbjval(v) {
|
||
v = n0(v);
|
||
const s = fmtHash(Math.abs(v), 14);
|
||
const pos = s.indexOf(".") + 1;
|
||
if (pos < 2) return v;
|
||
const eps = pos <= 9 ? Math.pow(10, pos - 13) : pos <= 13 ? 1e-4 : 1e-9;
|
||
return eps > Math.abs(v) ? v : v + Math.sign(v) * eps;
|
||
}
|
||
|
||
const mfrac = (x) => x - Math.trunc(x);
|
||
|
||
// OPTIMIZ(rec, o) — ST_Func_C 0x48094c · rec {T,L,M,S,A} · o {priority, digits, mode, order}
|
||
function optimiz(rec, o = {}) {
|
||
const d = Math.trunc(n0(o.digits)),
|
||
mode = Math.trunc(n0(o.mode));
|
||
const ks = String(o.order || "SML")
|
||
.toUpperCase()
|
||
.slice(0, 3)
|
||
.split("")
|
||
.filter((k) => "LMS".includes(k));
|
||
for (const k of ["S", "M", "L"]) if (!ks.includes(k)) ks.push(k);
|
||
ks.push("A");
|
||
const c = ks.map((k) => n0(rec[k]));
|
||
const R = (x) =>
|
||
mode === 1 ? mroundud(x, d, 1) : mode === 3 ? mroundup(x, d) : mroundud(x, d);
|
||
const r = c.map(R);
|
||
const T = n0(rec.T);
|
||
const sumR = () => r.reduce((a, x) => a + x, 0);
|
||
let Tout = sumR(),
|
||
moved = 0;
|
||
if (!(o.priority || mode === 1 || mode === 3 || Tout === T)) {
|
||
Tout = mroundud(T, d, 0);
|
||
const P = Math.pow(10, d);
|
||
const f = c.map((x) => Math.abs(mroundud(mfrac(x * P), 2, 0)));
|
||
const neg = c.map((x) => x < 0);
|
||
let k = Math.round((Tout - sumR()) * P);
|
||
const negRes = k < 0;
|
||
k = Math.abs(k);
|
||
for (let guard = 0; k > 0 && k <= 4 && guard < 32; guard++) {
|
||
let i = 0,
|
||
pick = -1;
|
||
while (i < 4) {
|
||
if (f[i] > 1) {
|
||
i++;
|
||
continue;
|
||
}
|
||
const j = f.findIndex((x, jj) => jj > i && x < 1 && x > f[i]);
|
||
if (j >= 0) {
|
||
i = j;
|
||
continue;
|
||
}
|
||
pick = i;
|
||
break;
|
||
}
|
||
if (pick < 0) break;
|
||
f[pick] += 1;
|
||
k = negRes === neg[pick] ? k - 1 : k + 1;
|
||
moved++;
|
||
}
|
||
// 1/P 더하기 — 원본은 확장 정밀도 뒤 binary64 저장 · 여기서는 10^−d 를 바로 곱해 이진 잡음 막음
|
||
const step = d <= 0 ? Math.pow(10, -d) : 1 / Math.pow(10, d);
|
||
for (let i = 0; i < 4; i++) {
|
||
const t = Math.trunc(neg[i] ? -f[i] : f[i]);
|
||
if (t) r[i] = d > 0 ? Number((r[i] + t * step).toFixed(d)) : r[i] + t * step;
|
||
}
|
||
}
|
||
const out = { T: Tout, moved };
|
||
ks.forEach((k, i) => (out[k] = r[i]));
|
||
return out;
|
||
}
|
||
|
||
const firstComp = (optnm) => {
|
||
const c = String(optnm || "SML").toUpperCase()[0];
|
||
return c === "L" ? "l" : c === "M" ? "m" : "s";
|
||
};
|
||
|
||
// 중기 실행단가 — wNe_AutoCost 0x4da7a8
|
||
// p {fee, hours, units?, execQty?, initQty?, init{l,m,s,t?}, jeol | jeolDigits, order, optnm, chnnm}
|
||
function machineExecUnit(p) {
|
||
const hours = n0(p.hours),
|
||
fee = n0(p.fee);
|
||
const X = hours ? mroundud(fee / hours, 0, 0) : 0;
|
||
const init = {
|
||
l: n0(p.init && p.init.l),
|
||
m: n0(p.init && p.init.m),
|
||
s: n0(p.init && p.init.s),
|
||
};
|
||
const initT = p.init && p.init.t != null ? n0(p.init.t) : init.l + init.m + init.s;
|
||
const ratio = initT ? X / initT : 0;
|
||
const digits = p.jeolDigits != null ? Math.trunc(n0(p.jeolDigits)) : jeolDigits(p.jeol);
|
||
const o1 = optimiz(
|
||
{ T: X, L: init.l * ratio, M: init.m * ratio, S: init.s * ratio, A: 0 },
|
||
{ priority: false, digits, mode: 0, order: p.optnm },
|
||
);
|
||
const comps = { l: o1.L, m: o1.M, s: o1.S };
|
||
let to = p.order || "base";
|
||
if (to === "base") to = firstComp(p.optnm);
|
||
const before = comps.l + comps.m + comps.s;
|
||
if (before !== X) comps[to] = X - (before - comps[to]);
|
||
const qty =
|
||
p.units != null && p.units !== "" ? hours * n0(p.units) : n0(p.execQty || p.initQty);
|
||
const raw = {
|
||
T: addbjval(qty * X),
|
||
L: addbjval(qty * comps.l),
|
||
M: addbjval(qty * comps.m),
|
||
S: addbjval(qty * comps.s),
|
||
A: 0,
|
||
};
|
||
const o2 = optimiz(raw, { priority: p.chnnm !== false, digits: 0, mode: 0, order: p.optnm });
|
||
return {
|
||
target: hours ? fee / hours : 0,
|
||
X,
|
||
T: X,
|
||
Tr: o1.T,
|
||
comps,
|
||
diff: X - before,
|
||
to,
|
||
digits,
|
||
initT,
|
||
execQty: qty,
|
||
qtyRatio: n0(p.initQty) ? qty / n0(p.initQty) : 1,
|
||
amounts: { t: o2.T, l: o2.L, m: o2.M, s: o2.S },
|
||
};
|
||
}
|
||
|
||
// 실행단가 = 최초단가(Act_SameFirstExecute 0x4dadd0) — 사용료 = 최초합계 × 시간 · 절사 1원
|
||
const sameFirst = (p) =>
|
||
Object.assign({}, p, {
|
||
fee: n0(p.init && (p.init.t ?? p.init.l + p.init.m + p.init.s)) * n0(p.hours),
|
||
jeol: 1,
|
||
});
|
||
// 실행목표값(대략) 찾기(0x4da7e6) — 사용료 = MROUNDUP(목표 실행금액 ÷ 단위 수, 0)
|
||
const feeFromTarget = (target, units) => (n0(units) ? mroundup(n0(target) / n0(units), 0) : 0);
|
||
|
||
// 할증 갈래 — Act_Rate Tag%10: 1 L · 2 M · 3 X · 4 그 밖(S·W·B·D·A·P·Q)
|
||
const kindOf = (code) => {
|
||
const c = String(code || "").trim()[0] || "";
|
||
return c === "L" ? "L" : c === "M" ? "M" : c === "X" ? "X" : "W";
|
||
};
|
||
// 단가 할증 제외 — L·M 은 단위 %, W 갈래는 S·W·P 머리글자 + 단위 %(0x51300e)
|
||
const pctExcluded = (code, unit) => {
|
||
if (!String(unit || "").includes("%")) return false;
|
||
const c = String(code || "").trim()[0] || "";
|
||
const k = kindOf(code);
|
||
return k === "L" || k === "M" || (k === "W" && "SWP".includes(c));
|
||
};
|
||
|
||
// 실행예산 행 — 실행단가 = 직접 입력 또는 할증(율·자릿수·절사/반올림) · 실행수량 = 입력 또는 최초수량 × 수량율
|
||
// o {digits, round, rateQ, kindRates{L,M,X,W}, rateM/rateL/rateS(앱), jeol(앱), chnnm, optnm}
|
||
function execRow(r, o) {
|
||
const ov = (o.overrides || {})[r.id] || {};
|
||
const native = o.digits != null || o.round != null;
|
||
const dg = Math.trunc(n0(o.digits));
|
||
const rnd = (v) => (native ? mroundud(v, dg, o.round ? 1 : 0) : cut(v, n0(o.jeol) || 1));
|
||
const kr = o.kindRates;
|
||
const skip = kr && pctExcluded(r.code, r.unit);
|
||
const rate = (k) =>
|
||
kr ? n0(kr[kindOf(r.code)] ?? 100) : n0(o[{ m: "rateM", l: "rateL", s: "rateS" }[k]] ?? 100);
|
||
const u = {};
|
||
["m", "l", "s"].forEach((k, i) => {
|
||
u[k] = ov.mls ? n0(ov.mls[i]) : skip ? n0(r[k]) : rnd((n0(r[k]) * rate(k)) / 100);
|
||
});
|
||
const q =
|
||
ov.qty != null
|
||
? n0(ov.qty)
|
||
: o.rateQ != null && n0(o.rateQ) !== 100
|
||
? mroundud((n0(r.qty) * n0(o.rateQ)) / 100, dg, o.round ? 1 : 0)
|
||
: n0(r.qty);
|
||
// 행 금액 — 원본 행 계산(0x456504)은 미해독 · OPTIMIZ(CHNNM, 0자리) 대입(비목별 우선 = 비목 절사 합)
|
||
const g = optimiz(
|
||
{ T: (u.m + u.l + u.s) * q, M: u.m * q, L: u.l * q, S: u.s * q, A: 0 },
|
||
{ priority: o.chnnm !== false, digits: 0, order: o.optnm },
|
||
);
|
||
const a = { mAmt: g.M, lAmt: g.L, sAmt: g.S, tAmt: g.T };
|
||
return { qty: q, mUnit: u.m, lUnit: u.l, sUnit: u.s, tUnit: u.m + u.l + u.s, ...a };
|
||
}
|
||
|
||
// 평면 행 실행예산 — rows [{id, code?, unit?, qty, m, l, s, gov}]
|
||
function budget(rows, opts = {}) {
|
||
const out = rows.map((r) => {
|
||
const x = execRow(r, opts);
|
||
const d = {
|
||
mAmt: roundDown(n0(r.m) * n0(r.qty), 0),
|
||
lAmt: roundDown(n0(r.l) * n0(r.qty), 0),
|
||
sAmt: roundDown(n0(r.s) * n0(r.qty), 0),
|
||
};
|
||
d.tAmt = d.mAmt + d.lAmt + d.sAmt;
|
||
return Object.assign({}, r, { design: d, exec: x });
|
||
});
|
||
const tot = (key) =>
|
||
out
|
||
.filter((r) => !r.gov)
|
||
.reduce(
|
||
(a, r) => ({
|
||
mAmt: a.mAmt + r[key].mAmt,
|
||
lAmt: a.lAmt + r[key].lAmt,
|
||
sAmt: a.sAmt + r[key].sAmt,
|
||
tAmt: a.tAmt + r[key].tAmt,
|
||
}),
|
||
{ mAmt: 0, lAmt: 0, sAmt: 0, tAmt: 0 },
|
||
);
|
||
const design = tot("design"),
|
||
exec = tot("exec");
|
||
return {
|
||
rows: out,
|
||
design,
|
||
exec,
|
||
diff: exec.tAmt - design.tAmt,
|
||
rate: design.tAmt ? Math.round((exec.tAmt / design.tAmt) * 1e5) / 1e3 : 0,
|
||
};
|
||
}
|
||
|
||
// 내역 구조 위 실행예산 — 설계(계획) 칸 = 최초(3칸 복사본 · TwPrjList.MkBoq 0x55c956) · 실행 칸 = 1칸
|
||
function budgetFromTree(tree, stage, opts = {}) {
|
||
const nodes = tree.nodes.map((nd) => {
|
||
const o = Object.assign({}, nd, { st: {} });
|
||
if (nd.kind !== "leaf") return o;
|
||
const s = nd.st[stage] || {};
|
||
o.st.d = {
|
||
qty: n0(s.qty),
|
||
mUnit: n0(s.mUnit),
|
||
lUnit: n0(s.lUnit),
|
||
sUnit: n0(s.sUnit),
|
||
tUnit: n0(s.tUnit),
|
||
mAmt: n0(s.mAmt),
|
||
lAmt: n0(s.lAmt),
|
||
sAmt: n0(s.sAmt),
|
||
tAmt: n0(s.tAmt),
|
||
};
|
||
const row = { id: nd.id, code: nd.newCode || nd.code, unit: nd.unit, qty: s.qty };
|
||
Object.assign(row, { m: s.mUnit, l: s.lUnit, s: s.sUnit });
|
||
const flat = { rateM: 100, rateL: 100, rateS: 100, kindRates: null, rateQ: null };
|
||
o.st.x = execRow(row, nd.gov ? Object.assign({}, opts, flat) : opts);
|
||
return o;
|
||
});
|
||
Change.sumHeads(nodes, ["d", "x"]);
|
||
const tops = nodes.filter((nd) => nd.kind === "head" && !nd.zone);
|
||
const top = tops.reduce((a, h) => (!a || h.level > a.level ? h : a), null);
|
||
return {
|
||
nodes,
|
||
design: top ? top.st.d.tAmt : 0,
|
||
exec: top ? top.st.x.tAmt : 0,
|
||
};
|
||
}
|
||
|
||
// 실행예산서 Ⅰ·Ⅱ(0673·0674) 열 — 설치본 SET_REP.DBF 행(FLDCNT 5 · 열 이름·폭)
|
||
const REPORT_COLS = [
|
||
["공종", 25],
|
||
["설계(계획)", 20],
|
||
["실행예산", 25],
|
||
["작업명", 15],
|
||
["구분", 25],
|
||
];
|
||
|
||
// 실행예산서 Ⅰ·Ⅱ 줄 고르기 — ST_P_Nae 0x4c245d(조회식) · 0x4c3d38(소계 닫음 거름)
|
||
// Ⅰ = 모든 줄 · 설정 켬(+0x1768)이면 !(MLSWBDXAP 공종 .and. QTY1=0) · Ⅱ = T·E·C 줄 + RS=1 줄 · C1·E1 안 찍음
|
||
function reportRows(nodes, mode = 1, o = {}) {
|
||
return nodes.filter((nd) => {
|
||
if (nd.kind === "blank") return false;
|
||
const c = String(nd.newCode || nd.code || "").trim();
|
||
if (mode === 2) {
|
||
if (nd.kind === "close") return !/^[CE]1$/.test(c);
|
||
return nd.kind === "head" || !!nd.rs;
|
||
}
|
||
const q = nd.st && nd.st.x ? nd.st.x.qty : 0;
|
||
return !(o.skipZeroQty && nd.kind === "leaf" && /^[MLSWBDXAP]/.test(c) && !n0(q));
|
||
});
|
||
}
|
||
// PM_Nae_Cont 양식 열(DFM TPM_NAE_CONT 머리 띠) — 설계(계획) = 2칸(QTY2·UNIT2·T_AMT2) · 실행 = 1칸
|
||
const NAE_CONT_COLS = [
|
||
"공종",
|
||
"설계(계획) 수량",
|
||
"단위",
|
||
"금액",
|
||
"작업명",
|
||
"구분",
|
||
"수량",
|
||
"단위",
|
||
"재료비 단가",
|
||
"재료비 금액",
|
||
"노무비 단가",
|
||
"노무비 금액",
|
||
"경비 단가",
|
||
"경비 금액",
|
||
"총액 단가",
|
||
"총액 금액",
|
||
"비고",
|
||
];
|
||
|
||
// 계약,실행내역서(0623·0624) — ST_Prt 꼬리표 20623 → Prn_Nae/Prn_NaeW · 20624 → Prn_Nae_P/Prn_NaeW_P(0x4513e7)
|
||
// 설계 내역서와 같은 인쇄 모듈을 지금 공사(계약·실행)에 씀 · SET_REP FLDCNT 0 → 내역서 기본 열
|
||
const NAE_COLS = [
|
||
"공종",
|
||
"명칭",
|
||
"규격",
|
||
"수량",
|
||
"단위",
|
||
"재료비 단가",
|
||
"재료비 금액",
|
||
"노무비 단가",
|
||
"노무비 금액",
|
||
"경비 단가",
|
||
"경비 금액",
|
||
"합계 단가",
|
||
"합계 금액",
|
||
"비고",
|
||
];
|
||
// nodes 의 st[key] 값으로 내역서 줄 — 머리·닫음 = 금액만
|
||
function naeRows(nodes, key) {
|
||
return nodes
|
||
.filter((nd) => nd.kind !== "blank")
|
||
.map((nd) => {
|
||
const v = (nd.st && nd.st[key]) || {};
|
||
if (nd.kind !== "leaf")
|
||
return [
|
||
nd.itnum || "",
|
||
nd.name || "",
|
||
"",
|
||
"",
|
||
"",
|
||
"",
|
||
v.mAmt,
|
||
"",
|
||
v.lAmt,
|
||
"",
|
||
v.sAmt,
|
||
"",
|
||
v.tAmt,
|
||
"",
|
||
];
|
||
return [
|
||
nd.itnum || "",
|
||
nd.name || "",
|
||
nd.spec || "",
|
||
v.qty,
|
||
nd.unit || "",
|
||
v.mUnit,
|
||
v.mAmt,
|
||
v.lUnit,
|
||
v.lAmt,
|
||
v.sUnit,
|
||
v.sAmt,
|
||
v.tUnit,
|
||
v.tAmt,
|
||
nd.newCode || nd.code || "",
|
||
];
|
||
});
|
||
}
|
||
|
||
return {
|
||
JEOL,
|
||
NAE_COLS,
|
||
naeRows,
|
||
NAE_CONT_COLS,
|
||
reportRows,
|
||
ORDERS,
|
||
REPORT_COLS,
|
||
mroundud,
|
||
mroundup,
|
||
addbjval,
|
||
optimiz,
|
||
jeolDigits,
|
||
kindOf,
|
||
pctExcluded,
|
||
machineExecUnit,
|
||
sameFirst,
|
||
feeFromTarget,
|
||
execRow,
|
||
budget,
|
||
budgetFromTree,
|
||
};
|
||
})();
|
||
|
||
if (typeof window !== "undefined") window.STMATE_EXEC = StmateExec;
|
||
if (typeof module !== "undefined" && module.exports) module.exports = StmateExec;
|