feat: add Condo owner desk frontend and backend
This commit is contained in:
Wyndham ARR
885
backend/scripts/audit-import-data.mjs
Normal file
885
backend/scripts/audit-import-data.mjs
Normal file
@@ -0,0 +1,885 @@
|
||||
import { readFile } from "node:fs/promises";
|
||||
import { dirname, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
const scriptDirectory = dirname(fileURLToPath(import.meta.url));
|
||||
const projectRoot = resolve(scriptDirectory, "../..");
|
||||
const ownerFile = resolve(projectRoot, "业主账户.md");
|
||||
const usageFile = resolve(projectRoot, "使用记录.md");
|
||||
|
||||
const ROOM_TYPES = [
|
||||
"RM1",
|
||||
"RM2",
|
||||
"RM3",
|
||||
"RM4",
|
||||
"UG1",
|
||||
"UG2",
|
||||
"SU1",
|
||||
"SU2",
|
||||
"SU6",
|
||||
"SU3",
|
||||
"AC2"
|
||||
];
|
||||
const ROOM_TYPE_SET = new Set(ROOM_TYPES);
|
||||
const TIER = new Map([
|
||||
["RM1", 1],
|
||||
["RM2", 1],
|
||||
["RM3", 1],
|
||||
["RM4", 1],
|
||||
["UG1", 1],
|
||||
["UG2", 1],
|
||||
["SU1", 2],
|
||||
["SU2", 2],
|
||||
["SU6", 2],
|
||||
["SU3", 3]
|
||||
]);
|
||||
|
||||
function markdownCells(line) {
|
||||
const value = line.trim();
|
||||
if (!value.startsWith("|") || !value.endsWith("|")) return null;
|
||||
return value
|
||||
.slice(1, -1)
|
||||
.split("|")
|
||||
.map(cell => cell.trim());
|
||||
}
|
||||
|
||||
function isSeparatorRow(cells) {
|
||||
return cells?.length > 0 && cells.every(cell => /^:?-{3,}:?$/.test(cell));
|
||||
}
|
||||
|
||||
function tableRows(lines, headerIndex, endIndex) {
|
||||
const rows = [];
|
||||
for (let index = headerIndex + 1; index < endIndex; index += 1) {
|
||||
if (!lines[index].trim()) {
|
||||
if (rows.length) break;
|
||||
continue;
|
||||
}
|
||||
const cells = markdownCells(lines[index]);
|
||||
if (!cells) {
|
||||
if (rows.length) break;
|
||||
continue;
|
||||
}
|
||||
if (isSeparatorRow(cells)) continue;
|
||||
rows.push({ cells, line: index + 1 });
|
||||
}
|
||||
return rows;
|
||||
}
|
||||
|
||||
function integerValue(value) {
|
||||
return /^-?\d+$/.test(value) ? Number(value) : null;
|
||||
}
|
||||
|
||||
function roomNumbers(value) {
|
||||
return [...new Set(value.match(/\b\d{4}\b/g) ?? [])];
|
||||
}
|
||||
|
||||
function normalizedName(value) {
|
||||
return value
|
||||
.normalize("NFKC")
|
||||
.toUpperCase()
|
||||
.replace(/[^A-Z0-9\u0E00-\u0E7F]+/g, "");
|
||||
}
|
||||
|
||||
function sameValues(left, right) {
|
||||
return [...left].sort().join("|") === [...right].sort().join("|");
|
||||
}
|
||||
|
||||
function validIsoDate(value) {
|
||||
if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
|
||||
const timestamp = Date.parse(`${value}T00:00:00Z`);
|
||||
return Number.isFinite(timestamp)
|
||||
&& new Date(timestamp).toISOString().slice(0, 10) === value;
|
||||
}
|
||||
|
||||
function dateDifference(checkIn, checkOut) {
|
||||
if (!validIsoDate(checkIn) || !validIsoDate(checkOut)) return null;
|
||||
return Math.round(
|
||||
(Date.parse(`${checkOut}T00:00:00Z`) - Date.parse(`${checkIn}T00:00:00Z`))
|
||||
/ 86_400_000
|
||||
);
|
||||
}
|
||||
|
||||
function grouped(items, keyOf) {
|
||||
const groups = new Map();
|
||||
for (const item of items) {
|
||||
const key = keyOf(item);
|
||||
const values = groups.get(key) ?? [];
|
||||
values.push(item);
|
||||
groups.set(key, values);
|
||||
}
|
||||
return groups;
|
||||
}
|
||||
|
||||
function duplicateSummary(items, keyOf, project) {
|
||||
return [...grouped(items, keyOf)]
|
||||
.filter(([, values]) => values.length > 1)
|
||||
.map(([key, values]) => ({
|
||||
key,
|
||||
count: values.length,
|
||||
records: values.map(project)
|
||||
}));
|
||||
}
|
||||
|
||||
function explicitRoomTypeCodes(value) {
|
||||
const upper = value.toUpperCase();
|
||||
return ROOM_TYPES.filter(code => {
|
||||
const expression = new RegExp(`(^|[^A-Z0-9])${code}([^A-Z0-9]|$)`);
|
||||
return expression.test(upper);
|
||||
});
|
||||
}
|
||||
|
||||
function classifyUsedRoomType(value) {
|
||||
const normalized = value
|
||||
.replace(/<br\s*\/?>/gi, " ")
|
||||
.replace(/\s+/g, " ")
|
||||
.trim()
|
||||
.toUpperCase();
|
||||
const explicitCodes = explicitRoomTypeCodes(normalized);
|
||||
if (explicitCodes.length === 1) {
|
||||
const code = explicitCodes[0];
|
||||
return {
|
||||
kind: "canonical",
|
||||
code,
|
||||
tier: TIER.get(code) ?? null,
|
||||
candidates: [code],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
if (/\bFAM(?:ILY)?\b/.test(normalized)) {
|
||||
return {
|
||||
kind: "alias",
|
||||
code: null,
|
||||
tier: 3,
|
||||
candidates: ["SU3"],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
if (normalized.includes("JUNIOR SUITE")) {
|
||||
return {
|
||||
kind: "alias",
|
||||
code: null,
|
||||
tier: 2,
|
||||
candidates: ["SU1", "SU2", "SU6"],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
if (normalized.includes("SUPERIOR ROOM")) {
|
||||
return {
|
||||
kind: "alias",
|
||||
code: null,
|
||||
tier: 1,
|
||||
candidates: ["RM1", "RM2", "RM3", "RM4"],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
if (normalized.includes("DELUXE ROOM")) {
|
||||
return {
|
||||
kind: "alias",
|
||||
code: null,
|
||||
tier: 1,
|
||||
candidates: ["UG1", "UG2"],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
return {
|
||||
kind: "unknown",
|
||||
code: null,
|
||||
tier: null,
|
||||
candidates: [],
|
||||
normalized
|
||||
};
|
||||
}
|
||||
|
||||
function automaticMultiplier(purchasedCodes, usedClassification, impliedEffectiveRatio) {
|
||||
if (
|
||||
purchasedCodes.includes("AC2")
|
||||
|| usedClassification.code === "AC2"
|
||||
) {
|
||||
return Number.isInteger(impliedEffectiveRatio)
|
||||
&& impliedEffectiveRatio >= 1
|
||||
&& impliedEffectiveRatio <= 3
|
||||
? impliedEffectiveRatio
|
||||
: null;
|
||||
}
|
||||
const purchasedTiers = purchasedCodes.map(code => TIER.get(code));
|
||||
if (
|
||||
!purchasedTiers.length
|
||||
|| purchasedTiers.some(tier => !tier)
|
||||
|| new Set(purchasedTiers).size !== 1
|
||||
|| !usedClassification.tier
|
||||
) return null;
|
||||
return Math.max(1, usedClassification.tier - purchasedTiers[0] + 1);
|
||||
}
|
||||
|
||||
const [ownerText, usageText] = await Promise.all([
|
||||
readFile(ownerFile, "utf8"),
|
||||
readFile(usageFile, "utf8")
|
||||
]);
|
||||
const ownerLines = ownerText.split(/\r?\n/);
|
||||
const usageLines = usageText.split(/\r?\n/);
|
||||
|
||||
const ownerHeaderIndex = ownerLines.findIndex(line =>
|
||||
line.startsWith("| Name | Room No. | Room Type | Unit No. | Member No. |")
|
||||
);
|
||||
if (ownerHeaderIndex < 0) throw new Error("OWNER_HEADER_NOT_FOUND");
|
||||
|
||||
const ownerRows = tableRows(ownerLines, ownerHeaderIndex, ownerLines.length)
|
||||
.map(({ cells, line }) => {
|
||||
if (cells.length !== 5) {
|
||||
return { line, malformed: true, cells };
|
||||
}
|
||||
const [name, roomNo, roomType, unitNo, memberNo] = cells;
|
||||
return {
|
||||
line,
|
||||
malformed: false,
|
||||
name,
|
||||
roomNo,
|
||||
roomType,
|
||||
unitNo,
|
||||
memberNo
|
||||
};
|
||||
});
|
||||
const validOwnerRows = ownerRows.filter(row => !row.malformed);
|
||||
const ownersByRoom = new Map(validOwnerRows.map(owner => [owner.roomNo, owner]));
|
||||
|
||||
const sectionStarts = usageLines
|
||||
.map((line, index) => {
|
||||
const match = line.match(/^## Room No\. (.+)$/);
|
||||
return match ? { index, heading: match[1].trim() } : null;
|
||||
})
|
||||
.filter(Boolean);
|
||||
|
||||
const sections = sectionStarts.map((start, sectionIndex) => {
|
||||
const end = sectionStarts[sectionIndex + 1]?.index ?? usageLines.length;
|
||||
const metadataHeaderIndex = usageLines.findIndex(
|
||||
(line, index) =>
|
||||
index > start.index
|
||||
&& index < end
|
||||
&& line.startsWith("| Owenr Name | Room No. | PURCHASED ROOM TYPE |"),
|
||||
);
|
||||
const usageHeaderIndex = usageLines.findIndex(
|
||||
(line, index) =>
|
||||
index > start.index
|
||||
&& index < end
|
||||
&& line.startsWith("| Confirmation No. | Check -IN | Check-OUT |"),
|
||||
);
|
||||
const metadataRows = metadataHeaderIndex < 0
|
||||
? []
|
||||
: tableRows(usageLines, metadataHeaderIndex, usageHeaderIndex < 0 ? end : usageHeaderIndex);
|
||||
const usageRows = usageHeaderIndex < 0
|
||||
? []
|
||||
: tableRows(usageLines, usageHeaderIndex, end);
|
||||
const metadata = metadataRows[0]?.cells.length === 4
|
||||
? {
|
||||
ownerName: metadataRows[0].cells[0],
|
||||
roomNoRaw: metadataRows[0].cells[1],
|
||||
purchasedTypeRaw: metadataRows[0].cells[2],
|
||||
transferOnRaw: metadataRows[0].cells[3],
|
||||
line: metadataRows[0].line
|
||||
}
|
||||
: null;
|
||||
|
||||
return {
|
||||
heading: start.heading,
|
||||
line: start.index + 1,
|
||||
headingRooms: roomNumbers(start.heading),
|
||||
metadata,
|
||||
metadataRooms: metadata ? roomNumbers(metadata.roomNoRaw) : [],
|
||||
usageRows: usageRows.map(({ cells, line }) => {
|
||||
if (cells.length !== 9) return { line, malformed: true, cells };
|
||||
const [
|
||||
confirmationNo,
|
||||
checkIn,
|
||||
checkOut,
|
||||
nightRaw,
|
||||
roomRaw,
|
||||
useRaw,
|
||||
balanceRaw,
|
||||
usedRoomTypeRaw,
|
||||
remark
|
||||
] = cells;
|
||||
const night = integerValue(nightRaw);
|
||||
const room = integerValue(roomRaw);
|
||||
const use = integerValue(useRaw);
|
||||
const balance = integerValue(balanceRaw);
|
||||
const denominator = night && room ? night * room : null;
|
||||
const impliedEffectiveRatio = denominator && use !== null && use % denominator === 0
|
||||
? use / denominator
|
||||
: null;
|
||||
const usedClassification = classifyUsedRoomType(usedRoomTypeRaw);
|
||||
const remarkRoomNumbers = roomNumbers(remark);
|
||||
const remarkOwners = remarkRoomNumbers
|
||||
.map(roomNo => ownersByRoom.get(roomNo))
|
||||
.filter(Boolean);
|
||||
const remarkRoomTypes = [...new Set(remarkOwners.map(owner => owner.roomType))];
|
||||
const remarkResolutionComplete = remarkRoomNumbers.length > 0
|
||||
&& remarkOwners.length === remarkRoomNumbers.length
|
||||
&& remarkRoomTypes.length === 1;
|
||||
const resolvedUsedClassification = remarkResolutionComplete
|
||||
? {
|
||||
kind: "remark",
|
||||
code: remarkRoomTypes[0],
|
||||
tier: TIER.get(remarkRoomTypes[0]) ?? null,
|
||||
candidates: [remarkRoomTypes[0]],
|
||||
normalized: usedClassification.normalized
|
||||
}
|
||||
: usedClassification;
|
||||
return {
|
||||
line,
|
||||
malformed: false,
|
||||
confirmationNo,
|
||||
checkIn,
|
||||
checkOut,
|
||||
nightRaw,
|
||||
roomRaw,
|
||||
useRaw,
|
||||
balanceRaw,
|
||||
night,
|
||||
room,
|
||||
use,
|
||||
balance,
|
||||
usedRoomTypeRaw,
|
||||
usedClassification,
|
||||
resolvedUsedClassification,
|
||||
usedTypeConflict: Boolean(
|
||||
usedClassification.code
|
||||
&& resolvedUsedClassification.code
|
||||
&& usedClassification.code !== resolvedUsedClassification.code
|
||||
),
|
||||
remarkRoomNumbers,
|
||||
remarkRoomsFound: remarkOwners.length,
|
||||
remarkRoomTypes,
|
||||
remark,
|
||||
impliedEffectiveRatio
|
||||
};
|
||||
})
|
||||
};
|
||||
});
|
||||
|
||||
const issues = [];
|
||||
function issue(code, severity, location, detail) {
|
||||
issues.push({ code, severity, ...location, detail });
|
||||
}
|
||||
|
||||
for (const row of ownerRows) {
|
||||
if (row.malformed) {
|
||||
issue("OWNER_ROW_MALFORMED", "blocker", {
|
||||
file: "业主账户.md",
|
||||
line: row.line
|
||||
}, `Expected 5 columns, found ${row.cells.length}`);
|
||||
continue;
|
||||
}
|
||||
for (const field of ["name", "roomNo", "roomType", "unitNo", "memberNo"]) {
|
||||
if (!row[field]) {
|
||||
issue("OWNER_REQUIRED_VALUE_MISSING", "blocker", {
|
||||
file: "业主账户.md",
|
||||
line: row.line,
|
||||
roomNo: row.roomNo
|
||||
}, `Missing ${field}`);
|
||||
}
|
||||
}
|
||||
if (!/^\d{4}$/.test(row.roomNo)) {
|
||||
issue("OWNER_ROOM_FORMAT_INVALID", "blocker", {
|
||||
file: "业主账户.md",
|
||||
line: row.line,
|
||||
roomNo: row.roomNo
|
||||
}, "Room No. is not exactly four digits");
|
||||
}
|
||||
if (!ROOM_TYPE_SET.has(row.roomType)) {
|
||||
issue("OWNER_ROOM_TYPE_UNKNOWN", "blocker", {
|
||||
file: "业主账户.md",
|
||||
line: row.line,
|
||||
roomNo: row.roomNo
|
||||
}, `Unknown purchased room type ${row.roomType}`);
|
||||
}
|
||||
}
|
||||
|
||||
const ownerRoomDuplicates = duplicateSummary(
|
||||
validOwnerRows,
|
||||
owner => owner.roomNo,
|
||||
owner => ({ line: owner.line, name: owner.name })
|
||||
);
|
||||
for (const duplicate of ownerRoomDuplicates) {
|
||||
issue("OWNER_ROOM_DUPLICATE", "blocker", {
|
||||
file: "业主账户.md",
|
||||
roomNo: duplicate.key
|
||||
}, `${duplicate.count} owner rows use this room number`);
|
||||
}
|
||||
|
||||
const allUsageRows = [];
|
||||
for (const section of sections) {
|
||||
if (!section.metadata) {
|
||||
issue("SECTION_METADATA_MISSING", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: section.line,
|
||||
section: section.heading
|
||||
}, "Owner metadata row is missing or malformed");
|
||||
}
|
||||
if (!section.usageRows.length) {
|
||||
issue("SECTION_USAGE_MISSING", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: section.line,
|
||||
section: section.heading
|
||||
}, "No usage rows were parsed");
|
||||
}
|
||||
if (section.metadata && !sameValues(section.headingRooms, section.metadataRooms)) {
|
||||
issue("SECTION_ROOM_HEADING_MISMATCH", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: section.line,
|
||||
section: section.heading
|
||||
}, `Heading rooms ${section.headingRooms.join(",")} differ from metadata rooms ${section.metadataRooms.join(",")}`);
|
||||
}
|
||||
for (const roomNo of section.metadataRooms) {
|
||||
if (!ownersByRoom.has(roomNo)) {
|
||||
issue("SECTION_OWNER_ROOM_NOT_FOUND", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: section.metadata?.line ?? section.line,
|
||||
section: section.heading,
|
||||
roomNo
|
||||
}, "Room number is absent from 业主账户.md");
|
||||
}
|
||||
}
|
||||
if (section.metadataRooms.length > 1) {
|
||||
issue("SECTION_MULTIPLE_ENTITLEMENT_ROOMS", "review", {
|
||||
file: "使用记录.md",
|
||||
line: section.metadata?.line ?? section.line,
|
||||
section: section.heading
|
||||
}, `${section.metadataRooms.length} independent owner rooms are combined`);
|
||||
}
|
||||
if (section.metadata) {
|
||||
const explicitPurchased = explicitRoomTypeCodes(section.metadata.purchasedTypeRaw);
|
||||
if (!explicitPurchased.length) {
|
||||
issue("SECTION_PURCHASED_TYPE_NONCANONICAL", "review", {
|
||||
file: "使用记录.md",
|
||||
line: section.metadata.line,
|
||||
section: section.heading
|
||||
}, `Noncanonical purchased type: ${section.metadata.purchasedTypeRaw}`);
|
||||
}
|
||||
if (section.metadataRooms.length === 1) {
|
||||
const master = ownersByRoom.get(section.metadataRooms[0]);
|
||||
if (
|
||||
master
|
||||
&& explicitPurchased.length === 1
|
||||
&& explicitPurchased[0] !== master.roomType
|
||||
) {
|
||||
issue("SECTION_PURCHASED_TYPE_MISMATCH", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: section.metadata.line,
|
||||
section: section.heading,
|
||||
roomNo: master.roomNo
|
||||
}, `Metadata says ${explicitPurchased[0]}, owner master says ${master.roomType}`);
|
||||
}
|
||||
if (
|
||||
master
|
||||
&& normalizedName(section.metadata.ownerName) !== normalizedName(master.name)
|
||||
) {
|
||||
issue("SECTION_OWNER_NAME_MISMATCH", "review", {
|
||||
file: "使用记录.md",
|
||||
line: section.metadata.line,
|
||||
section: section.heading,
|
||||
roomNo: master.roomNo
|
||||
}, `Metadata owner "${section.metadata.ownerName}" differs from master "${master.name}"`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const linkedOwners = section.metadataRooms
|
||||
.map(roomNo => ownersByRoom.get(roomNo))
|
||||
.filter(Boolean);
|
||||
const balancesByYear = new Map();
|
||||
const currentRuleBalancesByYear = new Map();
|
||||
const initialBalance = section.metadataRooms.length * 15;
|
||||
|
||||
for (const row of section.usageRows) {
|
||||
row.section = section.heading;
|
||||
row.sectionLine = section.line;
|
||||
row.metadataRooms = section.metadataRooms;
|
||||
row.headingRooms = section.headingRooms;
|
||||
row.linkedOwners = linkedOwners;
|
||||
row.balanceChainOk = false;
|
||||
allUsageRows.push(row);
|
||||
|
||||
const location = {
|
||||
file: "使用记录.md",
|
||||
line: row.line,
|
||||
section: section.heading,
|
||||
confirmationNo: row.confirmationNo
|
||||
};
|
||||
if (row.malformed) {
|
||||
issue("USAGE_ROW_MALFORMED", "blocker", location, `Expected 9 columns, found ${row.cells.length}`);
|
||||
continue;
|
||||
}
|
||||
if (!/^\d+$/.test(row.confirmationNo)) {
|
||||
issue("CONFIRMATION_NOT_DIGITS", "blocker", location, `Value is ${row.confirmationNo}`);
|
||||
}
|
||||
for (const field of ["night", "room", "use", "balance"]) {
|
||||
if (!Number.isInteger(row[field])) {
|
||||
issue("USAGE_INTEGER_INVALID", "blocker", location, `${field} is not an integer`);
|
||||
}
|
||||
}
|
||||
if (!validIsoDate(row.checkIn) || !validIsoDate(row.checkOut)) {
|
||||
issue("USAGE_DATE_INVALID", "blocker", location, `${row.checkIn} → ${row.checkOut}`);
|
||||
} else {
|
||||
const difference = dateDifference(row.checkIn, row.checkOut);
|
||||
if (difference !== row.night || difference <= 0) {
|
||||
issue("NIGHT_DATE_MISMATCH", "blocker", location, `Source Night ${row.night}; date difference ${difference}`);
|
||||
}
|
||||
if (row.checkIn.slice(0, 4) !== row.checkOut.slice(0, 4)) {
|
||||
issue("CROSS_YEAR_STAY", "blocker", location, `${row.checkIn} → ${row.checkOut}`);
|
||||
}
|
||||
}
|
||||
if (!Number.isInteger(row.room) || row.room <= 0) {
|
||||
issue("ROOM_COUNT_INVALID", "blocker", location, `Room is ${row.roomRaw}`);
|
||||
} else if (row.room > 1) {
|
||||
issue("ROOM_COUNT_GT_ONE", "transform", location, `Room=${row.room}; current usage model represents one room`);
|
||||
}
|
||||
if (!Number.isInteger(row.impliedEffectiveRatio)) {
|
||||
issue("IMPLIED_EFFECTIVE_RATIO_NOT_INTEGER", "blocker", location, `Use ${row.use} is not divisible by Night×Room`);
|
||||
} else if (row.impliedEffectiveRatio > 3) {
|
||||
issue("IMPLIED_EFFECTIVE_RATIO_GT_THREE", "blocker", location,
|
||||
`Use÷(Night×Room) implies ${row.impliedEffectiveRatio}; the source has no multiplier field`);
|
||||
}
|
||||
if (row.remarkRoomNumbers.length !== row.remarkRoomsFound) {
|
||||
issue("REMARK_ROOM_NOT_FOUND", "review", location,
|
||||
`Remark rooms ${row.remarkRoomNumbers.join(",")}; ${row.remarkRoomsFound} found in owner master`);
|
||||
}
|
||||
if (
|
||||
Number.isInteger(row.room)
|
||||
&& row.remarkRoomNumbers.length > 0
|
||||
&& row.remarkRoomNumbers.length !== row.room
|
||||
) {
|
||||
issue("REMARK_ROOM_COUNT_MISMATCH", "review", location,
|
||||
`Room=${row.room}; Remark contains ${row.remarkRoomNumbers.length} room numbers`);
|
||||
}
|
||||
if (row.remarkRoomTypes.length > 1) {
|
||||
issue("REMARK_MULTIPLE_USED_TYPES", "transform", location,
|
||||
`Remark rooms resolve to ${row.remarkRoomTypes.join(",")}`);
|
||||
}
|
||||
if (row.usedTypeConflict) {
|
||||
issue("USED_TYPE_REMARK_CONFLICT", "blocker", location,
|
||||
`Raw code ${row.usedClassification.code}; Remark rooms resolve to ${row.resolvedUsedClassification.code}`);
|
||||
}
|
||||
if (!row.resolvedUsedClassification.code) {
|
||||
issue("USED_ROOM_TYPE_MAPPING_REQUIRED", "review", location,
|
||||
`${row.usedRoomTypeRaw} → candidates ${row.resolvedUsedClassification.candidates.join(",") || "unknown"}`);
|
||||
}
|
||||
|
||||
if (
|
||||
validIsoDate(row.checkIn)
|
||||
&& Number.isInteger(row.use)
|
||||
&& Number.isInteger(row.balance)
|
||||
&& initialBalance > 0
|
||||
) {
|
||||
const year = row.checkIn.slice(0, 4);
|
||||
const balanceBefore = balancesByYear.get(year) ?? initialBalance;
|
||||
const expectedBalance = balanceBefore - row.use;
|
||||
row.balanceBeforeSource = balanceBefore;
|
||||
row.expectedSourceBalance = expectedBalance;
|
||||
row.balanceChainOk = row.balance === expectedBalance;
|
||||
if (!row.balanceChainOk) {
|
||||
issue("BALANCE_CHAIN_MISMATCH", "blocker", location,
|
||||
`Expected ${expectedBalance} after ${balanceBefore}-${row.use}; source has ${row.balance}`);
|
||||
}
|
||||
balancesByYear.set(year, row.balance);
|
||||
}
|
||||
|
||||
const purchasedTypes = linkedOwners.map(owner => owner.roomType);
|
||||
const expectedMultiplier = automaticMultiplier(
|
||||
purchasedTypes,
|
||||
row.resolvedUsedClassification,
|
||||
row.impliedEffectiveRatio
|
||||
);
|
||||
row.purchasedTypesForRule = purchasedTypes;
|
||||
row.expectedMultiplier = expectedMultiplier;
|
||||
row.expectedUseCurrentRule = expectedMultiplier !== null
|
||||
&& Number.isInteger(row.night)
|
||||
&& Number.isInteger(row.room)
|
||||
? row.night * row.room * expectedMultiplier
|
||||
: null;
|
||||
row.currentRuleCompatible = expectedMultiplier !== null
|
||||
&& row.use === row.expectedUseCurrentRule;
|
||||
if (
|
||||
expectedMultiplier !== null
|
||||
&& Number.isInteger(row.use)
|
||||
&& Number.isInteger(row.night)
|
||||
&& Number.isInteger(row.room)
|
||||
&& !row.currentRuleCompatible
|
||||
) {
|
||||
issue("CURRENT_RULE_USE_MISMATCH", "blocker", location,
|
||||
`Source Use ${row.use}; current room lookup/rules imply ${row.expectedUseCurrentRule}`);
|
||||
}
|
||||
|
||||
if (validIsoDate(row.checkIn)) {
|
||||
const year = row.checkIn.slice(0, 4);
|
||||
const balanceBefore = currentRuleBalancesByYear.has(year)
|
||||
? currentRuleBalancesByYear.get(year)
|
||||
: initialBalance;
|
||||
if (
|
||||
balanceBefore !== null
|
||||
&& Number.isInteger(row.expectedUseCurrentRule)
|
||||
) {
|
||||
row.balanceBeforeCurrentRule = balanceBefore;
|
||||
row.balanceAfterCurrentRule = balanceBefore - row.expectedUseCurrentRule;
|
||||
row.currentRuleBalanceMatchesSource = row.balanceAfterCurrentRule === row.balance;
|
||||
if (!row.currentRuleBalanceMatchesSource) {
|
||||
issue("CURRENT_RULE_BALANCE_MISMATCH", "blocker", location,
|
||||
`Current-rule balance would be ${row.balanceAfterCurrentRule}; source has ${row.balance}`);
|
||||
}
|
||||
currentRuleBalancesByYear.set(year, row.balanceAfterCurrentRule);
|
||||
} else {
|
||||
row.currentRuleBalanceMatchesSource = null;
|
||||
currentRuleBalancesByYear.set(year, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const usableRows = allUsageRows.filter(row => !row.malformed);
|
||||
const confirmationDuplicates = duplicateSummary(
|
||||
usableRows,
|
||||
row => row.confirmationNo,
|
||||
row => ({ line: row.line, section: row.section, balance: row.balance, usedRoomType: row.usedRoomTypeRaw })
|
||||
);
|
||||
for (const duplicate of confirmationDuplicates) {
|
||||
issue("CONFIRMATION_DUPLICATE", "blocker", {
|
||||
file: "使用记录.md",
|
||||
confirmationNo: duplicate.key
|
||||
}, `${duplicate.count} usage lines share this confirmation`);
|
||||
}
|
||||
|
||||
const duplicateConfirmations = new Set(confirmationDuplicates.map(item => item.key));
|
||||
for (const row of usableRows) {
|
||||
const singleLinkedOwner = row.metadataRooms.length === 1
|
||||
&& row.linkedOwners.length === 1;
|
||||
const headingMatches = sameValues(row.headingRooms, row.metadataRooms);
|
||||
const validDates = validIsoDate(row.checkIn)
|
||||
&& validIsoDate(row.checkOut)
|
||||
&& dateDifference(row.checkIn, row.checkOut) === row.night
|
||||
&& row.checkIn.slice(0, 4) === row.checkOut.slice(0, 4);
|
||||
row.structurallyDirect = singleLinkedOwner
|
||||
&& headingMatches
|
||||
&& row.room === 1
|
||||
&& /^\d+$/.test(row.confirmationNo)
|
||||
&& !duplicateConfirmations.has(row.confirmationNo)
|
||||
&& validDates
|
||||
&& row.balanceChainOk;
|
||||
row.fullyDirect = row.structurallyDirect
|
||||
&& Boolean(row.resolvedUsedClassification.code)
|
||||
&& !row.usedTypeConflict
|
||||
&& row.currentRuleCompatible
|
||||
&& row.currentRuleBalanceMatchesSource !== false;
|
||||
}
|
||||
|
||||
const declaredOwnerCount = Number(ownerText.match(/共\s*(\d+)\s*条记录/)?.[1]);
|
||||
const declaredSectionCount = Number(usageText.match(/共\s*(\d+)\s*个房号子表/)?.[1]);
|
||||
const declaredUsageCount = Number(usageText.match(/、(\d+)\s*条实际使用记录/)?.[1]);
|
||||
const declaredCoveredRoomCount = Number(usageText.match(/覆盖\s*(\d+)\s*个房号/)?.[1]);
|
||||
if (declaredOwnerCount !== validOwnerRows.length) {
|
||||
issue("DECLARED_OWNER_COUNT_MISMATCH", "blocker", {
|
||||
file: "业主账户.md",
|
||||
line: 3
|
||||
}, `Declared ${declaredOwnerCount}; parsed ${validOwnerRows.length}`);
|
||||
}
|
||||
if (declaredSectionCount !== sections.length) {
|
||||
issue("DECLARED_SECTION_COUNT_MISMATCH", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: 3
|
||||
}, `Declared ${declaredSectionCount}; parsed ${sections.length}`);
|
||||
}
|
||||
if (declaredUsageCount !== usableRows.length) {
|
||||
issue("DECLARED_USAGE_COUNT_MISMATCH", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: 3
|
||||
}, `Declared ${declaredUsageCount}; parsed ${usableRows.length}`);
|
||||
}
|
||||
|
||||
const uniqueHeadingRooms = new Set(sections.flatMap(section => section.headingRooms));
|
||||
if (declaredCoveredRoomCount !== uniqueHeadingRooms.size) {
|
||||
issue("DECLARED_COVERED_ROOM_COUNT_MISMATCH", "blocker", {
|
||||
file: "使用记录.md",
|
||||
line: 5
|
||||
}, `Declared ${declaredCoveredRoomCount}; heading tokens contain ${uniqueHeadingRooms.size}`);
|
||||
}
|
||||
|
||||
const issueCounts = Object.fromEntries(
|
||||
[...grouped(issues, item => item.code)]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([code, values]) => [code, values.length])
|
||||
);
|
||||
const issueSamples = Object.fromEntries(
|
||||
[...grouped(issues, item => item.code)]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([code, values]) => [code, values.slice(0, 8)])
|
||||
);
|
||||
const blockerIssues = issues.filter(item => item.severity === "blocker");
|
||||
const transformIssues = issues.filter(item => item.severity === "transform");
|
||||
|
||||
const roomTypeDistribution = Object.fromEntries(
|
||||
[...grouped(validOwnerRows, owner => owner.roomType)]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([code, values]) => [code, values.length])
|
||||
);
|
||||
const usedRoomTypeDistribution = Object.fromEntries(
|
||||
[...grouped(usableRows, row => row.usedRoomTypeRaw)]
|
||||
.sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))
|
||||
.map(([label, values]) => [label, values.length])
|
||||
);
|
||||
const impliedEffectiveRatioDistribution = Object.fromEntries(
|
||||
[...grouped(usableRows, row => String(row.impliedEffectiveRatio))]
|
||||
.sort(([left], [right]) => Number(left) - Number(right))
|
||||
.map(([value, rows]) => [value, rows.length])
|
||||
);
|
||||
const yearDistribution = Object.fromEntries(
|
||||
[...grouped(usableRows, row => row.checkIn.slice(0, 4))]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([year, rows]) => [year, rows.length])
|
||||
);
|
||||
const metadataValues = sections
|
||||
.filter(section => section.metadata)
|
||||
.map(section => ({
|
||||
line: section.metadata.line,
|
||||
section: section.heading,
|
||||
transferOnRaw: section.metadata.transferOnRaw,
|
||||
purchasedTypeRaw: section.metadata.purchasedTypeRaw
|
||||
}));
|
||||
|
||||
const report = {
|
||||
mode: "read-only",
|
||||
sourceFiles: {
|
||||
owners: "业主账户.md",
|
||||
usage: "使用记录.md"
|
||||
},
|
||||
owners: {
|
||||
declaredRecords: declaredOwnerCount,
|
||||
parsedRecords: validOwnerRows.length,
|
||||
malformedRows: ownerRows.length - validOwnerRows.length,
|
||||
uniqueRoomNumbers: new Set(validOwnerRows.map(owner => owner.roomNo)).size,
|
||||
roomTypeDistribution,
|
||||
importDefaultsRequired: {
|
||||
accountNo: "not supplied; database column is nullable",
|
||||
transferDate: "not supplied in 业主账户.md; database column is nullable"
|
||||
},
|
||||
maxFieldLengths: {
|
||||
name: Math.max(...validOwnerRows.map(owner => owner.name.length)),
|
||||
roomNo: Math.max(...validOwnerRows.map(owner => owner.roomNo.length)),
|
||||
roomType: Math.max(...validOwnerRows.map(owner => owner.roomType.length)),
|
||||
unitNo: Math.max(...validOwnerRows.map(owner => owner.unitNo.length)),
|
||||
memberNo: Math.max(...validOwnerRows.map(owner => owner.memberNo.length))
|
||||
},
|
||||
duplicateRoomNumbers: ownerRoomDuplicates,
|
||||
duplicateMemberNumbers: duplicateSummary(
|
||||
validOwnerRows,
|
||||
owner => owner.memberNo,
|
||||
owner => ({ line: owner.line, roomNo: owner.roomNo, name: owner.name })
|
||||
),
|
||||
duplicateUnitNumbers: duplicateSummary(
|
||||
validOwnerRows,
|
||||
owner => owner.unitNo,
|
||||
owner => ({ line: owner.line, roomNo: owner.roomNo, name: owner.name })
|
||||
)
|
||||
},
|
||||
usage: {
|
||||
declaredSections: declaredSectionCount,
|
||||
parsedSections: sections.length,
|
||||
declaredRecords: declaredUsageCount,
|
||||
parsedRecords: usableRows.length,
|
||||
declaredCoveredRooms: declaredCoveredRoomCount,
|
||||
uniqueHeadingRooms: uniqueHeadingRooms.size,
|
||||
uniqueMetadataRooms: new Set(sections.flatMap(section => section.metadataRooms)).size,
|
||||
uniqueConfirmations: new Set(usableRows.map(row => row.confirmationNo)).size,
|
||||
confirmationDuplicates,
|
||||
nonDigitConfirmations: usableRows
|
||||
.filter(row => !/^\d+$/.test(row.confirmationNo))
|
||||
.map(row => ({ line: row.line, section: row.section, confirmationNo: row.confirmationNo })),
|
||||
yearDistribution,
|
||||
impliedEffectiveRatioDistribution,
|
||||
roomCountDistribution: Object.fromEntries(
|
||||
[...grouped(usableRows, row => String(row.room))]
|
||||
.sort(([left], [right]) => Number(left) - Number(right))
|
||||
.map(([value, rows]) => [value, rows.length])
|
||||
),
|
||||
usedRoomTypeDistribution,
|
||||
rawCanonicalUsedTypeRows: usableRows.filter(row => row.usedClassification.kind === "canonical").length,
|
||||
rawAliasUsedTypeRows: usableRows.filter(row => row.usedClassification.kind === "alias").length,
|
||||
rawUnknownUsedTypeRows: usableRows.filter(row => row.usedClassification.kind === "unknown").length,
|
||||
remarkResolvedUsedTypeRows: usableRows.filter(row => row.resolvedUsedClassification.kind === "remark").length,
|
||||
resolvedCanonicalUsedTypeRows: usableRows.filter(row => Boolean(row.resolvedUsedClassification.code)).length,
|
||||
unresolvedUsedTypeRows: usableRows.filter(row => !row.resolvedUsedClassification.code).length,
|
||||
usedTypeConflictRows: usableRows.filter(row => row.usedTypeConflict).length,
|
||||
structurallyDirectRows: usableRows.filter(row => row.structurallyDirect).length,
|
||||
fullyDirectRows: usableRows.filter(row => row.fullyDirect).length,
|
||||
currentRuleCompatibleRows: usableRows.filter(row => row.currentRuleCompatible).length,
|
||||
currentRuleEvaluatedRows: usableRows.filter(row => row.expectedMultiplier !== null).length,
|
||||
balanceChainValidRows: usableRows.filter(row => row.balanceChainOk).length,
|
||||
currentRuleBalanceEvaluatedRows: usableRows.filter(row => typeof row.currentRuleBalanceMatchesSource === "boolean").length,
|
||||
currentRuleBalanceMatchingRows: usableRows.filter(row => row.currentRuleBalanceMatchesSource === true).length,
|
||||
currentRuleBalanceMismatchingRows: usableRows.filter(row => row.currentRuleBalanceMatchesSource === false).length,
|
||||
maxRoomCount: Math.max(...usableRows.map(row => row.room ?? 0)),
|
||||
maxBalance: Math.max(...usableRows.map(row => row.balance ?? 0)),
|
||||
maxFieldLengths: {
|
||||
confirmationNo: Math.max(...usableRows.map(row => row.confirmationNo.length)),
|
||||
usedRoomTypeRaw: Math.max(...usableRows.map(row => row.usedRoomTypeRaw.length)),
|
||||
remark: Math.max(...usableRows.map(row => row.remark.length))
|
||||
}
|
||||
},
|
||||
associations: {
|
||||
multiRoomSections: sections
|
||||
.filter(section => section.metadataRooms.length > 1)
|
||||
.map(section => ({
|
||||
line: section.line,
|
||||
heading: section.heading,
|
||||
metadataRooms: section.metadataRooms,
|
||||
usageRows: section.usageRows.length
|
||||
})),
|
||||
headingMetadataMismatches: sections
|
||||
.filter(section => !sameValues(section.headingRooms, section.metadataRooms))
|
||||
.map(section => ({
|
||||
line: section.line,
|
||||
heading: section.heading,
|
||||
headingRooms: section.headingRooms,
|
||||
metadataRooms: section.metadataRooms
|
||||
})),
|
||||
metadataRoomsAbsentFromOwners: [...new Set(
|
||||
sections
|
||||
.flatMap(section => section.metadataRooms)
|
||||
.filter(roomNo => !ownersByRoom.has(roomNo))
|
||||
)],
|
||||
rowsWithRemarkRoomNumbers: usableRows.filter(row => row.remarkRoomNumbers.length > 0).length,
|
||||
rowsWithAllRemarkRoomsFound: usableRows.filter(row =>
|
||||
row.remarkRoomNumbers.length > 0
|
||||
&& row.remarkRoomNumbers.length === row.remarkRoomsFound
|
||||
).length,
|
||||
rowsWithMultipleRemarkRoomTypes: usableRows.filter(row => row.remarkRoomTypes.length > 1).length
|
||||
},
|
||||
metadata: {
|
||||
isoTransferDateRows: metadataValues.filter(item => validIsoDate(item.transferOnRaw)).length,
|
||||
nonIsoOrCompoundTransferDateRows: metadataValues
|
||||
.filter(item => !validIsoDate(item.transferOnRaw))
|
||||
.map(item => ({
|
||||
line: item.line,
|
||||
section: item.section,
|
||||
transferOnRaw: item.transferOnRaw
|
||||
})),
|
||||
canonicalPurchasedTypeRows: metadataValues.filter(item =>
|
||||
explicitRoomTypeCodes(item.purchasedTypeRaw).length > 0
|
||||
).length,
|
||||
noncanonicalPurchasedTypeRows: metadataValues
|
||||
.filter(item => explicitRoomTypeCodes(item.purchasedTypeRaw).length === 0)
|
||||
.map(item => ({
|
||||
line: item.line,
|
||||
section: item.section,
|
||||
purchasedTypeRaw: item.purchasedTypeRaw
|
||||
}))
|
||||
},
|
||||
issueCounts,
|
||||
issueSamples,
|
||||
blockerIssues,
|
||||
transformIssues,
|
||||
severityCounts: Object.fromEntries(
|
||||
[...grouped(issues, item => item.severity)]
|
||||
.sort(([left], [right]) => left.localeCompare(right))
|
||||
.map(([severity, values]) => [severity, values.length])
|
||||
)
|
||||
};
|
||||
|
||||
process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
|
||||
Reference in New Issue
Block a user