326 lines
14 KiB
JavaScript
326 lines
14 KiB
JavaScript
// REA c90bd4/c91100/c914d4/c9261c/c9199c, c98928, ca4814/ca5e98.
|
||
const EstProgress = (() => {
|
||
const { num, components, units, floating, sum } = EstMath;
|
||
const precision = (value) => {
|
||
const [mantissa, exponent] = String(value ?? 0)
|
||
.toLowerCase()
|
||
.split("e");
|
||
return Math.max(0, (mantissa.split(".")[1]?.length || 0) - Number(exponent || 0));
|
||
};
|
||
const ordinary = (row) => num(row.Level) === 0 && ![54, 55, 58, 59].includes(num(row.LinkIndex));
|
||
function ambiguousKeys(rows) {
|
||
const counts = new Map();
|
||
rows.forEach((row, index) => {
|
||
const key = EstBusiness.rowKey(row, index);
|
||
counts.set(key, (counts.get(key) || 0) + 1);
|
||
});
|
||
return new Set([...counts].filter(([, count]) => count > 1).map(([key]) => key));
|
||
}
|
||
function distribute(amount, row, digits) {
|
||
const parts = components.map((field) => num(row[field]));
|
||
const base = sum(row);
|
||
const output = parts.map((part) => (base ? EstMath.fixed((amount * part) / base, digits) : 0));
|
||
if (base) {
|
||
const index = parts.map(Math.abs).indexOf(Math.max(...parts.map(Math.abs)));
|
||
output[index] += amount - output.reduce((a, b) => a + b, 0);
|
||
}
|
||
return output;
|
||
}
|
||
function calculate(project, roundId) {
|
||
const round = project.progress.find((item) => item.id === roundId);
|
||
if (!round) throw Error("기성 회차 없음");
|
||
const source = round.contract || {
|
||
rows: project.tables.EstMainDat,
|
||
wonga: project.tables.Wonga,
|
||
options: project.options,
|
||
};
|
||
const rows = structuredClone(source.rows),
|
||
options = source.options || project.options;
|
||
const errors = [],
|
||
position = project.progress.indexOf(round),
|
||
key = EstBusiness.rowKey;
|
||
const ambiguous = ambiguousKeys(rows);
|
||
const earlier = project.progress.slice(0, position);
|
||
if (earlier.some((item) => !item.locked)) errors.push("전회 기성 회차를 먼저 확정하세요.");
|
||
const previous = earlier.at(-1)?.result,
|
||
oldRows = new Map((previous?.rows || []).map((row, index) => [key(row, index), row]));
|
||
if (earlier.at(-1)?.locked && !Array.isArray(previous?.rows))
|
||
errors.push("확정된 전회 기성 결과가 없습니다. 전회 결과를 확인하세요.");
|
||
if (
|
||
earlier.at(-1)?.locked &&
|
||
source.wonga?.length &&
|
||
!Array.isArray(previous?.costs) &&
|
||
!Array.isArray(previous?.wonga)
|
||
)
|
||
errors.push("확정된 전회 기성 원가 결과가 없습니다. 전회 결과를 확인하세요.");
|
||
const segments = { Gum: [], Sa: [] };
|
||
const separated = round.separateComponents !== false;
|
||
rows.forEach((row, index) => {
|
||
const id = key(row, index),
|
||
input = ambiguous.has(id) ? {} : round.inputs?.[id] || {},
|
||
old = ambiguous.has(id) ? null : oldRows.get(id);
|
||
if (ambiguous.has(id) && (round.inputs?.[id] || oldRows.has(id)))
|
||
errors.push(`기성 내역 식별자가 중복됩니다: ${id}`);
|
||
for (const field of ["GN", "TC", "Ratio", ...components])
|
||
row["Jun" + field] = num(old?.["Total" + field]);
|
||
if (num(row.Level) > 0 || [54, 59].includes(num(row.LinkIndex))) {
|
||
segments.Gum = [];
|
||
segments.Sa = [];
|
||
}
|
||
for (const prefix of ["Gum", "Sa"]) {
|
||
components.forEach((field) => (row[prefix + field] = 0));
|
||
row[prefix + "GN"] = 0;
|
||
row[prefix + "TC"] = 0;
|
||
row[prefix + "Ratio"] = 0;
|
||
if (!ordinary(row)) continue;
|
||
const mode = input[prefix + "Mode"] || "quantity",
|
||
value = num(input[prefix]),
|
||
digits = input.AmountDigits ?? round.amountDigits ?? 0;
|
||
if (!["quantity", "amount", "ratio", "components"].includes(mode)) {
|
||
errors.push(`${row.Name || id}: 지원하지 않는 기성 입력방법`);
|
||
continue;
|
||
}
|
||
let quantity = value,
|
||
amount,
|
||
standaloneAmount;
|
||
if (mode === "amount") {
|
||
amount = value;
|
||
quantity = num(row.TC) ? (amount / num(row.TC)) * num(row.GN) : 0;
|
||
if (!num(row.TC) && amount)
|
||
errors.push(`${row.Name || id}: 도급금액이 0인 항목은 비목 금액으로 입력하세요.`);
|
||
} else if (mode === "components") {
|
||
components.forEach((field) => (row[prefix + field] = num(input[prefix + field])));
|
||
amount = components.reduce((n, field) => n + row[prefix + field], 0);
|
||
quantity = num(row.TC) ? (amount / num(row.TC)) * num(row.GN) : 0;
|
||
} else if (mode === "ratio")
|
||
quantity = floating(
|
||
(num(row.GN) * value) / 100,
|
||
input.QuantityDigits ?? precision(row.GN),
|
||
1,
|
||
);
|
||
const factor =
|
||
quantity /
|
||
([57, 62, 67].includes(num(row.LinkIndex)) || ["%", "％"].includes(row.Unite) ? 100 : 1);
|
||
if ([62, 67].includes(num(row.LinkIndex))) {
|
||
const selected = segments[prefix].filter(
|
||
(item) =>
|
||
num(item.CalcIndex) < 2 &&
|
||
(num(row.LinkIndex) !== 62 ||
|
||
(num(item.SKind) > 0 &&
|
||
String(row.Code || "")
|
||
.toUpperCase()
|
||
.includes(String.fromCharCode(64 + num(item.SKind))))),
|
||
);
|
||
const base = EstRows.baseKind(row),
|
||
target = { 1: "GC", 2: "NC", 3: "JC", 4: "SC" }[num(row.SCheck)] || "JC";
|
||
if (base)
|
||
row[prefix + target] = EstMath.even(
|
||
(selected.reduce((n, item) => n + num(item[prefix + base]), 0) * num(row.GN)) / 100,
|
||
);
|
||
else
|
||
components.forEach(
|
||
(field) =>
|
||
(row[prefix + field] = EstMath.even(
|
||
(selected.reduce((n, item) => n + num(item[prefix + field]), 0) * num(row.GN)) /
|
||
100,
|
||
)),
|
||
);
|
||
quantity = num(row.GN);
|
||
} else if (mode === "amount") {
|
||
distribute(amount, row, digits).forEach(
|
||
(value, i) => (row[prefix + components[i]] = value),
|
||
);
|
||
if (separated && !sum(row) && amount)
|
||
errors.push(`${row.Name || id}: 도급 비목 금액이 없어 비목별 배분을 할 수 없습니다.`);
|
||
} else if (mode !== "components") {
|
||
const fixed = units.every((field) => !num(row[field])) && num(row.TC) !== 0;
|
||
if (fixed) {
|
||
const share = mode === "ratio" ? value / 100 : num(row.GN) ? quantity / num(row.GN) : 0;
|
||
components.forEach(
|
||
(field) => (row[prefix + field] = EstMath.fixed(num(row[field]) * share, digits)),
|
||
);
|
||
if (!separated) standaloneAmount = EstMath.fixed(num(row.TC) * share, digits);
|
||
} else
|
||
components.forEach(
|
||
(field, i) =>
|
||
(row[prefix + field] = EstMath.fixed(num(row[units[i]]) * factor, digits)),
|
||
);
|
||
}
|
||
row[prefix + "GN"] = quantity;
|
||
row[prefix + "TC"] =
|
||
!separated && (mode === "amount" || standaloneAmount !== undefined)
|
||
? mode === "amount"
|
||
? amount
|
||
: standaloneAmount
|
||
: components.reduce((n, field) => n + num(row[prefix + field]), 0);
|
||
row[prefix + "Ratio"] = num(row.TC)
|
||
? floating((row[prefix + "TC"] / num(row.TC)) * 100, 2, 1)
|
||
: 0;
|
||
if (num(row.CalcIndex) < 2) segments[prefix].push(row);
|
||
}
|
||
});
|
||
const boundary = rows.findIndex((row) => num(row.LinkIndex) === 54);
|
||
const direct = rows
|
||
.slice(0, boundary < 0 ? rows.length : boundary)
|
||
.filter((row) => ordinary(row) && num(row.CalcIndex) < 2);
|
||
const contract = direct.reduce((n, row) => n + num(row.TC), 0);
|
||
function costsFor(prefix) {
|
||
const current = direct.reduce((n, row) => n + num(row[prefix + "TC"]), 0),
|
||
ratio = contract ? current / contract : 0;
|
||
const working = EstNative.empty();
|
||
working.options = { ...options, SourceRefresh: false, TotalFix: false };
|
||
working.tables.EstMainDat = rows.map((row) => {
|
||
const copy = { ...row, CalcIndex: num(row.CalcIndex) >= 2 ? 3 : 1 };
|
||
components.forEach((field) => (copy[field] = num(row[prefix + field])));
|
||
copy.TC = num(row[prefix + "TC"]);
|
||
return copy;
|
||
});
|
||
working.tables.Wonga = structuredClone(source.wonga);
|
||
for (const row of working.tables.Wonga) {
|
||
if (!separated && row.BaseField === "TC") {
|
||
row.Cost = current;
|
||
row.BaseField = "";
|
||
row.CalcIndex = 1;
|
||
} else if (row.Youl && !String(row.Name).replace(/\s/g, "").includes("부가")) {
|
||
row.Cost = Math.trunc(num(row.Cost) * ratio);
|
||
row.VSusic = "";
|
||
row.CalcIndex = 1;
|
||
} else if (
|
||
!row.VSusic &&
|
||
!row.BaseField &&
|
||
![1, 3].includes(num(row.CalcIndex)) &&
|
||
!/관급/.test(String(row.Name))
|
||
)
|
||
row.Cost = Math.trunc(num(row.Cost) * ratio);
|
||
}
|
||
const calculated = EstNative.calculate(working);
|
||
if (!separated) calculated.calculation.direct.TC = current;
|
||
errors.push(...calculated.calculation.errors);
|
||
const names = new Map(
|
||
calculated.tables.Wonga.filter((row) => num(row.CalcIndex) < 2).map((row) => [
|
||
EstNative.normalize(row.Name),
|
||
row,
|
||
]),
|
||
);
|
||
for (const row of rows) {
|
||
if (num(row.LinkIndex) === 54) {
|
||
for (const field of [...components, "TC"])
|
||
row[prefix + field] = num(calculated.calculation.direct[field]);
|
||
} else if (
|
||
[55, 58].includes(num(row.LinkIndex)) &&
|
||
names.has(EstNative.normalize(row.Name))
|
||
) {
|
||
row[prefix + "TC"] = num(names.get(EstNative.normalize(row.Name)).Cost);
|
||
}
|
||
row[prefix + "Ratio"] = num(row.TC)
|
||
? floating((num(row[prefix + "TC"]) / num(row.TC)) * 100, 2, 1)
|
||
: 0;
|
||
}
|
||
return {
|
||
rows: calculated.tables.Wonga,
|
||
total: calculated.tables.Wonga.length ? num(calculated.calculation.total) : current,
|
||
};
|
||
}
|
||
const gum = costsFor("Gum"),
|
||
sa = costsFor("Sa"),
|
||
accepted = round.approved ? "Sa" : "Gum";
|
||
for (const row of rows)
|
||
for (const field of ["GN", "TC", "Ratio", ...components])
|
||
row["Total" + field] = num(row["Jun" + field]) + num(row[accepted + field]);
|
||
for (let i = rows.length - 1; i >= 0; i--) {
|
||
const row = rows[i];
|
||
if (num(row.Level) <= 0) continue;
|
||
const children = [];
|
||
for (
|
||
let j = i + 1;
|
||
j < rows.length &&
|
||
num(rows[j].Level) < num(row.Level) &&
|
||
![54, 59].includes(num(rows[j].LinkIndex));
|
||
j++
|
||
)
|
||
if (num(rows[j].Level) === 0 && num(rows[j].CalcIndex) < 2) children.push(rows[j]);
|
||
for (const prefix of ["Jun", "Gum", "Sa", "Total"])
|
||
for (const field of [...components, "TC"])
|
||
row[prefix + field] = children.reduce((n, child) => n + num(child[prefix + field]), 0);
|
||
}
|
||
const acceptedCost = round.approved ? sa : gum;
|
||
const costKeys = (items) => {
|
||
const occurrences = new Map();
|
||
return items.map((row) => {
|
||
const identity = JSON.stringify(row.Gubun ? ["code", row.Gubun] : ["name", row.Name || ""]);
|
||
const occurrence = occurrences.get(identity) || 0;
|
||
occurrences.set(identity, occurrence + 1);
|
||
return JSON.stringify([identity, occurrence]);
|
||
});
|
||
};
|
||
const oldCosts = previous?.costs || previous?.wonga || [];
|
||
const priorCosts = new Map(costKeys(oldCosts).map((key, index) => [key, oldCosts[index]]));
|
||
const currentKeys = costKeys(acceptedCost.rows);
|
||
const costs = acceptedCost.rows.map((row, index) => {
|
||
const previous = priorCosts.get(currentKeys[index]);
|
||
const jun = num(previous?.TotalCost ?? previous?.Cost);
|
||
return {
|
||
...row,
|
||
ContractCost: num(source.wonga[index]?.Cost),
|
||
JunCost: jun,
|
||
GumCost: num(gum.rows[index]?.Cost),
|
||
SaCost: num(sa.rows[index]?.Cost),
|
||
TotalCost: jun + num(row.Cost),
|
||
};
|
||
});
|
||
return {
|
||
rows,
|
||
wonga: acceptedCost.rows,
|
||
costs,
|
||
gumWonga: gum.rows,
|
||
saWonga: sa.rows,
|
||
total: acceptedCost.total,
|
||
ratio: contract
|
||
? floating(
|
||
(direct.reduce((n, row) => n + num(row[accepted + "TC"]), 0) / contract) * 100,
|
||
2,
|
||
1,
|
||
)
|
||
: 0,
|
||
errors: [...new Set(errors)],
|
||
};
|
||
}
|
||
function lock(project, id) {
|
||
const next = structuredClone(project),
|
||
round = next.progress.find((item) => item.id === id);
|
||
if (!round) throw Error("기성 회차 없음");
|
||
if (round.locked) throw Error("이미 확정한 회차입니다.");
|
||
round.contract = {
|
||
rows: structuredClone(project.tables.EstMainDat),
|
||
wonga: structuredClone(project.tables.Wonga),
|
||
options: { ...project.options },
|
||
};
|
||
const result = calculate(next, id);
|
||
if (result.errors.length) throw Error(result.errors.join("\n"));
|
||
round.result = result;
|
||
round.locked = true;
|
||
return next;
|
||
}
|
||
function unlock(project, id) {
|
||
const next = structuredClone(project),
|
||
at = next.progress.findIndex((item) => item.id === id);
|
||
if (at < 0) throw Error("기성 회차 없음");
|
||
for (const round of next.progress.slice(at)) {
|
||
round.locked = false;
|
||
delete round.result;
|
||
delete round.contract;
|
||
}
|
||
return next;
|
||
}
|
||
function rebuild(project) {
|
||
for (const round of project.progress || [])
|
||
if (round.locked && round.contract) {
|
||
const result = calculate(project, round.id);
|
||
if (result.errors.length) throw Error(result.errors.join("\n"));
|
||
round.result = result;
|
||
}
|
||
return project;
|
||
}
|
||
return { calculate, lock, unlock, rebuild, ambiguousKeys };
|
||
})();
|