451 lines
16 KiB
TypeScript
451 lines
16 KiB
TypeScript
import { query } from '../../db/client.js'
|
|
import type { JsonObject } from '../../types/json.js'
|
|
import { nowIso } from '../../utils/time.js'
|
|
|
|
const CHINA_TIME_ZONE = 'Asia/Shanghai'
|
|
const DAY_MS = 24 * 60 * 60 * 1000
|
|
|
|
type FinanceRange = {
|
|
from: string
|
|
to: string
|
|
fromDate: string
|
|
toDate: string
|
|
bucketFrom: string
|
|
bucketTo: string
|
|
}
|
|
|
|
const FINANCE_EVENTS_CTE = `
|
|
WITH finance_events AS (
|
|
SELECT
|
|
'order_paid'::text AS category,
|
|
o.id::bigint AS source_id,
|
|
COALESCE(o.paid_at, o.created_at) AS occurred_at,
|
|
o.total_amount::bigint AS amount,
|
|
'订单收款'::text AS label,
|
|
o.platform_order_id::text AS reference_no,
|
|
COALESCE(NULLIF(CONCAT_WS('/', NULLIF(o.provider, ''), NULLIF(o.platform, '')), ''), '其他')::text AS channel,
|
|
o.created_at AS request_created_at,
|
|
NULL::timestamptz AS request_reviewed_at
|
|
FROM orders o
|
|
WHERE o.pay_status IN ('paid', 'refunded')
|
|
AND o.total_amount > 0
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
'order_refund'::text,
|
|
o.id::bigint,
|
|
COALESCE(o.updated_at, o.created_at),
|
|
o.total_amount::bigint,
|
|
'订单退款'::text,
|
|
o.platform_order_id::text,
|
|
COALESCE(NULLIF(CONCAT_WS('/', NULLIF(o.provider, ''), NULLIF(o.platform, '')), ''), '其他')::text,
|
|
o.created_at,
|
|
NULL::timestamptz
|
|
FROM orders o
|
|
WHERE o.pay_status = 'refunded'
|
|
AND o.total_amount > 0
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
CASE WHEN wl.ledger_type IN ('reward_settlement', 'sharing_reward')
|
|
THEN 'worker_reward' ELSE 'worker_recovery' END::text,
|
|
wl.id::bigint,
|
|
wl.created_at,
|
|
ABS(wl.amount)::bigint,
|
|
CASE WHEN wl.ledger_type IN ('reward_settlement', 'sharing_reward')
|
|
THEN '打手报酬' ELSE '打手资金回收' END::text,
|
|
COALESCE(wl.related_work_order_id::text, ''),
|
|
'worker-platform'::text,
|
|
wl.created_at,
|
|
NULL::timestamptz
|
|
FROM worker_wallet_ledgers wl
|
|
WHERE wl.ledger_type IN (
|
|
'reward_settlement', 'sharing_reward', 'after_sales_deposit_deduction',
|
|
'after_sales_balance_deduction', 'after_sales_debt_offset'
|
|
)
|
|
AND wl.amount <> 0
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
'withdraw_paid'::text,
|
|
wfr.id::bigint,
|
|
wfr.reviewed_at,
|
|
wfr.amount::bigint,
|
|
'打手提现'::text,
|
|
wfr.account_channel::text,
|
|
COALESCE(NULLIF(wfr.account_channel, ''), '其他')::text,
|
|
wfr.created_at,
|
|
wfr.reviewed_at
|
|
FROM worker_finance_requests wfr
|
|
WHERE wfr.request_type = 'withdraw'
|
|
AND wfr.status = 'approved'
|
|
AND wfr.reviewed_at IS NOT NULL
|
|
AND wfr.amount > 0
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
'recharge'::text,
|
|
wfr.id::bigint,
|
|
wfr.reviewed_at,
|
|
wfr.amount::bigint,
|
|
'打手充值'::text,
|
|
wfr.account_channel::text,
|
|
COALESCE(NULLIF(wfr.account_channel, ''), '其他')::text,
|
|
wfr.created_at,
|
|
wfr.reviewed_at
|
|
FROM worker_finance_requests wfr
|
|
WHERE wfr.request_type = 'recharge'
|
|
AND wfr.status = 'approved'
|
|
AND wfr.reviewed_at IS NOT NULL
|
|
AND wfr.amount > 0
|
|
|
|
UNION ALL
|
|
|
|
SELECT
|
|
'after_sales_refund'::text,
|
|
wasc.id::bigint,
|
|
wasc.refunded_at,
|
|
wasc.refunded_amount::bigint,
|
|
'售后追缴退还'::text,
|
|
wasc.case_no::text,
|
|
'worker-platform'::text,
|
|
wasc.created_at,
|
|
NULL::timestamptz
|
|
FROM worker_after_sales_cases wasc
|
|
WHERE wasc.refunded_at IS NOT NULL
|
|
AND wasc.refunded_amount > 0
|
|
)
|
|
`
|
|
|
|
export async function getAdminFinanceSummary(payload: JsonObject = {}) {
|
|
const range = resolveFinanceRange(payload, nowIso())
|
|
const dateType = normalizeFinanceDateType(payload.dateType)
|
|
const eventDateExpression = resolveFinanceEventDateExpression(dateType)
|
|
const [dailyResult, snapshotResult] = await Promise.all([
|
|
query<FinanceDailyRow>(
|
|
`${FINANCE_EVENTS_CTE}
|
|
SELECT
|
|
to_char(day AT TIME ZONE 'Asia/Shanghai', 'YYYY-MM-DD') AS day,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'order_paid'), 0)::bigint AS paid_amount,
|
|
COUNT(*) FILTER (WHERE category = 'order_paid')::int AS paid_order_count,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'order_refund'), 0)::bigint AS refund_amount,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'worker_reward'), 0)::bigint AS worker_reward_amount,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'withdraw_paid'), 0)::bigint AS withdraw_amount,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'recharge'), 0)::bigint AS recharge_amount,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'after_sales_refund'), 0)::bigint AS after_sales_refund_amount,
|
|
COALESCE(SUM(amount) FILTER (WHERE category = 'worker_recovery'), 0)::bigint AS worker_recovery_amount
|
|
FROM generate_series($3::timestamptz, $4::timestamptz - interval '1 day', interval '1 day') day
|
|
LEFT JOIN finance_events event
|
|
ON ${eventDateExpression} >= $1::timestamptz
|
|
AND ${eventDateExpression} < $2::timestamptz
|
|
AND ${eventDateExpression} >= day
|
|
AND ${eventDateExpression} < day + interval '1 day'
|
|
GROUP BY day
|
|
ORDER BY day DESC`,
|
|
[range.from, range.to, range.bucketFrom, range.bucketTo],
|
|
),
|
|
query<FinanceSnapshotRow>(
|
|
`
|
|
SELECT
|
|
(SELECT COALESCE(SUM(available_amount), 0)::bigint FROM worker_wallets) AS available_amount,
|
|
(SELECT COALESCE(SUM(frozen_deposit_amount), 0)::bigint FROM worker_wallets) AS frozen_deposit_amount,
|
|
(SELECT COALESCE(SUM(pending_unfreeze_amount), 0)::bigint FROM worker_wallets) AS pending_unfreeze_amount,
|
|
(SELECT COALESCE(SUM(frozen_withdraw_amount), 0)::bigint FROM worker_wallets) AS frozen_withdraw_amount,
|
|
(SELECT COALESCE(SUM(amount), 0)::bigint FROM worker_finance_requests WHERE status = 'pending' AND request_type = 'withdraw') AS pending_withdraw_amount,
|
|
(SELECT COUNT(*)::int FROM worker_finance_requests WHERE status = 'pending' AND request_type = 'withdraw') AS pending_withdraw_count
|
|
`,
|
|
),
|
|
])
|
|
|
|
const daily = dailyResult.rows.map(mapFinanceDailyRow)
|
|
const channelDailyResult = await query<FinanceChannelDailyRow>(
|
|
`${FINANCE_EVENTS_CTE}
|
|
SELECT
|
|
to_char(${eventDateExpression} AT TIME ZONE 'Asia/Shanghai', 'YYYY-MM-DD') AS day,
|
|
event.channel,
|
|
event.category,
|
|
COUNT(*)::int AS total,
|
|
COALESCE(SUM(event.amount), 0)::bigint AS amount
|
|
FROM finance_events event
|
|
WHERE ${eventDateExpression} >= $1::timestamptz
|
|
AND ${eventDateExpression} < $2::timestamptz
|
|
GROUP BY 1, 2, 3
|
|
ORDER BY day DESC, event.channel ASC, event.category ASC`,
|
|
[range.from, range.to],
|
|
)
|
|
const totals = daily.reduce(
|
|
(result, row) => ({
|
|
paidOrderCount: result.paidOrderCount + row.paidOrderCount,
|
|
paidAmount: result.paidAmount + row.paidAmount,
|
|
refundAmount: result.refundAmount + row.refundAmount,
|
|
workerRewardAmount: result.workerRewardAmount + row.workerRewardAmount,
|
|
withdrawAmount: result.withdrawAmount + row.withdrawAmount,
|
|
rechargeAmount: result.rechargeAmount + row.rechargeAmount,
|
|
afterSalesRefundAmount: result.afterSalesRefundAmount + row.afterSalesRefundAmount,
|
|
workerRecoveryAmount: result.workerRecoveryAmount + row.workerRecoveryAmount,
|
|
netCashFlow: result.netCashFlow + row.netCashFlow,
|
|
}),
|
|
emptyFinanceTotals(),
|
|
)
|
|
const snapshot = snapshotResult.rows[0] || emptyFinanceSnapshot()
|
|
|
|
return {
|
|
range: { from: range.fromDate, to: range.toDate },
|
|
overview: {
|
|
...totals,
|
|
availableAmount: Number(snapshot.available_amount || 0),
|
|
frozenDepositAmount: Number(snapshot.frozen_deposit_amount || 0),
|
|
pendingUnfreezeAmount: Number(snapshot.pending_unfreeze_amount || 0),
|
|
frozenWithdrawAmount: Number(snapshot.frozen_withdraw_amount || 0),
|
|
pendingWithdrawAmount: Number(snapshot.pending_withdraw_amount || 0),
|
|
pendingWithdrawCount: Number(snapshot.pending_withdraw_count || 0),
|
|
},
|
|
daily,
|
|
channelDaily: channelDailyResult.rows.map((row) => ({
|
|
date: String(row.day).slice(0, 10),
|
|
channel: row.channel || '其他',
|
|
category: row.category,
|
|
count: Number(row.total || 0),
|
|
amount: Number(row.amount || 0),
|
|
})),
|
|
}
|
|
}
|
|
|
|
export async function listAdminFinanceTransactions(payload: JsonObject = {}) {
|
|
const range = resolveFinanceRange(payload, nowIso())
|
|
const dateType = normalizeFinanceDateType(payload.dateType)
|
|
const eventDateExpression = resolveFinanceEventDateExpression(dateType)
|
|
const page = normalizePositiveInt(payload.page, 1)
|
|
const pageSize = Math.min(normalizePositiveInt(payload.pageSize, 20), 100)
|
|
const category = String(payload.category || '').trim()
|
|
const channel = String(payload.channel || '').trim()
|
|
const allowedCategories = new Set([
|
|
'order_paid',
|
|
'order_refund',
|
|
'worker_reward',
|
|
'worker_recovery',
|
|
'withdraw_paid',
|
|
'recharge',
|
|
'after_sales_refund',
|
|
])
|
|
const params: unknown[] = [range.from, range.to]
|
|
const categoryClause = allowedCategories.has(category)
|
|
? ` AND event.category = $${params.push(category)}`
|
|
: ''
|
|
const channelClause = channel ? ` AND event.channel = $${params.push(channel)}` : ''
|
|
const offset = (page - 1) * pageSize
|
|
const countResult = await query<{ total: number }>(
|
|
`${FINANCE_EVENTS_CTE}
|
|
SELECT COUNT(*)::int AS total
|
|
FROM finance_events event
|
|
WHERE ${eventDateExpression} >= $1
|
|
AND ${eventDateExpression} < $2${categoryClause}${channelClause}`,
|
|
params,
|
|
)
|
|
const itemsParams = [...params, pageSize, offset]
|
|
const itemsResult = await query<FinanceTransactionRow>(
|
|
`${FINANCE_EVENTS_CTE}
|
|
SELECT category, source_id, occurred_at, amount, label, reference_no, channel
|
|
FROM finance_events event
|
|
WHERE ${eventDateExpression} >= $1
|
|
AND ${eventDateExpression} < $2${categoryClause}${channelClause}
|
|
ORDER BY ${eventDateExpression} DESC, event.source_id DESC
|
|
LIMIT $${itemsParams.length - 1} OFFSET $${itemsParams.length}`,
|
|
itemsParams,
|
|
)
|
|
return {
|
|
items: itemsResult.rows.map((row) => ({
|
|
category: row.category,
|
|
sourceId: Number(row.source_id),
|
|
occurredAt: row.occurred_at,
|
|
amount: Number(row.amount || 0),
|
|
direction: ['order_paid', 'recharge', 'worker_recovery'].includes(row.category)
|
|
? 'in'
|
|
: 'out',
|
|
label: row.label,
|
|
referenceNo: row.reference_no || '',
|
|
channel: row.channel || '其他',
|
|
})),
|
|
pagination: { page, pageSize, total: Number(countResult.rows[0]?.total || 0) },
|
|
range: { from: range.fromDate, to: range.toDate },
|
|
}
|
|
}
|
|
|
|
export function resolveFinanceRange(payload: JsonObject = {}, now = nowIso()): FinanceRange {
|
|
const today = chinaDateParts(now)
|
|
const fromInput = String(payload.dateFrom || payload.from || '')
|
|
const toInput = String(payload.dateTo || payload.to || '')
|
|
const fromDate = normalizeDateTimeDate(fromInput) || today
|
|
const toDate = normalizeDateTimeDate(toInput) || fromDate
|
|
const [safeFrom, safeTo] = fromDate <= toDate ? [fromDate, toDate] : [toDate, fromDate]
|
|
const from = parseFinanceBoundary(fromInput, safeFrom, false)
|
|
const to = parseFinanceBoundary(toInput, safeTo, true)
|
|
const normalizedFrom = Date.parse(from) <= Date.parse(to) ? from : chinaDateToUtcIso(safeFrom)
|
|
const normalizedTo =
|
|
Date.parse(from) <= Date.parse(to)
|
|
? to
|
|
: new Date(Date.parse(chinaDateToUtcIso(safeTo)) + DAY_MS).toISOString()
|
|
return {
|
|
from: normalizedFrom,
|
|
to: normalizedTo,
|
|
fromDate: safeFrom,
|
|
toDate: safeTo,
|
|
bucketFrom: chinaDateToUtcIso(safeFrom),
|
|
bucketTo: new Date(Date.parse(chinaDateToUtcIso(safeTo)) + DAY_MS).toISOString(),
|
|
}
|
|
}
|
|
|
|
export function calculateFinanceNetCashFlow(row: {
|
|
paidAmount: number
|
|
refundAmount: number
|
|
rechargeAmount: number
|
|
workerRecoveryAmount: number
|
|
withdrawAmount: number
|
|
afterSalesRefundAmount: number
|
|
}) {
|
|
return (
|
|
row.paidAmount +
|
|
row.rechargeAmount -
|
|
row.refundAmount -
|
|
row.withdrawAmount -
|
|
row.afterSalesRefundAmount +
|
|
row.workerRecoveryAmount
|
|
)
|
|
}
|
|
|
|
type FinanceDailyRow = {
|
|
day: string
|
|
paid_amount: number
|
|
paid_order_count: number
|
|
refund_amount: number
|
|
worker_reward_amount: number
|
|
withdraw_amount: number
|
|
recharge_amount: number
|
|
after_sales_refund_amount: number
|
|
worker_recovery_amount: number
|
|
}
|
|
|
|
type FinanceSnapshotRow = {
|
|
available_amount: number
|
|
frozen_deposit_amount: number
|
|
pending_unfreeze_amount: number
|
|
frozen_withdraw_amount: number
|
|
pending_withdraw_amount: number
|
|
pending_withdraw_count: number
|
|
}
|
|
|
|
type FinanceTransactionRow = {
|
|
category: string
|
|
source_id: number
|
|
occurred_at: string
|
|
amount: number
|
|
label: string
|
|
reference_no: string
|
|
channel: string
|
|
}
|
|
|
|
type FinanceChannelDailyRow = {
|
|
day: string
|
|
channel: string
|
|
category: string
|
|
total: number
|
|
amount: number
|
|
}
|
|
|
|
function mapFinanceDailyRow(row: FinanceDailyRow) {
|
|
const mapped = {
|
|
date: String(row.day).slice(0, 10),
|
|
paidOrderCount: Number(row.paid_order_count || 0),
|
|
paidAmount: Number(row.paid_amount || 0),
|
|
refundAmount: Number(row.refund_amount || 0),
|
|
workerRewardAmount: Number(row.worker_reward_amount || 0),
|
|
withdrawAmount: Number(row.withdraw_amount || 0),
|
|
rechargeAmount: Number(row.recharge_amount || 0),
|
|
afterSalesRefundAmount: Number(row.after_sales_refund_amount || 0),
|
|
workerRecoveryAmount: Number(row.worker_recovery_amount || 0),
|
|
}
|
|
return { ...mapped, netCashFlow: calculateFinanceNetCashFlow(mapped) }
|
|
}
|
|
|
|
function emptyFinanceTotals() {
|
|
return {
|
|
paidOrderCount: 0,
|
|
paidAmount: 0,
|
|
refundAmount: 0,
|
|
workerRewardAmount: 0,
|
|
withdrawAmount: 0,
|
|
rechargeAmount: 0,
|
|
afterSalesRefundAmount: 0,
|
|
workerRecoveryAmount: 0,
|
|
netCashFlow: 0,
|
|
}
|
|
}
|
|
|
|
function emptyFinanceSnapshot(): FinanceSnapshotRow {
|
|
return {
|
|
available_amount: 0,
|
|
frozen_deposit_amount: 0,
|
|
pending_unfreeze_amount: 0,
|
|
frozen_withdraw_amount: 0,
|
|
pending_withdraw_amount: 0,
|
|
pending_withdraw_count: 0,
|
|
}
|
|
}
|
|
|
|
function normalizePositiveInt(value: unknown, fallback: number) {
|
|
const parsed = Number(value)
|
|
return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback
|
|
}
|
|
|
|
function normalizeFinanceDateType(value: unknown): 'occurred' | 'created' | 'reviewed' {
|
|
const normalized = String(value || '').trim()
|
|
if (normalized === 'created' || normalized === 'reviewed') return normalized
|
|
return 'occurred'
|
|
}
|
|
|
|
function resolveFinanceEventDateExpression(dateType: 'occurred' | 'created' | 'reviewed') {
|
|
if (dateType === 'created') return 'COALESCE(event.request_created_at, event.occurred_at)'
|
|
if (dateType === 'reviewed') return 'event.request_reviewed_at'
|
|
return 'event.occurred_at'
|
|
}
|
|
|
|
function normalizeDateTimeDate(value: string) {
|
|
const match = value.trim().match(/^(\d{4}-\d{2}-\d{2})/)
|
|
if (!match || Number.isNaN(Date.parse(`${match[1]}T00:00:00Z`))) return ''
|
|
return match[1]
|
|
}
|
|
|
|
function parseFinanceBoundary(value: string, fallbackDate: string, end: boolean) {
|
|
const normalized = value.trim().replace('T', ' ')
|
|
if (!normalized || /^\d{4}-\d{2}-\d{2}$/.test(normalized)) {
|
|
return new Date(Date.parse(chinaDateToUtcIso(fallbackDate)) + (end ? DAY_MS : 0)).toISOString()
|
|
}
|
|
const minuteMatch = normalized.match(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})$/)
|
|
const valueWithSeconds = minuteMatch
|
|
? `${minuteMatch[1]} ${minuteMatch[2]}:${end ? '59' : '00'}`
|
|
: normalized
|
|
const parsed = new Date(`${valueWithSeconds}+08:00`)
|
|
return Number.isNaN(parsed.getTime())
|
|
? new Date(Date.parse(chinaDateToUtcIso(fallbackDate)) + (end ? DAY_MS : 0)).toISOString()
|
|
: parsed.toISOString()
|
|
}
|
|
|
|
function chinaDateParts(value: string) {
|
|
const parts = new Intl.DateTimeFormat('en-CA', {
|
|
timeZone: CHINA_TIME_ZONE,
|
|
year: 'numeric',
|
|
month: '2-digit',
|
|
day: '2-digit',
|
|
}).formatToParts(new Date(value))
|
|
const result = Object.fromEntries(parts.map((part) => [part.type, part.value]))
|
|
return `${result.year}-${result.month}-${result.day}`
|
|
}
|
|
|
|
function chinaDateToUtcIso(value: string) {
|
|
return new Date(`${value}T00:00:00+08:00`).toISOString()
|
|
}
|