739 行
24 KiB
JavaScript
739 行
24 KiB
JavaScript
const { AppError } = require("../utils/AppError");
|
|
|
|
const TRAVEL_RECONCILIATION_BATCH_STATUSES = Object.freeze({
|
|
draft: "draft",
|
|
reconciled: "reconciled",
|
|
});
|
|
|
|
const TRAVEL_RECONCILIATION_ITEM_KINDS = Object.freeze({
|
|
order: "order",
|
|
orphanTransaction: "orphan_transaction",
|
|
});
|
|
|
|
const TRAVEL_RECONCILIATION_MATCH_STATUSES = Object.freeze({
|
|
matched: "matched",
|
|
amountMismatch: "amount_mismatch",
|
|
currencyMismatch: "currency_mismatch",
|
|
missingTransaction: "missing_transaction",
|
|
duplicateCharge: "duplicate_charge",
|
|
orphanTransaction: "orphan_transaction",
|
|
reversedAfterPayment: "reversed_after_payment",
|
|
});
|
|
|
|
const TRAVEL_RECONCILIATION_RESOLUTION_STATUSES = Object.freeze({
|
|
pending: "pending",
|
|
confirmed: "confirmed",
|
|
});
|
|
|
|
function buildValidationError(details, statusCode = 409) {
|
|
return new AppError({
|
|
code: "VALID_001",
|
|
message: "参数校验失败",
|
|
statusCode,
|
|
details,
|
|
});
|
|
}
|
|
|
|
function toMoneyNumber(value) {
|
|
const numeric = Number(value ?? 0);
|
|
if (!Number.isFinite(numeric)) {
|
|
return 0;
|
|
}
|
|
return Number(numeric.toFixed(2));
|
|
}
|
|
|
|
function toMoneyFixed(value) {
|
|
return toMoneyNumber(value).toFixed(2);
|
|
}
|
|
|
|
function toDateOnlyString(value) {
|
|
if (!value) {
|
|
return null;
|
|
}
|
|
try {
|
|
return new Date(value).toISOString().slice(0, 10);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function normalizeSummaryJson(value) {
|
|
const summary = value && typeof value === "object" ? value : {};
|
|
return {
|
|
totalOrders: Number(summary.totalOrders ?? 0),
|
|
totalTransactions: Number(summary.totalTransactions ?? 0),
|
|
matchedItems: Number(summary.matchedItems ?? 0),
|
|
pendingItems: Number(summary.pendingItems ?? 0),
|
|
anomalyItems: Number(summary.anomalyItems ?? 0),
|
|
totalOrderAmount: toMoneyFixed(summary.totalOrderAmount),
|
|
totalSettledAmount: toMoneyFixed(summary.totalSettledAmount),
|
|
totalReversedAmount: toMoneyFixed(summary.totalReversedAmount),
|
|
matchRate: toMoneyFixed(summary.matchRate),
|
|
};
|
|
}
|
|
|
|
function isSettledCharge(transaction) {
|
|
return transaction?.txn_type === "charge" && transaction?.status === "settled";
|
|
}
|
|
|
|
function isReversedTransaction(transaction) {
|
|
return ["refund", "reversal"].includes(String(transaction?.txn_type ?? "")) || transaction?.status === "reversed";
|
|
}
|
|
|
|
function sumTransactionAmounts(items, predicate) {
|
|
return items.reduce((total, item) => {
|
|
if (!predicate(item)) {
|
|
return total;
|
|
}
|
|
return toMoneyNumber(total + toMoneyNumber(item.amount));
|
|
}, 0);
|
|
}
|
|
|
|
function buildReasonDetail(matchStatus, order, settledCharges, reversedTransactions) {
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.matched) {
|
|
return `订单 ${order.external_order_no} 与已结算交易精确匹配。`;
|
|
}
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.missingTransaction) {
|
|
return `订单 ${order.external_order_no} 未找到已结算的 charge 交易。`;
|
|
}
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.duplicateCharge) {
|
|
return `订单 ${order.external_order_no} 关联到 ${settledCharges.length} 条已结算 charge 交易，无法判定唯一匹配。`;
|
|
}
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.currencyMismatch) {
|
|
return `订单 ${order.external_order_no} 与交易 ${settledCharges[0]?.external_txn_id ?? "-"} 币种不一致。`;
|
|
}
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.amountMismatch) {
|
|
return `订单 ${order.external_order_no} 与交易 ${settledCharges[0]?.external_txn_id ?? "-"} 金额不一致。`;
|
|
}
|
|
if (matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.reversedAfterPayment) {
|
|
return `订单 ${order.external_order_no} 在支付后存在 ${reversedTransactions.length} 条 refund/reversal 交易。`;
|
|
}
|
|
return `订单 ${order.external_order_no} 存在待人工确认的差异。`;
|
|
}
|
|
|
|
function analyzeOrderTransactions(order, orderTransactions = []) {
|
|
const settledCharges = orderTransactions.filter(isSettledCharge);
|
|
const reversedTransactions = orderTransactions.filter(isReversedTransaction);
|
|
const settledAmount = sumTransactionAmounts(settledCharges, () => true);
|
|
const primaryTransaction = settledCharges[0] ?? reversedTransactions[0] ?? null;
|
|
const exactMatch =
|
|
settledCharges.length === 1 &&
|
|
String(order.currency ?? "").toUpperCase() === String(primaryTransaction?.currency ?? "").toUpperCase() &&
|
|
toMoneyFixed(order.amount) === toMoneyFixed(primaryTransaction?.amount);
|
|
|
|
let matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.missingTransaction;
|
|
|
|
if (reversedTransactions.length > 0) {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.reversedAfterPayment;
|
|
} else if (settledCharges.length === 0) {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.missingTransaction;
|
|
} else if (settledCharges.length > 1) {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.duplicateCharge;
|
|
} else if (String(order.currency ?? "").toUpperCase() !== String(primaryTransaction?.currency ?? "").toUpperCase()) {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.currencyMismatch;
|
|
} else if (!exactMatch) {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.amountMismatch;
|
|
} else {
|
|
matchStatus = TRAVEL_RECONCILIATION_MATCH_STATUSES.matched;
|
|
}
|
|
|
|
const anomalyCode = matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.matched ? null : matchStatus;
|
|
const resolutionStatus =
|
|
matchStatus === TRAVEL_RECONCILIATION_MATCH_STATUSES.matched
|
|
? TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.confirmed
|
|
: TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.pending;
|
|
|
|
return {
|
|
primaryTransaction,
|
|
matchStatus,
|
|
anomalyCode,
|
|
resolutionStatus,
|
|
transactionAmount: toMoneyFixed(settledAmount || primaryTransaction?.amount),
|
|
matchedTransactionIds: orderTransactions.map((item) => item.id),
|
|
reasonDetail: buildReasonDetail(matchStatus, order, settledCharges, reversedTransactions),
|
|
};
|
|
}
|
|
|
|
function buildInvoiceStatsMap(invoices = []) {
|
|
const stats = new Map();
|
|
for (const invoice of invoices) {
|
|
if (!invoice.travel_order_id) {
|
|
continue;
|
|
}
|
|
const current = stats.get(invoice.travel_order_id) ?? {
|
|
count: 0,
|
|
amount: 0,
|
|
};
|
|
current.count += 1;
|
|
current.amount = toMoneyNumber(current.amount + toMoneyNumber(invoice.total_amount));
|
|
stats.set(invoice.travel_order_id, current);
|
|
}
|
|
return stats;
|
|
}
|
|
|
|
function buildOrderItem({ order, orderTransactions = [], invoiceStatsMap, actorId, now }) {
|
|
const analysis = analyzeOrderTransactions(order, orderTransactions);
|
|
const invoiceStats = invoiceStatsMap.get(order.id) ?? { count: 0, amount: 0 };
|
|
const primaryTransaction = analysis.primaryTransaction;
|
|
const autoConfirmed = analysis.resolutionStatus === TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.confirmed;
|
|
|
|
return {
|
|
item_kind: TRAVEL_RECONCILIATION_ITEM_KINDS.order,
|
|
travel_request_id: order.travel_request_id ?? null,
|
|
travel_order_id: order.id,
|
|
card_transaction_id: primaryTransaction?.id ?? null,
|
|
match_status: analysis.matchStatus,
|
|
resolution_status: analysis.resolutionStatus,
|
|
order_amount: toMoneyFixed(order.amount),
|
|
transaction_amount: analysis.transactionAmount,
|
|
currency: order.currency ?? primaryTransaction?.currency ?? "CNY",
|
|
anomaly_code: analysis.anomalyCode,
|
|
snapshot_json: {
|
|
requestNo: order.travel_request?.request_no ?? null,
|
|
externalOrderNo: order.external_order_no,
|
|
externalTxnId: primaryTransaction?.external_txn_id ?? null,
|
|
travelOrderStatus: order.status,
|
|
transactionStatus: primaryTransaction?.status ?? null,
|
|
linkedReimbursementId: order.linked_reimbursement_id ?? null,
|
|
boundInvoiceCount: invoiceStats.count,
|
|
boundInvoiceAmount: toMoneyFixed(invoiceStats.amount),
|
|
matchedTransactionIds: analysis.matchedTransactionIds,
|
|
reasonDetail: analysis.reasonDetail,
|
|
},
|
|
confirmed_at: autoConfirmed ? now : null,
|
|
confirmed_by: autoConfirmed ? actorId : null,
|
|
confirm_note: null,
|
|
};
|
|
}
|
|
|
|
function buildOrphanTransactionItem({ transaction, actorId, now }) {
|
|
return {
|
|
item_kind: TRAVEL_RECONCILIATION_ITEM_KINDS.orphanTransaction,
|
|
travel_request_id: transaction.travel_request_id ?? null,
|
|
travel_order_id: transaction.travel_order_id ?? null,
|
|
card_transaction_id: transaction.id,
|
|
match_status: TRAVEL_RECONCILIATION_MATCH_STATUSES.orphanTransaction,
|
|
resolution_status: TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.pending,
|
|
order_amount: null,
|
|
transaction_amount: toMoneyFixed(transaction.amount),
|
|
currency: transaction.currency ?? "CNY",
|
|
anomaly_code: TRAVEL_RECONCILIATION_MATCH_STATUSES.orphanTransaction,
|
|
snapshot_json: {
|
|
requestNo: transaction.travel_request?.request_no ?? null,
|
|
externalOrderNo: transaction.travel_order?.external_order_no ?? null,
|
|
externalTxnId: transaction.external_txn_id,
|
|
travelOrderStatus: transaction.travel_order?.status ?? null,
|
|
transactionStatus: transaction.status,
|
|
linkedReimbursementId: transaction.travel_order?.linked_reimbursement_id ?? null,
|
|
boundInvoiceCount: 0,
|
|
boundInvoiceAmount: toMoneyFixed(0),
|
|
matchedTransactionIds: [transaction.id],
|
|
reasonDetail: `交易 ${transaction.external_txn_id} 未匹配到本批次范围内的差旅订单。`,
|
|
},
|
|
confirmed_at: null,
|
|
confirmed_by: null,
|
|
confirm_note: null,
|
|
};
|
|
}
|
|
|
|
function buildTravelReconciliationSummary({ items, orders, transactions }) {
|
|
const matchedItems = items.filter((item) => item.match_status === TRAVEL_RECONCILIATION_MATCH_STATUSES.matched).length;
|
|
const pendingItems = items.filter((item) => item.resolution_status === TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.pending).length;
|
|
const anomalyItems = items.length - matchedItems;
|
|
const totalOrderAmount = orders.reduce((total, item) => toMoneyNumber(total + toMoneyNumber(item.amount)), 0);
|
|
const totalSettledAmount = transactions.reduce((total, item) => {
|
|
if (!isSettledCharge(item)) {
|
|
return total;
|
|
}
|
|
return toMoneyNumber(total + toMoneyNumber(item.amount));
|
|
}, 0);
|
|
const totalReversedAmount = transactions.reduce((total, item) => {
|
|
if (!isReversedTransaction(item)) {
|
|
return total;
|
|
}
|
|
return toMoneyNumber(total + toMoneyNumber(item.amount));
|
|
}, 0);
|
|
const matchRate = items.length ? (matchedItems / items.length) * 100 : 0;
|
|
|
|
return {
|
|
totalOrders: orders.length,
|
|
totalTransactions: transactions.length,
|
|
matchedItems,
|
|
pendingItems,
|
|
anomalyItems,
|
|
totalOrderAmount: toMoneyFixed(totalOrderAmount),
|
|
totalSettledAmount: toMoneyFixed(totalSettledAmount),
|
|
totalReversedAmount: toMoneyFixed(totalReversedAmount),
|
|
matchRate: toMoneyFixed(matchRate),
|
|
};
|
|
}
|
|
|
|
function buildReconciliationItemsSnapshot({ orders = [], transactions = [], invoices = [], actorId = null, now = new Date() }) {
|
|
const invoiceStatsMap = buildInvoiceStatsMap(invoices);
|
|
const ordersById = new Map(orders.map((item) => [item.id, item]));
|
|
const transactionsByOrderId = new Map();
|
|
|
|
for (const transaction of transactions) {
|
|
if (!transaction.travel_order_id) {
|
|
continue;
|
|
}
|
|
const list = transactionsByOrderId.get(transaction.travel_order_id) ?? [];
|
|
list.push(transaction);
|
|
transactionsByOrderId.set(transaction.travel_order_id, list);
|
|
}
|
|
|
|
const items = orders.map((order) =>
|
|
buildOrderItem({
|
|
order,
|
|
orderTransactions: transactionsByOrderId.get(order.id) ?? [],
|
|
invoiceStatsMap,
|
|
actorId,
|
|
now,
|
|
}),
|
|
);
|
|
|
|
const orphanTransactions = transactions.filter(
|
|
(transaction) => !transaction.travel_order_id || !ordersById.has(transaction.travel_order_id),
|
|
);
|
|
for (const transaction of orphanTransactions) {
|
|
items.push(buildOrphanTransactionItem({ transaction, actorId, now }));
|
|
}
|
|
|
|
return {
|
|
items,
|
|
summary: buildTravelReconciliationSummary({ items, orders, transactions }),
|
|
};
|
|
}
|
|
|
|
function buildOrderWhere({ legalEntityId, costCenterId, periodStart, periodEnd, periodEndExclusive }) {
|
|
return {
|
|
status: "paid",
|
|
travel_request: {
|
|
legal_entity_id: legalEntityId,
|
|
...(costCenterId ? { cost_center_id: costCenterId } : {}),
|
|
},
|
|
OR: [
|
|
{
|
|
payment_date: {
|
|
gte: periodStart,
|
|
lte: periodEnd,
|
|
},
|
|
},
|
|
{
|
|
AND: [
|
|
{ payment_date: null },
|
|
{ paid_at: { gte: periodStart, lt: periodEndExclusive } },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
function buildTransactionWhere({ legalEntityId, costCenterId, periodStart, periodEndExclusive }) {
|
|
return {
|
|
status: { in: ["settled", "reversed"] },
|
|
travel_request: {
|
|
legal_entity_id: legalEntityId,
|
|
...(costCenterId ? { cost_center_id: costCenterId } : {}),
|
|
},
|
|
occurred_at: {
|
|
gte: periodStart,
|
|
lt: periodEndExclusive,
|
|
},
|
|
};
|
|
}
|
|
|
|
const ORDER_SCOPE_SELECT = {
|
|
id: true,
|
|
source: true,
|
|
external_order_no: true,
|
|
linked_reimbursement_id: true,
|
|
travel_request_id: true,
|
|
amount: true,
|
|
currency: true,
|
|
status: true,
|
|
payment_date: true,
|
|
paid_at: true,
|
|
travel_request: {
|
|
select: {
|
|
id: true,
|
|
request_no: true,
|
|
legal_entity_id: true,
|
|
cost_center_id: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
const TRANSACTION_SCOPE_SELECT = {
|
|
id: true,
|
|
source: true,
|
|
external_txn_id: true,
|
|
travel_request_id: true,
|
|
travel_order_id: true,
|
|
amount: true,
|
|
currency: true,
|
|
txn_type: true,
|
|
status: true,
|
|
occurred_at: true,
|
|
travel_request: {
|
|
select: {
|
|
id: true,
|
|
request_no: true,
|
|
},
|
|
},
|
|
travel_order: {
|
|
select: {
|
|
id: true,
|
|
external_order_no: true,
|
|
linked_reimbursement_id: true,
|
|
status: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
async function loadReconciliationScope(prisma, { legalEntityId, costCenterId = null, periodStart, periodEnd }) {
|
|
const normalizedStart = new Date(`${toDateOnlyString(periodStart)}T00:00:00.000Z`);
|
|
const normalizedEnd = new Date(`${toDateOnlyString(periodEnd)}T00:00:00.000Z`);
|
|
const periodEndExclusive = new Date(normalizedEnd.getTime() + 24 * 60 * 60 * 1000);
|
|
|
|
const [orders, transactions] = await Promise.all([
|
|
prisma.travelOrder.findMany({
|
|
where: buildOrderWhere({
|
|
legalEntityId,
|
|
costCenterId,
|
|
periodStart: normalizedStart,
|
|
periodEnd: normalizedEnd,
|
|
periodEndExclusive,
|
|
}),
|
|
orderBy: [{ payment_date: "asc" }, { paid_at: "asc" }, { created_at: "asc" }],
|
|
select: ORDER_SCOPE_SELECT,
|
|
}),
|
|
prisma.cardTransaction.findMany({
|
|
where: buildTransactionWhere({
|
|
legalEntityId,
|
|
costCenterId,
|
|
periodStart: normalizedStart,
|
|
periodEndExclusive,
|
|
}),
|
|
orderBy: [{ occurred_at: "asc" }, { created_at: "asc" }],
|
|
select: TRANSACTION_SCOPE_SELECT,
|
|
}),
|
|
]);
|
|
|
|
const orderIds = orders.map((item) => item.id);
|
|
const invoices = orderIds.length
|
|
? await prisma.invoicePool.findMany({
|
|
where: { travel_order_id: { in: orderIds } },
|
|
select: {
|
|
id: true,
|
|
travel_order_id: true,
|
|
total_amount: true,
|
|
},
|
|
})
|
|
: [];
|
|
|
|
return {
|
|
orders,
|
|
transactions,
|
|
invoices,
|
|
periodStart: normalizedStart,
|
|
periodEnd: normalizedEnd,
|
|
};
|
|
}
|
|
|
|
function mapBatchSummary(batch) {
|
|
return {
|
|
id: batch.id,
|
|
batchNo: batch.batch_no,
|
|
legalEntityId: batch.legal_entity_id,
|
|
costCenterId: batch.cost_center_id ?? null,
|
|
periodStart: toDateOnlyString(batch.period_start),
|
|
periodEnd: toDateOnlyString(batch.period_end),
|
|
status: batch.status,
|
|
summary: normalizeSummaryJson(batch.summary_json),
|
|
confirmedAt: batch.confirmed_at?.toISOString?.() ?? null,
|
|
confirmedBy: batch.confirmed_by ?? null,
|
|
createdAt: batch.created_at?.toISOString?.() ?? null,
|
|
updatedAt: batch.updated_at?.toISOString?.() ?? null,
|
|
legalEntity: batch.legal_entity
|
|
? {
|
|
id: batch.legal_entity.id,
|
|
code: batch.legal_entity.code,
|
|
name: batch.legal_entity.name,
|
|
}
|
|
: null,
|
|
costCenter: batch.cost_center
|
|
? {
|
|
id: batch.cost_center.id,
|
|
code: batch.cost_center.code,
|
|
name: batch.cost_center.name,
|
|
legalEntityId: batch.cost_center.legal_entity_id,
|
|
}
|
|
: null,
|
|
confirmedByEmployee: batch.confirmed_by_employee
|
|
? {
|
|
id: batch.confirmed_by_employee.id,
|
|
employeeNo: batch.confirmed_by_employee.employee_no,
|
|
name: batch.confirmed_by_employee.name,
|
|
}
|
|
: null,
|
|
};
|
|
}
|
|
|
|
function mapBatchItem(item, { canManagePayments = false, batchStatus = TRAVEL_RECONCILIATION_BATCH_STATUSES.draft } = {}) {
|
|
const snapshot = item.snapshot_json && typeof item.snapshot_json === "object" ? item.snapshot_json : {};
|
|
return {
|
|
id: item.id,
|
|
itemKind: item.item_kind,
|
|
travelRequestId: item.travel_request_id ?? null,
|
|
travelOrderId: item.travel_order_id ?? null,
|
|
cardTransactionId: item.card_transaction_id ?? null,
|
|
matchStatus: item.match_status,
|
|
resolutionStatus: item.resolution_status,
|
|
orderAmount: item.order_amount?.toString?.() ?? null,
|
|
transactionAmount: item.transaction_amount?.toString?.() ?? null,
|
|
currency: item.currency,
|
|
anomalyCode: item.anomaly_code ?? null,
|
|
confirmedAt: item.confirmed_at?.toISOString?.() ?? null,
|
|
confirmedBy: item.confirmed_by ?? null,
|
|
confirmNote: item.confirm_note ?? null,
|
|
snapshot: {
|
|
requestNo: snapshot.requestNo ?? null,
|
|
externalOrderNo: snapshot.externalOrderNo ?? null,
|
|
externalTxnId: snapshot.externalTxnId ?? null,
|
|
travelOrderStatus: snapshot.travelOrderStatus ?? null,
|
|
transactionStatus: snapshot.transactionStatus ?? null,
|
|
linkedReimbursementId: snapshot.linkedReimbursementId ?? null,
|
|
boundInvoiceCount: Number(snapshot.boundInvoiceCount ?? 0),
|
|
boundInvoiceAmount: toMoneyFixed(snapshot.boundInvoiceAmount),
|
|
matchedTransactionIds: Array.isArray(snapshot.matchedTransactionIds) ? snapshot.matchedTransactionIds : [],
|
|
reasonDetail: snapshot.reasonDetail ?? null,
|
|
},
|
|
travelRequest: item.travel_request
|
|
? {
|
|
id: item.travel_request.id,
|
|
requestNo: item.travel_request.request_no ?? null,
|
|
}
|
|
: null,
|
|
travelOrder: item.travel_order
|
|
? {
|
|
id: item.travel_order.id,
|
|
externalOrderNo: item.travel_order.external_order_no,
|
|
status: item.travel_order.status,
|
|
}
|
|
: null,
|
|
cardTransaction: item.card_transaction
|
|
? {
|
|
id: item.card_transaction.id,
|
|
externalTxnId: item.card_transaction.external_txn_id,
|
|
status: item.card_transaction.status,
|
|
txnType: item.card_transaction.txn_type,
|
|
}
|
|
: null,
|
|
actions: {
|
|
canConfirm:
|
|
canManagePayments &&
|
|
batchStatus === TRAVEL_RECONCILIATION_BATCH_STATUSES.draft &&
|
|
item.match_status !== TRAVEL_RECONCILIATION_MATCH_STATUSES.matched &&
|
|
item.resolution_status === TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.pending,
|
|
canReopen:
|
|
canManagePayments &&
|
|
batchStatus === TRAVEL_RECONCILIATION_BATCH_STATUSES.draft &&
|
|
item.match_status !== TRAVEL_RECONCILIATION_MATCH_STATUSES.matched &&
|
|
item.resolution_status === TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.confirmed,
|
|
},
|
|
};
|
|
}
|
|
|
|
const BATCH_SELECT = {
|
|
id: true,
|
|
batch_no: true,
|
|
legal_entity_id: true,
|
|
cost_center_id: true,
|
|
period_start: true,
|
|
period_end: true,
|
|
status: true,
|
|
summary_json: true,
|
|
confirmed_at: true,
|
|
confirmed_by: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
legal_entity: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
},
|
|
},
|
|
cost_center: {
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
legal_entity_id: true,
|
|
},
|
|
},
|
|
confirmed_by_employee: {
|
|
select: {
|
|
id: true,
|
|
employee_no: true,
|
|
name: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
const BATCH_DETAIL_SELECT = {
|
|
...BATCH_SELECT,
|
|
items: {
|
|
orderBy: [{ created_at: "asc" }, { id: "asc" }],
|
|
select: {
|
|
id: true,
|
|
item_kind: true,
|
|
travel_request_id: true,
|
|
travel_order_id: true,
|
|
card_transaction_id: true,
|
|
match_status: true,
|
|
resolution_status: true,
|
|
order_amount: true,
|
|
transaction_amount: true,
|
|
currency: true,
|
|
anomaly_code: true,
|
|
snapshot_json: true,
|
|
confirmed_at: true,
|
|
confirmed_by: true,
|
|
confirm_note: true,
|
|
created_at: true,
|
|
updated_at: true,
|
|
travel_request: {
|
|
select: {
|
|
id: true,
|
|
request_no: true,
|
|
},
|
|
},
|
|
travel_order: {
|
|
select: {
|
|
id: true,
|
|
external_order_no: true,
|
|
status: true,
|
|
},
|
|
},
|
|
card_transaction: {
|
|
select: {
|
|
id: true,
|
|
external_txn_id: true,
|
|
status: true,
|
|
txn_type: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
async function listTravelReconciliationBatches(prisma, query) {
|
|
const skip = (query.page - 1) * query.pageSize;
|
|
const where = {
|
|
...(query.status ? { status: query.status } : {}),
|
|
...(query.legalEntityId ? { legal_entity_id: query.legalEntityId } : {}),
|
|
...(query.costCenterId ? { cost_center_id: query.costCenterId } : {}),
|
|
...(query.periodStart ? { period_end: { gte: query.periodStart } } : {}),
|
|
...(query.periodEnd ? { period_start: { lte: query.periodEnd } } : {}),
|
|
};
|
|
|
|
const [items, total] = await Promise.all([
|
|
prisma.travelReconciliationBatch.findMany({
|
|
where,
|
|
orderBy: [{ created_at: "desc" }, { id: "desc" }],
|
|
skip,
|
|
take: query.pageSize,
|
|
select: BATCH_SELECT,
|
|
}),
|
|
prisma.travelReconciliationBatch.count({ where }),
|
|
]);
|
|
|
|
return {
|
|
page: query.page,
|
|
pageSize: query.pageSize,
|
|
total,
|
|
items: items.map(mapBatchSummary),
|
|
};
|
|
}
|
|
|
|
async function loadTravelReconciliationBatchDetail(prisma, batchId, options = {}) {
|
|
const batch = await prisma.travelReconciliationBatch.findUnique({
|
|
where: { id: batchId },
|
|
select: BATCH_DETAIL_SELECT,
|
|
});
|
|
|
|
if (!batch) {
|
|
throw new AppError({
|
|
code: "SYS_404",
|
|
message: "Not Found",
|
|
statusCode: 404,
|
|
});
|
|
}
|
|
|
|
return {
|
|
...mapBatchSummary(batch),
|
|
items: batch.items.map((item) => mapBatchItem(item, { canManagePayments: options.canManagePayments, batchStatus: batch.status })),
|
|
permissions: {
|
|
canManagePayments: Boolean(options.canManagePayments),
|
|
canRetryErp: Boolean(options.canRetryErp),
|
|
},
|
|
};
|
|
}
|
|
|
|
function ensureDraftBatch(batch) {
|
|
if (batch.status !== TRAVEL_RECONCILIATION_BATCH_STATUSES.draft) {
|
|
throw buildValidationError({ batch: "reconciliation_batch_not_editable" });
|
|
}
|
|
}
|
|
|
|
function ensurePendingReconciliationItem(item) {
|
|
if (item.resolution_status !== TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.pending) {
|
|
throw buildValidationError({ item: "reconciliation_item_not_pending" });
|
|
}
|
|
}
|
|
|
|
function ensureConfirmedReconciliationItem(item) {
|
|
if (item.resolution_status !== TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.confirmed) {
|
|
throw buildValidationError({ item: "reconciliation_item_not_confirmed" });
|
|
}
|
|
}
|
|
|
|
function ensureReopenableReconciliationItem(item) {
|
|
if (item.match_status === TRAVEL_RECONCILIATION_MATCH_STATUSES.matched) {
|
|
throw buildValidationError({ item: "matched_item_not_reopenable" });
|
|
}
|
|
}
|
|
|
|
function ensureBatchFinalizable(items = []) {
|
|
if (items.some((item) => item.resolution_status !== TRAVEL_RECONCILIATION_RESOLUTION_STATUSES.confirmed)) {
|
|
throw buildValidationError({ batch: "reconciliation_batch_has_pending_items" });
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
TRAVEL_RECONCILIATION_BATCH_STATUSES,
|
|
TRAVEL_RECONCILIATION_ITEM_KINDS,
|
|
TRAVEL_RECONCILIATION_MATCH_STATUSES,
|
|
TRAVEL_RECONCILIATION_RESOLUTION_STATUSES,
|
|
BATCH_SELECT,
|
|
BATCH_DETAIL_SELECT,
|
|
buildReconciliationItemsSnapshot,
|
|
buildTravelReconciliationSummary,
|
|
buildValidationError,
|
|
ensureBatchFinalizable,
|
|
ensureConfirmedReconciliationItem,
|
|
ensureDraftBatch,
|
|
ensurePendingReconciliationItem,
|
|
ensureReopenableReconciliationItem,
|
|
listTravelReconciliationBatches,
|
|
loadReconciliationScope,
|
|
loadTravelReconciliationBatchDetail,
|
|
mapBatchItem,
|
|
mapBatchSummary,
|
|
normalizeSummaryJson,
|
|
toMoneyFixed,
|
|
toMoneyNumber,
|
|
};
|