3470 lines
110 KiB
TypeScript
3470 lines
110 KiB
TypeScript
import { BadRequestException, Injectable, Logger, NotFoundException, OnModuleInit } from '@nestjs/common';
|
||
import { Prisma } from '@prisma/client';
|
||
import {
|
||
DEFAULT_STORE_WITHDRAW_DAILY_LIMIT,
|
||
DEFAULT_XFX_LOGISTICS_PRICING,
|
||
LOGISTICS_SETTLEMENT_METHOD_LABELS,
|
||
PAYMENT_PROOF_IMAGE_MAX_COUNT,
|
||
WINERY_BILL_EPOCH_YMD,
|
||
WINERY_SETTLEMENT_PERIOD_DAYS,
|
||
WINERY_SETTLEMENT_RATE,
|
||
} from '@dukang/shared-types';
|
||
import {
|
||
addShanghaiDays,
|
||
calcLogisticsFeeByBottles,
|
||
calcRedeemSettleAmount,
|
||
isWineryIssueDay,
|
||
listWineryIssueDays,
|
||
parseShanghaiYmd,
|
||
pickPayoutsForWithdrawAmount,
|
||
previousShanghaiMonth,
|
||
previousShanghaiWeek,
|
||
resolveSettlementRate,
|
||
shanghaiBillPeriodYmds,
|
||
shanghaiMonthLastInstant,
|
||
shanghaiMonthRange,
|
||
shanghaiPeriodYmds,
|
||
shanghaiPeriodYmdsForWeek,
|
||
shanghaiT1DayWindow,
|
||
shanghaiWeekRange,
|
||
shanghaiWineryPeriodWindow,
|
||
shanghaiYearMonth,
|
||
shanghaiYmd,
|
||
startOfShanghaiDay,
|
||
nextPartnerBillIssueAt,
|
||
sumUnbilledPayoutAmount,
|
||
validateStoreWithdraw,
|
||
wineryIssueDateFromCompletedAt,
|
||
type LogisticsPricingRule,
|
||
} from '@dukang/domain';
|
||
import { PrismaService } from '../../common/prisma/prisma.module';
|
||
import { serializeBigInt } from '../../common/decorators/current-user.decorator';
|
||
import { AlertService } from '../../common/alert/alert.service';
|
||
import { WecomMessagePushService } from '../../integrations/wecom/wecom-message-push.service';
|
||
import { AnalyticsService } from '../analytics/analytics.service';
|
||
import { PartnerCityService } from '../city-scope/partner-city.service';
|
||
import { FulfillmentProviderService } from '../fulfillment/fulfillment-provider.service';
|
||
import {
|
||
loadStorePrimaryBank,
|
||
loadStorePrimaryBanksMap,
|
||
loadWineryBankConfig,
|
||
formatWecomBankAccount,
|
||
} from '../../common/store/store-bank.util';
|
||
import {
|
||
capBillBlocks,
|
||
formatLogisticsBillWecomBlock,
|
||
formatPartnerBillWecomBlock,
|
||
formatPartnerDashLabel,
|
||
formatPercent,
|
||
formatStoreBillWecomBlock,
|
||
joinLimited,
|
||
wecomBankParts,
|
||
type WecomBankLike,
|
||
} from './wecom-bill-digest';
|
||
|
||
function generateBillNo(prefix: string) {
|
||
return `${prefix}${Date.now()}${Math.floor(Math.random() * 900 + 100)}`;
|
||
}
|
||
|
||
function csvEscape(value: string) {
|
||
if (/[",\n\r]/.test(value)) return `"${value.replace(/"/g, '""')}"`;
|
||
return value;
|
||
}
|
||
|
||
function parsePaymentProofUrls(raw: unknown): string[] {
|
||
if (!Array.isArray(raw)) return [];
|
||
return raw
|
||
.map((u) => String(u ?? '').trim())
|
||
.filter((u) => /^https?:\/\//i.test(u))
|
||
.slice(0, PAYMENT_PROOF_IMAGE_MAX_COUNT);
|
||
}
|
||
|
||
function paymentProofUrlsInput(urls?: string[]): Prisma.InputJsonValue | typeof Prisma.JsonNull {
|
||
const parsed = parsePaymentProofUrls(urls);
|
||
return parsed.length ? (parsed as Prisma.InputJsonValue) : Prisma.JsonNull;
|
||
}
|
||
|
||
function withShanghaiPeriod<T extends { periodStart: Date; periodEnd: Date }>(row: T) {
|
||
return { ...row, ...shanghaiBillPeriodYmds(row.periodStart, row.periodEnd) };
|
||
}
|
||
|
||
function resolvePartnerWeekPeriod(weekStartYmd: string): {
|
||
periodStart: Date;
|
||
periodEnd: Date;
|
||
endExclusive: Date;
|
||
} {
|
||
const ymd = String(weekStartYmd || '').trim();
|
||
if (!/^\d{4}-\d{2}-\d{2}$/.test(ymd)) {
|
||
throw new BadRequestException('请提供周起始日 weekStartYmd（YYYY-MM-DD）');
|
||
}
|
||
const start = parseShanghaiYmd(ymd);
|
||
const week = shanghaiWeekRange(start);
|
||
if (shanghaiYmd(week.start) !== ymd) {
|
||
throw new BadRequestException('账期起始日须为周一');
|
||
}
|
||
return {
|
||
periodStart: week.start,
|
||
periodEnd: new Date(week.endExclusive.getTime() - 1),
|
||
endExclusive: week.endExclusive,
|
||
};
|
||
}
|
||
|
||
function partnerSettlementCycleDto(anchor = new Date()) {
|
||
const { start } = shanghaiWeekRange(anchor);
|
||
const ymds = shanghaiPeriodYmdsForWeek(start);
|
||
return {
|
||
periodStart: ymds.periodStart,
|
||
periodEnd: ymds.periodEnd,
|
||
nextIssueAt: nextPartnerBillIssueAt(anchor).toISOString(),
|
||
cycleLabel: '每周一 08:00 出账',
|
||
};
|
||
}
|
||
|
||
function toPartnerBillItemDto(row: {
|
||
id: bigint;
|
||
kind: string;
|
||
refId: bigint;
|
||
refNo: string;
|
||
title: string | null;
|
||
extra: string | null;
|
||
baseAmount: Prisma.Decimal | number;
|
||
rate: Prisma.Decimal | number;
|
||
commission: Prisma.Decimal | number;
|
||
occurredAt: Date;
|
||
}) {
|
||
return {
|
||
id: row.id.toString(),
|
||
kind: row.kind,
|
||
refId: row.refId.toString(),
|
||
refNo: row.refNo,
|
||
title: row.title,
|
||
extra: row.extra,
|
||
baseAmount: Number(row.baseAmount),
|
||
rate: Number(row.rate),
|
||
commission: Number(row.commission),
|
||
occurredAt: row.occurredAt.toISOString(),
|
||
};
|
||
}
|
||
|
||
function splitPartnerBillItems(
|
||
items: Array<{
|
||
id: bigint;
|
||
kind: string;
|
||
refId: bigint;
|
||
refNo: string;
|
||
title: string | null;
|
||
extra: string | null;
|
||
baseAmount: Prisma.Decimal | number;
|
||
rate: Prisma.Decimal | number;
|
||
commission: Prisma.Decimal | number;
|
||
occurredAt: Date;
|
||
}>,
|
||
) {
|
||
const orderItems = items.filter((i) => i.kind === 'ORDER').map(toPartnerBillItemDto);
|
||
const redeemItems = items.filter((i) => i.kind === 'REDEEM').map(toPartnerBillItemDto);
|
||
return { orderItems, redeemItems };
|
||
}
|
||
|
||
function round2(n: number) {
|
||
return Math.round(n * 100) / 100;
|
||
}
|
||
|
||
function sumAmounts(rows: Array<{ amount: number }>): string {
|
||
return rows.reduce((s, r) => s + Number(r.amount || 0), 0).toFixed(2);
|
||
}
|
||
|
||
function storeWecomMeta(
|
||
store:
|
||
| {
|
||
name?: string | null;
|
||
cityName?: string | null;
|
||
cityRef?: { name: string } | null;
|
||
partnerAccount?: {
|
||
name: string | null;
|
||
companyName: string | null;
|
||
parent?: { companyName: string | null } | null;
|
||
} | null;
|
||
}
|
||
| null
|
||
| undefined,
|
||
fallbackName: string,
|
||
) {
|
||
const cityName = store?.cityRef?.name?.trim() || store?.cityName?.trim() || '—';
|
||
const acc = store?.partnerAccount;
|
||
const partnerLabel = formatPartnerDashLabel(
|
||
acc?.companyName || acc?.parent?.companyName,
|
||
acc?.name,
|
||
);
|
||
return {
|
||
storeName: store?.name?.trim() || fallbackName,
|
||
cityName,
|
||
partnerLabel,
|
||
};
|
||
}
|
||
|
||
function getStoreWithdrawDailyLimit(): number {
|
||
const raw = process.env.STORE_WITHDRAW_DAILY_LIMIT;
|
||
const n = raw != null && raw !== '' ? Number(raw) : DEFAULT_STORE_WITHDRAW_DAILY_LIMIT;
|
||
return Number.isFinite(n) && n > 0 ? n : DEFAULT_STORE_WITHDRAW_DAILY_LIMIT;
|
||
}
|
||
|
||
/** 工作日 18:00 前未审完视为 FIN-003 超时（Asia/Shanghai 自然日） */
|
||
function isWithdrawOverdue(appliedAt: Date, now = new Date()): boolean {
|
||
const ymd = shanghaiYmd(appliedAt);
|
||
const noon = new Date(`${ymd}T12:00:00+08:00`);
|
||
const day = noon.getUTCDay(); // 与北京日历日相同
|
||
if (day === 0 || day === 6) return false;
|
||
const deadline = new Date(`${ymd}T18:00:00+08:00`);
|
||
return now.getTime() > deadline.getTime();
|
||
}
|
||
|
||
@Injectable()
|
||
export class SettlementService implements OnModuleInit {
|
||
private readonly logger = new Logger(SettlementService.name);
|
||
|
||
constructor(
|
||
private readonly prisma: PrismaService,
|
||
private readonly analyticsService: AnalyticsService,
|
||
private readonly partnerCityService: PartnerCityService,
|
||
private readonly fulfillmentProviderService: FulfillmentProviderService,
|
||
private readonly alert: AlertService,
|
||
private readonly wecomPush: WecomMessagePushService,
|
||
) {}
|
||
|
||
async onModuleInit() {
|
||
try {
|
||
const shifted = await this.realignStoreBillIssueDates();
|
||
if (shifted > 0) this.logger.log(`Store bill dates aligned to Beijing issue day: ${shifted}`);
|
||
} catch (e) {
|
||
this.logger.warn(`Store bill date align skipped: ${e instanceof Error ? e.message : e}`);
|
||
}
|
||
try {
|
||
const shifted = await this.realignWineryBillIssueDates();
|
||
if (shifted > 0) this.logger.log(`Winery bill dates aligned to Beijing issue day: ${shifted}`);
|
||
} catch (e) {
|
||
this.logger.warn(`Winery bill date align skipped: ${e instanceof Error ? e.message : e}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 账单日 = 出账当天（created_at 的北京日历日 00:00+08）。
|
||
* 纠正：旧窗口左端、UTC DATE() +1 误伤、以及 toISOString 跨日。
|
||
*/
|
||
private async realignStoreBillIssueDates(): Promise<number> {
|
||
const locked = await this.prisma.$queryRaw<Array<{ acquired: number | bigint | null }>>`
|
||
SELECT GET_LOCK('store_bill_issue_date_align', 5) AS acquired
|
||
`;
|
||
if (!Number(locked[0]?.acquired)) return 0;
|
||
try {
|
||
const bills = await this.prisma.storeBill.findMany({
|
||
select: { id: true, storeId: true, billDate: true, createdAt: true },
|
||
orderBy: { createdAt: 'desc' },
|
||
});
|
||
let shifted = 0;
|
||
for (const b of bills) {
|
||
const issue = startOfShanghaiDay(b.createdAt);
|
||
if (shanghaiYmd(b.billDate) === shanghaiYmd(issue)) continue;
|
||
const clash = await this.prisma.storeBill.findUnique({
|
||
where: { storeId_billDate: { storeId: b.storeId, billDate: issue } },
|
||
});
|
||
if (clash && clash.id !== b.id) continue;
|
||
await this.prisma.storeBill.update({ where: { id: b.id }, data: { billDate: issue } });
|
||
shifted += 1;
|
||
}
|
||
return shifted;
|
||
} finally {
|
||
await this.prisma.$queryRaw`SELECT RELEASE_LOCK('store_bill_issue_date_align')`;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 一次性：旧「billDate = 完成日」改为出账当天。
|
||
* 已是 T+3 周期出账日的账单禁止再按 createdAt 挪日，否则补生成的历史期账单会被改成今天。
|
||
*/
|
||
private async realignWineryBillIssueDates(): Promise<number> {
|
||
const locked = await this.prisma.$queryRaw<Array<{ acquired: number | bigint | null }>>`
|
||
SELECT GET_LOCK('winery_bill_issue_date_align', 5) AS acquired
|
||
`;
|
||
if (!Number(locked[0]?.acquired)) return 0;
|
||
try {
|
||
const periodDays = WINERY_SETTLEMENT_PERIOD_DAYS;
|
||
const epochYmd = WINERY_BILL_EPOCH_YMD;
|
||
const bills = await this.prisma.wineryBill.findMany({
|
||
select: { id: true, billDate: true, createdAt: true },
|
||
orderBy: { createdAt: 'desc' },
|
||
});
|
||
let shifted = 0;
|
||
for (const b of bills) {
|
||
if (isWineryIssueDay(b.billDate, periodDays, epochYmd)) continue;
|
||
const issue = startOfShanghaiDay(b.createdAt);
|
||
if (shanghaiYmd(b.billDate) === shanghaiYmd(issue)) continue;
|
||
const clash = await this.prisma.wineryBill.findUnique({ where: { billDate: issue } });
|
||
if (clash && clash.id !== b.id) continue;
|
||
await this.prisma.wineryBill.update({ where: { id: b.id }, data: { billDate: issue } });
|
||
shifted += 1;
|
||
}
|
||
return shifted;
|
||
} finally {
|
||
await this.prisma.$queryRaw`SELECT RELEASE_LOCK('winery_bill_issue_date_align')`;
|
||
}
|
||
}
|
||
|
||
private notifyPartnerBillDigest(
|
||
period: string,
|
||
rows: Array<{
|
||
cityName: string;
|
||
partnerLabel: string;
|
||
orderCount?: number;
|
||
redeemCount?: number;
|
||
orderCommission: number;
|
||
redeemCommission: number;
|
||
amount: number;
|
||
bank?: WecomBankLike | null;
|
||
}>,
|
||
) {
|
||
if (!rows.length) return;
|
||
const blocks = rows.map((r) => formatPartnerBillWecomBlock(r));
|
||
void this.wecomPush.dispatchEvent(
|
||
'finance.partner_bill',
|
||
{
|
||
period,
|
||
billCount: String(rows.length),
|
||
totalAmount: sumAmounts(rows),
|
||
billSummary: capBillBlocks(blocks),
|
||
},
|
||
{ handlePath: '/finance/partner-bills' },
|
||
);
|
||
}
|
||
|
||
private notifyLogisticsBillDigest(
|
||
period: string,
|
||
rows: Array<{
|
||
cityNames: string;
|
||
partnerNames: string;
|
||
providerName: string;
|
||
settlementMethod: string;
|
||
orderCount: number;
|
||
bottleCount: number;
|
||
amount: number;
|
||
bank?: WecomBankLike | null;
|
||
}>,
|
||
) {
|
||
if (!rows.length) return;
|
||
const blocks = rows.map((r) => formatLogisticsBillWecomBlock(r));
|
||
void this.wecomPush.dispatchEvent(
|
||
'finance.logistics_bill',
|
||
{
|
||
period,
|
||
billCount: String(rows.length),
|
||
totalAmount: sumAmounts(rows),
|
||
billSummary: capBillBlocks(blocks),
|
||
},
|
||
{ handlePath: '/finance/logistics-bills' },
|
||
);
|
||
}
|
||
|
||
// ─── Store payout (line) ─────────────────────────────
|
||
|
||
async createStorePayout(
|
||
redeemRecordId: bigint,
|
||
storeId: bigint,
|
||
redeemAmount: number,
|
||
payoutAmount: number,
|
||
settlementRate: number,
|
||
tx?: Prisma.TransactionClient,
|
||
) {
|
||
const redeemAmountNum = Number(redeemAmount);
|
||
const payoutAmountNum = Number(payoutAmount);
|
||
const settlementRateNum = resolveSettlementRate(settlementRate);
|
||
if (!(redeemAmountNum > 0) || !(payoutAmountNum > 0)) {
|
||
throw new BadRequestException('结算金额无效，无法入账');
|
||
}
|
||
const expectedPayAt = new Date();
|
||
expectedPayAt.setDate(expectedPayAt.getDate() + 1);
|
||
const client = tx ?? this.prisma;
|
||
const payout = await client.storePayout.create({
|
||
data: {
|
||
redeemRecordId,
|
||
storeId,
|
||
redeemAmount: redeemAmountNum,
|
||
payoutAmount: payoutAmountNum,
|
||
settlementRate: settlementRateNum,
|
||
status: 'PENDING',
|
||
expectedPayAt,
|
||
},
|
||
});
|
||
this.analyticsService.trackStoreOneSafe(undefined, 'SHOP_H5', {
|
||
storeId,
|
||
eventName: 'store_payout_created',
|
||
refType: 'STORE_PAYOUT',
|
||
refId: payout.id,
|
||
extraJson: {
|
||
redeemRecordId: redeemRecordId.toString(),
|
||
payoutAmount,
|
||
redeemAmount,
|
||
settlementRate,
|
||
},
|
||
});
|
||
return serializeBigInt(payout);
|
||
}
|
||
|
||
async listShopPayouts(storeAccountId: bigint, storeId: bigint, page = 1, pageSize = 20) {
|
||
await this.prisma.storeAccountStore.findUniqueOrThrow({
|
||
where: { storeAccountId_storeId: { storeAccountId, storeId } },
|
||
});
|
||
const where = { storeId };
|
||
const [items, total] = await Promise.all([
|
||
this.prisma.storePayout.findMany({
|
||
where,
|
||
orderBy: { createdAt: 'desc' },
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: { redeemRecord: { select: { redeemNo: true, amount: true } } },
|
||
}),
|
||
this.prisma.storePayout.count({ where }),
|
||
]);
|
||
return serializeBigInt({ items, total, page, pageSize });
|
||
}
|
||
|
||
// ─── Store withdraw (未出账手动提现) ─────────────────
|
||
|
||
private async assertShopStoreAccess(storeAccountId: bigint, storeId: bigint) {
|
||
await this.prisma.storeAccountStore.findUniqueOrThrow({
|
||
where: { storeAccountId_storeId: { storeAccountId, storeId } },
|
||
});
|
||
}
|
||
|
||
private async listAvailableUnbilledPayouts(storeId: bigint) {
|
||
await this.backfillMissingStorePayouts(storeId);
|
||
return this.prisma.storePayout.findMany({
|
||
where: {
|
||
storeId,
|
||
status: 'PENDING',
|
||
storeBillId: null,
|
||
withdrawItem: { is: null },
|
||
},
|
||
orderBy: [{ createdAt: 'asc' }, { id: 'asc' }],
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 补写历史核销缺失的 store_payout（含测试流水）。
|
||
* 线上曾出现核销成功但未入账、可提余额为 0 的情况。
|
||
*/
|
||
async backfillMissingStorePayouts(storeId: bigint) {
|
||
const store = await this.prisma.store.findUnique({
|
||
where: { id: storeId },
|
||
select: { settlementRate: true },
|
||
});
|
||
if (!store) return 0;
|
||
|
||
const orphans = await this.prisma.redeemRecord.findMany({
|
||
where: {
|
||
storeId,
|
||
payout: { is: null },
|
||
},
|
||
select: { id: true, amount: true, settleAmount: true },
|
||
take: 200,
|
||
});
|
||
if (!orphans.length) return 0;
|
||
|
||
const settlementRate = resolveSettlementRate(store.settlementRate);
|
||
let created = 0;
|
||
for (const row of orphans) {
|
||
const redeemAmount = Number(row.amount);
|
||
let payoutAmount = Number(row.settleAmount);
|
||
if (!(redeemAmount > 0)) continue;
|
||
if (!(payoutAmount > 0)) {
|
||
payoutAmount = calcRedeemSettleAmount(redeemAmount, settlementRate);
|
||
}
|
||
if (!(payoutAmount > 0)) continue;
|
||
try {
|
||
await this.createStorePayout(
|
||
row.id,
|
||
storeId,
|
||
redeemAmount,
|
||
payoutAmount,
|
||
settlementRate,
|
||
);
|
||
created += 1;
|
||
} catch {
|
||
// 并发补写时可能已存在 payout
|
||
}
|
||
}
|
||
return created;
|
||
}
|
||
|
||
private async todayWithdrawAppliedAmount(storeId: bigint, now = new Date()) {
|
||
const start = startOfShanghaiDay(now);
|
||
const end = addShanghaiDays(start, 1);
|
||
const agg = await this.prisma.storeWithdrawRequest.aggregate({
|
||
where: {
|
||
storeId,
|
||
status: { in: ['PENDING_REVIEW', 'PAID'] },
|
||
appliedAt: { gte: start, lt: end },
|
||
},
|
||
_sum: { amount: true },
|
||
});
|
||
return Number(agg._sum.amount ?? 0);
|
||
}
|
||
|
||
async getShopWithdrawSummary(storeAccountId: bigint, storeId: bigint) {
|
||
await this.assertShopStoreAccess(storeAccountId, storeId);
|
||
const [account, available, pending, todayApplied] = await Promise.all([
|
||
this.prisma.storeAccount.findUniqueOrThrow({
|
||
where: { id: storeAccountId },
|
||
select: {
|
||
isPrimary: true,
|
||
bankAccountName: true,
|
||
bankAccountNo: true,
|
||
bankBranch: true,
|
||
},
|
||
}),
|
||
this.listAvailableUnbilledPayouts(storeId),
|
||
this.prisma.storeWithdrawRequest.findFirst({
|
||
where: { storeId, status: 'PENDING_REVIEW' },
|
||
select: { id: true, amount: true },
|
||
}),
|
||
this.todayWithdrawAppliedAmount(storeId),
|
||
]);
|
||
|
||
const availableAmount = sumUnbilledPayoutAmount(
|
||
available.map((p) => ({ payoutAmount: Number(p.payoutAmount) })),
|
||
);
|
||
const dailyLimit = getStoreWithdrawDailyLimit();
|
||
const hasBankAccount = !!(
|
||
account.bankAccountName?.trim() &&
|
||
account.bankAccountNo?.trim()
|
||
);
|
||
|
||
return {
|
||
availableAmount,
|
||
pendingReviewAmount: pending ? Number(pending.amount) : 0,
|
||
todayAppliedAmount: todayApplied,
|
||
dailyLimit,
|
||
remainingDailyLimit: Math.max(0, round2(dailyLimit - todayApplied)),
|
||
isPrimary: account.isPrimary === 1,
|
||
hasBankAccount,
|
||
bankAccount: {
|
||
bankAccountName: account.bankAccountName,
|
||
bankAccountNo: account.bankAccountNo,
|
||
bankBranch: account.bankBranch,
|
||
},
|
||
};
|
||
}
|
||
|
||
async createStoreWithdrawRequest(
|
||
storeAccountId: bigint,
|
||
storeId: bigint,
|
||
dto?: { amount?: number },
|
||
) {
|
||
await this.assertShopStoreAccess(storeAccountId, storeId);
|
||
|
||
const [store, account, available, pending, todayApplied] = await Promise.all([
|
||
this.prisma.store.findUniqueOrThrow({
|
||
where: { id: storeId },
|
||
select: { id: true, name: true, phone: true, cityName: true },
|
||
}),
|
||
this.prisma.storeAccount.findUniqueOrThrow({
|
||
where: { id: storeAccountId },
|
||
select: {
|
||
isPrimary: true,
|
||
bankAccountName: true,
|
||
bankAccountNo: true,
|
||
},
|
||
}),
|
||
this.listAvailableUnbilledPayouts(storeId),
|
||
this.prisma.storeWithdrawRequest.findFirst({
|
||
where: { storeId, status: 'PENDING_REVIEW' },
|
||
select: { id: true },
|
||
}),
|
||
this.todayWithdrawAppliedAmount(storeId),
|
||
]);
|
||
|
||
if (account.isPrimary !== 1) {
|
||
throw new BadRequestException('仅门店主账号可申请提现');
|
||
}
|
||
|
||
const availableAmount = sumUnbilledPayoutAmount(
|
||
available.map((p) => ({ payoutAmount: Number(p.payoutAmount) })),
|
||
);
|
||
const dailyLimit = getStoreWithdrawDailyLimit();
|
||
const hasBankAccount = !!(
|
||
account.bankAccountName?.trim() &&
|
||
account.bankAccountNo?.trim()
|
||
);
|
||
const requestAmount =
|
||
dto?.amount != null && Number.isFinite(Number(dto.amount))
|
||
? round2(Number(dto.amount))
|
||
: availableAmount;
|
||
|
||
const guard = validateStoreWithdraw({
|
||
availableAmount,
|
||
requestAmount,
|
||
todayApplied,
|
||
dailyLimit,
|
||
hasBankAccount,
|
||
});
|
||
if (!guard.ok) throw new BadRequestException(guard.message);
|
||
|
||
const picked = pickPayoutsForWithdrawAmount(
|
||
available.map((p) => ({ id: p.id, payoutAmount: Number(p.payoutAmount) })),
|
||
requestAmount,
|
||
);
|
||
if (!picked.ok) throw new BadRequestException(picked.message);
|
||
|
||
const created = await this.prisma.$transaction(async (tx) => {
|
||
const payoutIds = picked.selected.map((p) => p.id);
|
||
const locked = await tx.storePayout.findMany({
|
||
where: {
|
||
id: { in: payoutIds },
|
||
storeId,
|
||
status: 'PENDING',
|
||
storeBillId: null,
|
||
withdrawItem: { is: null },
|
||
},
|
||
select: { id: true, payoutAmount: true },
|
||
});
|
||
if (locked.length !== payoutIds.length) {
|
||
throw new BadRequestException('可提余额已变化，请刷新后重试');
|
||
}
|
||
const amount = round2(locked.reduce((s, p) => s + Number(p.payoutAmount), 0));
|
||
|
||
const req = await tx.storeWithdrawRequest.create({
|
||
data: {
|
||
withdrawNo: generateBillNo('SW'),
|
||
storeId,
|
||
storeAccountId,
|
||
amount,
|
||
payoutCount: locked.length,
|
||
status: 'PENDING_REVIEW',
|
||
},
|
||
});
|
||
await tx.storeWithdrawPayoutItem.createMany({
|
||
data: locked.map((p) => ({
|
||
withdrawRequestId: req.id,
|
||
storePayoutId: p.id,
|
||
})),
|
||
});
|
||
return req;
|
||
});
|
||
|
||
this.analyticsService.trackStoreOneSafe(storeAccountId, 'SHOP_H5', {
|
||
storeId,
|
||
eventName: 'store_withdraw_applied',
|
||
refType: 'STORE_WITHDRAW',
|
||
refId: created.id,
|
||
extraJson: {
|
||
amount: Number(created.amount),
|
||
payoutCount: created.payoutCount,
|
||
},
|
||
});
|
||
|
||
void this.wecomPush.dispatchEvent(
|
||
'store.withdraw_pending',
|
||
{
|
||
storeName: store.name,
|
||
withdrawNo: created.withdrawNo,
|
||
amount: Number(created.amount).toFixed(2),
|
||
payoutCount: String(created.payoutCount),
|
||
storeId: storeId.toString(),
|
||
},
|
||
{
|
||
handlePath: `/finance/store-bills?kind=WITHDRAW&status=PENDING_REVIEW&storeId=${storeId.toString()}`,
|
||
},
|
||
);
|
||
|
||
return serializeBigInt(created);
|
||
}
|
||
|
||
async listShopWithdrawRequests(
|
||
storeAccountId: bigint,
|
||
storeId: bigint,
|
||
query: { page?: number; pageSize?: number; status?: string },
|
||
) {
|
||
await this.assertShopStoreAccess(storeAccountId, storeId);
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where: Prisma.StoreWithdrawRequestWhereInput = { storeId };
|
||
if (query.status) {
|
||
where.status = query.status as 'PENDING_REVIEW' | 'REJECTED' | 'PAID';
|
||
}
|
||
const [items, total] = await Promise.all([
|
||
this.prisma.storeWithdrawRequest.findMany({
|
||
where,
|
||
orderBy: { appliedAt: 'desc' },
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
}),
|
||
this.prisma.storeWithdrawRequest.count({ where }),
|
||
]);
|
||
return serializeBigInt({ items, total, page, pageSize });
|
||
}
|
||
|
||
async listAdminStoreWithdrawals(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where: Prisma.StoreWithdrawRequestWhereInput = {};
|
||
if (query.status) {
|
||
where.status = query.status as 'PENDING_REVIEW' | 'REJECTED' | 'PAID';
|
||
}
|
||
if (query.storeId) where.storeId = BigInt(query.storeId);
|
||
if (query.dateFrom || query.dateTo) {
|
||
where.appliedAt = {};
|
||
if (query.dateFrom) where.appliedAt.gte = new Date(query.dateFrom);
|
||
if (query.dateTo) {
|
||
const end = new Date(query.dateTo);
|
||
end.setHours(23, 59, 59, 999);
|
||
where.appliedAt.lte = end;
|
||
}
|
||
}
|
||
|
||
const [items, total, aggregates] = await Promise.all([
|
||
this.prisma.storeWithdrawRequest.findMany({
|
||
where,
|
||
orderBy: [{ appliedAt: 'desc' }, { id: 'desc' }],
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
},
|
||
}),
|
||
this.prisma.storeWithdrawRequest.count({ where }),
|
||
this.prisma.storeWithdrawRequest.aggregate({
|
||
where,
|
||
_sum: { amount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const now = new Date();
|
||
const mapped = items.map((row) => ({
|
||
...row,
|
||
overdue:
|
||
row.status === 'PENDING_REVIEW' ? isWithdrawOverdue(row.appliedAt, now) : false,
|
||
}));
|
||
|
||
return serializeBigInt({
|
||
items: mapped,
|
||
total,
|
||
page,
|
||
pageSize,
|
||
summary: {
|
||
count: aggregates._count,
|
||
totalAmount: Number(aggregates._sum.amount ?? 0),
|
||
},
|
||
});
|
||
}
|
||
|
||
async getAdminStoreWithdrawal(id: bigint) {
|
||
const row = await this.prisma.storeWithdrawRequest.findUnique({
|
||
where: { id },
|
||
include: {
|
||
store: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
cityName: true,
|
||
phone: true,
|
||
},
|
||
},
|
||
storeAccount: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
phone: true,
|
||
bankAccountName: true,
|
||
bankAccountNo: true,
|
||
bankBranch: true,
|
||
},
|
||
},
|
||
items: {
|
||
include: {
|
||
storePayout: {
|
||
include: {
|
||
redeemRecord: { select: { redeemNo: true, amount: true, createdAt: true } },
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
});
|
||
if (!row) throw new NotFoundException('提现申请不存在');
|
||
return serializeBigInt({
|
||
...row,
|
||
paymentProofUrls: parsePaymentProofUrls(row.paymentProofUrls),
|
||
overdue:
|
||
row.status === 'PENDING_REVIEW' ? isWithdrawOverdue(row.appliedAt) : false,
|
||
});
|
||
}
|
||
|
||
async approveStoreWithdraw(
|
||
id: bigint,
|
||
hqAccountId: bigint,
|
||
dto?: { paymentRef?: string; paymentProofUrls?: string[] },
|
||
) {
|
||
const row = await this.prisma.storeWithdrawRequest.findUnique({
|
||
where: { id },
|
||
include: { items: { select: { storePayoutId: true } } },
|
||
});
|
||
if (!row) throw new NotFoundException('提现申请不存在');
|
||
if (row.status !== 'PENDING_REVIEW') {
|
||
throw new BadRequestException('仅待审核提现可审核通过');
|
||
}
|
||
|
||
const paidAt = new Date();
|
||
const updated = await this.prisma.$transaction(async (tx) => {
|
||
const req = await tx.storeWithdrawRequest.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'PAID',
|
||
reviewedAt: paidAt,
|
||
reviewedByHqId: hqAccountId,
|
||
paidAt,
|
||
paymentRef: dto?.paymentRef?.trim() || null,
|
||
paymentProofUrls: paymentProofUrlsInput(dto?.paymentProofUrls),
|
||
},
|
||
});
|
||
await tx.storePayout.updateMany({
|
||
where: {
|
||
id: { in: row.items.map((i) => i.storePayoutId) },
|
||
status: 'PENDING',
|
||
},
|
||
data: { status: 'PAID', paidAt },
|
||
});
|
||
return req;
|
||
});
|
||
|
||
this.analyticsService.trackStoreOneSafe(undefined, 'HQ_WEB', {
|
||
storeId: row.storeId,
|
||
eventName: 'store_withdraw_paid',
|
||
refType: 'STORE_WITHDRAW',
|
||
refId: id,
|
||
extraJson: {
|
||
amount: Number(row.amount),
|
||
paymentRef: dto?.paymentRef,
|
||
paymentProofCount: parsePaymentProofUrls(dto?.paymentProofUrls).length,
|
||
},
|
||
});
|
||
|
||
const [store, bank] = await Promise.all([
|
||
this.prisma.store.findUnique({
|
||
where: { id: row.storeId },
|
||
select: {
|
||
name: true,
|
||
cityName: true,
|
||
cityRef: { select: { name: true } },
|
||
partnerAccount: {
|
||
select: {
|
||
name: true,
|
||
companyName: true,
|
||
parent: { select: { companyName: true } },
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
loadStorePrimaryBank(this.prisma, row.storeId),
|
||
]);
|
||
const meta = storeWecomMeta(store, String(row.storeId));
|
||
const bankParts = wecomBankParts(bank);
|
||
void this.wecomPush.dispatchEvent(
|
||
'store.withdraw_approved',
|
||
{
|
||
cityName: meta.cityName,
|
||
storeName: meta.storeName,
|
||
partnerLabel: meta.partnerLabel,
|
||
withdrawNo: row.withdrawNo,
|
||
amount: Number(row.amount).toFixed(2),
|
||
payee: bankParts.payee,
|
||
accountNo: bankParts.accountNo,
|
||
bankBranch: bankParts.bankBranch,
|
||
bankAccount: formatWecomBankAccount(bank),
|
||
storeId: row.storeId.toString(),
|
||
},
|
||
{
|
||
handlePath: `/finance/store-bills?kind=WITHDRAW&status=PAID&storeId=${row.storeId.toString()}`,
|
||
},
|
||
);
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async rejectStoreWithdraw(id: bigint, hqAccountId: bigint, reason: string) {
|
||
const row = await this.prisma.storeWithdrawRequest.findUnique({
|
||
where: { id },
|
||
});
|
||
if (!row) throw new NotFoundException('提现申请不存在');
|
||
if (row.status !== 'PENDING_REVIEW') {
|
||
throw new BadRequestException('仅待审核提现可驳回');
|
||
}
|
||
const rejectReason = reason.trim();
|
||
if (!rejectReason) throw new BadRequestException('请填写驳回理由');
|
||
|
||
const updated = await this.prisma.$transaction(async (tx) => {
|
||
const req = await tx.storeWithdrawRequest.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'REJECTED',
|
||
rejectReason,
|
||
reviewedAt: new Date(),
|
||
reviewedByHqId: hqAccountId,
|
||
},
|
||
});
|
||
// 释放 payout 锁定，允许再次提现
|
||
await tx.storeWithdrawPayoutItem.deleteMany({ where: { withdrawRequestId: id } });
|
||
return req;
|
||
});
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async getStoreWithdrawOverdueSummary() {
|
||
const pending = await this.prisma.storeWithdrawRequest.findMany({
|
||
where: { status: 'PENDING_REVIEW' },
|
||
select: { id: true, appliedAt: true, amount: true },
|
||
});
|
||
const now = new Date();
|
||
const overdue = pending.filter((r) => isWithdrawOverdue(r.appliedAt, now));
|
||
return {
|
||
pendingCount: pending.length,
|
||
overdueCount: overdue.length,
|
||
overdueAmount: round2(overdue.reduce((s, r) => s + Number(r.amount), 0)),
|
||
pendingAmount: round2(pending.reduce((s, r) => s + Number(r.amount), 0)),
|
||
};
|
||
}
|
||
|
||
/** FIN-003：工作日 18:00 扫描超时未审提现 */
|
||
async scanOverdueStoreWithdrawals() {
|
||
const summary = await this.getStoreWithdrawOverdueSummary();
|
||
if (summary.overdueCount > 0) {
|
||
const overdueRows = await this.prisma.storeWithdrawRequest.findMany({
|
||
where: { status: 'PENDING_REVIEW' },
|
||
include: { store: { select: { name: true, phone: true } } },
|
||
orderBy: { appliedAt: 'asc' },
|
||
take: 20,
|
||
});
|
||
const now = new Date();
|
||
const lines = overdueRows
|
||
.filter((r) => isWithdrawOverdue(r.appliedAt, now))
|
||
.slice(0, 10)
|
||
.map(
|
||
(r) =>
|
||
`- ${r.store?.name || r.storeId} ${r.withdrawNo} ¥${Number(r.amount).toFixed(2)}`,
|
||
);
|
||
this.alert.notify({
|
||
level: 'P1',
|
||
category: 'settlement',
|
||
title: '门店提现超时未审',
|
||
detail: [
|
||
`待审 ${summary.pendingCount} 笔，超时 ${summary.overdueCount} 笔，超时金额 ¥${summary.overdueAmount.toFixed(2)}`,
|
||
...lines,
|
||
'请尽快在 HQ「财务 → 门店账单（手动提现）」处理。',
|
||
].join('\n'),
|
||
dedupeKey: `store_withdraw_overdue|${shanghaiYmd(new Date())}`,
|
||
dedupeTtlSec: 6 * 3600,
|
||
});
|
||
}
|
||
return summary;
|
||
}
|
||
|
||
async listAdminStorePayouts(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where = this.buildStorePayoutWhere(query);
|
||
|
||
const [items, total, aggregates] = await Promise.all([
|
||
this.prisma.storePayout.findMany({
|
||
where,
|
||
orderBy: [{ createdAt: 'desc' }, { expectedPayAt: 'asc' }],
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
redeemRecord: { select: { redeemNo: true, amount: true, userId: true, createdAt: true } },
|
||
},
|
||
}),
|
||
this.prisma.storePayout.count({ where }),
|
||
this.prisma.storePayout.aggregate({
|
||
where,
|
||
_sum: { redeemAmount: true, payoutAmount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const summary = {
|
||
count: aggregates._count,
|
||
redeemAmount: Number(aggregates._sum.redeemAmount ?? 0),
|
||
payoutAmount: Number(aggregates._sum.payoutAmount ?? 0),
|
||
totalAmount: Number(aggregates._sum.payoutAmount ?? 0),
|
||
};
|
||
|
||
return serializeBigInt({ items, total, page, pageSize, summary });
|
||
}
|
||
|
||
async getAdminStorePayout(id: bigint) {
|
||
const payout = await this.prisma.storePayout.findUnique({
|
||
where: { id },
|
||
include: {
|
||
store: true,
|
||
redeemRecord: true,
|
||
},
|
||
});
|
||
if (!payout) throw new NotFoundException('打款记录不存在');
|
||
return serializeBigInt(payout);
|
||
}
|
||
|
||
async confirmStorePayout(id: bigint, dto: { paymentRef?: string; batchNo?: string; remark?: string }) {
|
||
const payout = await this.prisma.storePayout.findUnique({ where: { id } });
|
||
if (!payout) throw new NotFoundException('打款记录不存在');
|
||
if (payout.status !== 'PENDING') throw new BadRequestException('仅未打款记录可确认');
|
||
|
||
const updated = await this.prisma.storePayout.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'PAID',
|
||
paidAt: new Date(),
|
||
batchNo: dto.batchNo ?? payout.batchNo,
|
||
},
|
||
});
|
||
|
||
if (payout.storeBillId) {
|
||
const pending = await this.prisma.storePayout.count({
|
||
where: { storeBillId: payout.storeBillId, status: 'PENDING' },
|
||
});
|
||
if (pending === 0) {
|
||
await this.prisma.storeBill.update({
|
||
where: { id: payout.storeBillId },
|
||
data: { status: 'PAID', paidAt: new Date() },
|
||
});
|
||
}
|
||
}
|
||
|
||
this.analyticsService.trackStoreOneSafe(undefined, 'HQ_WEB', {
|
||
storeId: payout.storeId,
|
||
eventName: 'store_payout_paid',
|
||
refType: 'STORE_PAYOUT',
|
||
refId: id,
|
||
extraJson: {
|
||
batchNo: dto.batchNo ?? payout.batchNo,
|
||
paymentRef: dto.paymentRef,
|
||
payoutAmount: Number(payout.payoutAmount),
|
||
},
|
||
});
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchConfirmStorePayouts(ids: string[], dto: { batchNo?: string }) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.confirmStorePayout(BigInt(id), { batchNo: dto.batchNo });
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async exportAdminStorePayouts(query: {
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const where = this.buildStorePayoutWhere(query);
|
||
const items = await this.prisma.storePayout.findMany({
|
||
where,
|
||
include: {
|
||
store: { select: { name: true, phone: true, cityName: true } },
|
||
redeemRecord: { select: { redeemNo: true, createdAt: true } },
|
||
},
|
||
orderBy: { createdAt: 'desc' },
|
||
});
|
||
const header = ['核销单号', '门店', '城市', '核销金额', '结算比例', '应付金额', '状态', '核销时间', '打款时间'].join(',');
|
||
const rows = items.map((p) =>
|
||
[
|
||
csvEscape(p.redeemRecord.redeemNo ?? ''),
|
||
csvEscape(p.store.name),
|
||
csvEscape(p.store.cityName ?? ''),
|
||
Number(p.redeemAmount),
|
||
Number(p.settlementRate),
|
||
Number(p.payoutAmount),
|
||
p.status,
|
||
p.redeemRecord.createdAt.toISOString().slice(0, 19).replace('T', ' '),
|
||
p.paidAt ? p.paidAt.toISOString().slice(0, 19).replace('T', ' ') : '',
|
||
].join(','),
|
||
);
|
||
return { csv: `\uFEFF${[header, ...rows].join('\n')}`, count: items.length };
|
||
}
|
||
|
||
async scanDueStorePayouts() {
|
||
const now = new Date();
|
||
const due = await this.prisma.storePayout.findMany({
|
||
where: { status: 'PENDING', expectedPayAt: { lte: now } },
|
||
take: 100,
|
||
});
|
||
return serializeBigInt({ dueCount: due.length, items: due });
|
||
}
|
||
|
||
private buildStorePayoutWhere(query: {
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}): Prisma.StorePayoutWhereInput {
|
||
const where: Prisma.StorePayoutWhereInput = {};
|
||
if (query.status === 'PENDING' || query.status === 'PAID') where.status = query.status;
|
||
if (query.storeId) where.storeId = BigInt(query.storeId);
|
||
if (query.dateFrom || query.dateTo) {
|
||
where.createdAt = {};
|
||
if (query.dateFrom) where.createdAt.gte = new Date(query.dateFrom);
|
||
if (query.dateTo) {
|
||
const end = new Date(query.dateTo);
|
||
end.setHours(23, 59, 59, 999);
|
||
where.createdAt.lte = end;
|
||
}
|
||
}
|
||
return where;
|
||
}
|
||
|
||
// ─── Store bills (daily header) ──────────────────────
|
||
|
||
/** 生成昨日核销窗口的门店对账单；billDate = 出账日（北京时间今天） */
|
||
async generateStoreBillsForDay(anchor = new Date()) {
|
||
const { start, end, billDate } = shanghaiT1DayWindow(anchor);
|
||
const payouts = await this.prisma.storePayout.findMany({
|
||
where: {
|
||
storeBillId: null,
|
||
createdAt: { gte: start, lt: end },
|
||
// 排除已锁定在待审提现单中的明细，避免出账与提现双占
|
||
withdrawItem: { is: null },
|
||
status: 'PENDING',
|
||
},
|
||
include: {
|
||
store: {
|
||
select: {
|
||
id: true,
|
||
name: true,
|
||
cityName: true,
|
||
settlementRate: true,
|
||
cityRef: { select: { name: true } },
|
||
partnerAccount: {
|
||
select: {
|
||
name: true,
|
||
companyName: true,
|
||
parent: { select: { companyName: true } },
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
});
|
||
|
||
const byStore = new Map<string, typeof payouts>();
|
||
for (const p of payouts) {
|
||
const key = p.storeId.toString();
|
||
const list = byStore.get(key) ?? [];
|
||
list.push(p);
|
||
byStore.set(key, list);
|
||
}
|
||
|
||
let created = 0;
|
||
let skipped = 0;
|
||
const createdBills: Array<{
|
||
storeId: bigint;
|
||
storeName: string;
|
||
cityName: string;
|
||
partnerLabel: string;
|
||
redeemCount: number;
|
||
redeemAmount: number;
|
||
settlementRate: number;
|
||
amount: number;
|
||
}> = [];
|
||
for (const [storeIdStr, list] of byStore) {
|
||
const storeId = BigInt(storeIdStr);
|
||
const meta = storeWecomMeta(list[0]?.store, storeIdStr);
|
||
const existing = await this.prisma.storeBill.findUnique({
|
||
where: { storeId_billDate: { storeId, billDate } },
|
||
});
|
||
if (existing) {
|
||
if (existing.status === 'PAID') {
|
||
skipped += 1;
|
||
continue;
|
||
}
|
||
const redeemAmount = round2(list.reduce((s, p) => s + Number(p.redeemAmount), 0));
|
||
const payoutAmount = round2(list.reduce((s, p) => s + Number(p.payoutAmount), 0));
|
||
const rate = Number(list[0].settlementRate);
|
||
const updatedTotal = round2(Number(existing.payoutAmount) + payoutAmount);
|
||
await this.prisma.$transaction(async (tx) => {
|
||
await tx.storeBill.update({
|
||
where: { id: existing.id },
|
||
data: {
|
||
redeemCount: existing.redeemCount + list.length,
|
||
redeemAmount: round2(Number(existing.redeemAmount) + redeemAmount),
|
||
payoutAmount: updatedTotal,
|
||
settlementRate: rate,
|
||
},
|
||
});
|
||
await tx.storePayout.updateMany({
|
||
where: { id: { in: list.map((p) => p.id) } },
|
||
data: { storeBillId: existing.id },
|
||
});
|
||
});
|
||
created += 1;
|
||
createdBills.push({
|
||
storeId,
|
||
...meta,
|
||
redeemCount: existing.redeemCount + list.length,
|
||
redeemAmount: round2(Number(existing.redeemAmount) + redeemAmount),
|
||
settlementRate: rate,
|
||
amount: updatedTotal,
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const redeemAmount = round2(list.reduce((s, p) => s + Number(p.redeemAmount), 0));
|
||
const payoutAmount = round2(list.reduce((s, p) => s + Number(p.payoutAmount), 0));
|
||
const rate = Number(list[0].settlementRate);
|
||
await this.prisma.$transaction(async (tx) => {
|
||
const bill = await tx.storeBill.create({
|
||
data: {
|
||
billNo: generateBillNo('SB'),
|
||
storeId,
|
||
billDate,
|
||
redeemCount: list.length,
|
||
redeemAmount,
|
||
settlementRate: rate,
|
||
payoutAmount,
|
||
status: 'UNPAID',
|
||
},
|
||
});
|
||
await tx.storePayout.updateMany({
|
||
where: { id: { in: list.map((p) => p.id) } },
|
||
data: { storeBillId: bill.id },
|
||
});
|
||
});
|
||
created += 1;
|
||
createdBills.push({
|
||
storeId,
|
||
...meta,
|
||
redeemCount: list.length,
|
||
redeemAmount,
|
||
settlementRate: rate,
|
||
amount: payoutAmount,
|
||
});
|
||
}
|
||
|
||
const period = shanghaiYmd(billDate);
|
||
if (createdBills.length) {
|
||
const banks = await loadStorePrimaryBanksMap(
|
||
this.prisma,
|
||
createdBills.map((b) => b.storeId),
|
||
);
|
||
const blocks = createdBills.map((b) =>
|
||
formatStoreBillWecomBlock({
|
||
...b,
|
||
bank: banks.get(b.storeId.toString()) ?? null,
|
||
}),
|
||
);
|
||
void this.wecomPush.dispatchEvent(
|
||
'finance.store_bill',
|
||
{
|
||
period,
|
||
billCount: String(createdBills.length),
|
||
totalAmount: sumAmounts(createdBills),
|
||
billSummary: capBillBlocks(blocks),
|
||
},
|
||
{ handlePath: '/finance/store-bills?kind=T1_BILL' },
|
||
);
|
||
}
|
||
|
||
return { billDate: period, created, skipped, payoutLinked: payouts.length };
|
||
}
|
||
|
||
/**
|
||
* 总部「门店账单」统一列表：T+1 StoreBill + 手动提现 StoreWithdrawRequest
|
||
* 中小数据量内存合并后分页。
|
||
*/
|
||
async listAdminStoreSettlements(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
kind?: string;
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const kind = query.kind === 'T1_BILL' || query.kind === 'WITHDRAW' ? query.kind : undefined;
|
||
const status = query.status?.trim() || undefined;
|
||
|
||
const includeBills =
|
||
!kind || kind === 'T1_BILL'
|
||
? !status || status === 'UNPAID' || status === 'PAID'
|
||
: false;
|
||
const includeWithdraws =
|
||
!kind || kind === 'WITHDRAW'
|
||
? !status ||
|
||
status === 'PENDING_REVIEW' ||
|
||
status === 'REJECTED' ||
|
||
status === 'PAID'
|
||
: false;
|
||
|
||
const billWhere = includeBills
|
||
? this.buildStoreBillWhere({
|
||
status: status === 'UNPAID' || status === 'PAID' ? status : undefined,
|
||
storeId: query.storeId,
|
||
dateFrom: query.dateFrom,
|
||
dateTo: query.dateTo,
|
||
})
|
||
: null;
|
||
|
||
const withdrawWhere: Prisma.StoreWithdrawRequestWhereInput | null = includeWithdraws
|
||
? (() => {
|
||
const where: Prisma.StoreWithdrawRequestWhereInput = {};
|
||
if (status === 'PENDING_REVIEW' || status === 'REJECTED' || status === 'PAID') {
|
||
where.status = status;
|
||
}
|
||
if (query.storeId) where.storeId = BigInt(query.storeId);
|
||
if (query.dateFrom || query.dateTo) {
|
||
where.appliedAt = {};
|
||
if (query.dateFrom) where.appliedAt.gte = parseShanghaiYmd(query.dateFrom);
|
||
if (query.dateTo) where.appliedAt.lt = addShanghaiDays(parseShanghaiYmd(query.dateTo), 1);
|
||
}
|
||
return where;
|
||
})()
|
||
: null;
|
||
|
||
const bills = billWhere
|
||
? await this.prisma.storeBill.findMany({
|
||
where: billWhere,
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
},
|
||
})
|
||
: [];
|
||
const withdraws = withdrawWhere
|
||
? await this.prisma.storeWithdrawRequest.findMany({
|
||
where: withdrawWhere,
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
},
|
||
})
|
||
: [];
|
||
|
||
const now = new Date();
|
||
type UnifiedRow = {
|
||
kind: 'T1_BILL' | 'WITHDRAW';
|
||
id: bigint;
|
||
billNo: string;
|
||
storeId: bigint;
|
||
amount: number;
|
||
status: string;
|
||
date: Date;
|
||
overdue?: boolean;
|
||
redeemCount?: number;
|
||
redeemAmount?: number;
|
||
settlementRate?: number;
|
||
payoutCount?: number;
|
||
store?: { id: bigint; name: string; cityName: string; phone: string | null };
|
||
};
|
||
|
||
const rows: UnifiedRow[] = [
|
||
...bills.map((b) => ({
|
||
kind: 'T1_BILL' as const,
|
||
id: b.id,
|
||
billNo: b.billNo,
|
||
storeId: b.storeId,
|
||
amount: Number(b.payoutAmount),
|
||
status: b.status,
|
||
date: b.billDate,
|
||
redeemCount: b.redeemCount,
|
||
redeemAmount: Number(b.redeemAmount),
|
||
settlementRate: Number(b.settlementRate),
|
||
store: b.store,
|
||
})),
|
||
...withdraws.map((w) => ({
|
||
kind: 'WITHDRAW' as const,
|
||
id: w.id,
|
||
billNo: w.withdrawNo,
|
||
storeId: w.storeId,
|
||
amount: Number(w.amount),
|
||
status: w.status,
|
||
date: w.appliedAt,
|
||
overdue: w.status === 'PENDING_REVIEW' ? isWithdrawOverdue(w.appliedAt, now) : false,
|
||
payoutCount: w.payoutCount,
|
||
store: w.store,
|
||
})),
|
||
];
|
||
|
||
rows.sort((a, b) => {
|
||
const dt = b.date.getTime() - a.date.getTime();
|
||
if (dt !== 0) return dt;
|
||
return Number(b.id - a.id);
|
||
});
|
||
|
||
const total = rows.length;
|
||
const slice = rows.slice((page - 1) * pageSize, page * pageSize);
|
||
const storeIds = [...new Set(rows.filter((r) => r.kind === 'T1_BILL').map((r) => r.storeId))];
|
||
const bankMap = await loadStorePrimaryBanksMap(this.prisma, storeIds);
|
||
|
||
const redeemAmount = bills.reduce((s, b) => s + Number(b.redeemAmount), 0);
|
||
const payoutAmount = rows.reduce((s, r) => s + r.amount, 0);
|
||
|
||
return serializeBigInt({
|
||
items: slice.map((r) => ({
|
||
...r,
|
||
date: r.kind === 'T1_BILL' ? shanghaiYmd(r.date) : r.date,
|
||
bankAccount:
|
||
r.kind === 'T1_BILL'
|
||
? bankMap.get(String(r.storeId)) ?? null
|
||
: null,
|
||
})),
|
||
total,
|
||
page,
|
||
pageSize,
|
||
summary: {
|
||
count: total,
|
||
redeemAmount,
|
||
payoutAmount,
|
||
totalAmount: payoutAmount,
|
||
},
|
||
});
|
||
}
|
||
|
||
async listAdminStoreBills(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where = this.buildStoreBillWhere(query);
|
||
|
||
const [items, total, aggregates] = await Promise.all([
|
||
this.prisma.storeBill.findMany({
|
||
where,
|
||
orderBy: [{ billDate: 'desc' }, { id: 'desc' }],
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
},
|
||
}),
|
||
this.prisma.storeBill.count({ where }),
|
||
this.prisma.storeBill.aggregate({
|
||
where,
|
||
_sum: { redeemAmount: true, payoutAmount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const summary = {
|
||
count: aggregates._count,
|
||
redeemAmount: Number(aggregates._sum.redeemAmount ?? 0),
|
||
payoutAmount: Number(aggregates._sum.payoutAmount ?? 0),
|
||
totalAmount: Number(aggregates._sum.payoutAmount ?? 0),
|
||
};
|
||
|
||
return serializeBigInt({
|
||
items: items.map((b) => ({ ...b, billDate: shanghaiYmd(b.billDate) })),
|
||
total,
|
||
page,
|
||
pageSize,
|
||
summary,
|
||
});
|
||
}
|
||
|
||
async getAdminStoreBill(id: bigint) {
|
||
const bill = await this.prisma.storeBill.findUnique({
|
||
where: { id },
|
||
include: {
|
||
store: { select: { id: true, name: true, cityName: true, phone: true } },
|
||
payouts: {
|
||
include: { redeemRecord: { select: { redeemNo: true, amount: true, createdAt: true } } },
|
||
orderBy: { createdAt: 'desc' },
|
||
},
|
||
},
|
||
});
|
||
if (!bill) throw new NotFoundException('门店对账单不存在');
|
||
const storeAccount = await loadStorePrimaryBank(this.prisma, bill.storeId);
|
||
return serializeBigInt({
|
||
...bill,
|
||
billDate: shanghaiYmd(bill.billDate),
|
||
storeAccount,
|
||
paymentProofUrls: parsePaymentProofUrls(bill.paymentProofUrls),
|
||
});
|
||
}
|
||
|
||
async confirmStoreBill(
|
||
id: bigint,
|
||
dto: { paymentRef?: string; paymentProofUrls?: string[] } = {},
|
||
) {
|
||
const bill = await this.prisma.storeBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('门店对账单不存在');
|
||
if (bill.status !== 'UNPAID') throw new BadRequestException('仅未打款账单可确认打款');
|
||
|
||
const paidAt = new Date();
|
||
const updated = await this.prisma.$transaction(async (tx) => {
|
||
const b = await tx.storeBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'PAID',
|
||
paidAt,
|
||
paymentRef: dto.paymentRef?.trim() || null,
|
||
paymentProofUrls: paymentProofUrlsInput(dto.paymentProofUrls),
|
||
},
|
||
});
|
||
await tx.storePayout.updateMany({
|
||
where: { storeBillId: id, status: 'PENDING' },
|
||
data: { status: 'PAID', paidAt },
|
||
});
|
||
return b;
|
||
});
|
||
return serializeBigInt({
|
||
...updated,
|
||
paymentProofUrls: parsePaymentProofUrls(updated.paymentProofUrls),
|
||
});
|
||
}
|
||
|
||
async batchConfirmStoreBills(
|
||
ids: string[],
|
||
dto: { paymentRef?: string; paymentProofUrls?: string[] } = {},
|
||
) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.confirmStoreBill(BigInt(id), dto);
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async exportAdminStoreBills(query: {
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
const where = this.buildStoreBillWhere(query);
|
||
const bills = await this.prisma.storeBill.findMany({
|
||
where,
|
||
include: { store: { select: { id: true, name: true, phone: true, cityName: true } } },
|
||
orderBy: { billDate: 'desc' },
|
||
});
|
||
const bankMap = await loadStorePrimaryBanksMap(
|
||
this.prisma,
|
||
bills.map((b) => b.storeId),
|
||
);
|
||
const header = [
|
||
'账单号',
|
||
'出账日',
|
||
'门店',
|
||
'城市',
|
||
'核销笔数',
|
||
'核销金额',
|
||
'结算比例',
|
||
'应付金额',
|
||
'状态',
|
||
'打款时间',
|
||
'打款凭证',
|
||
'打款凭证照片',
|
||
'收款户名',
|
||
'收款账号',
|
||
'开户行',
|
||
].join(',');
|
||
const rows = bills.map((b) => {
|
||
const bank = bankMap.get(String(b.storeId));
|
||
return [
|
||
csvEscape(b.billNo),
|
||
shanghaiYmd(b.billDate),
|
||
csvEscape(b.store.name),
|
||
csvEscape(b.store.cityName ?? ''),
|
||
b.redeemCount,
|
||
Number(b.redeemAmount),
|
||
Number(b.settlementRate),
|
||
Number(b.payoutAmount),
|
||
b.status,
|
||
b.paidAt ? b.paidAt.toISOString().slice(0, 19).replace('T', ' ') : '',
|
||
csvEscape(b.paymentRef ?? ''),
|
||
csvEscape(parsePaymentProofUrls(b.paymentProofUrls).join(' ')),
|
||
csvEscape(bank?.bankAccountName ?? ''),
|
||
csvEscape(bank?.bankAccountNo ?? ''),
|
||
csvEscape(bank?.bankBranch ?? ''),
|
||
].join(',');
|
||
});
|
||
return { csv: `\uFEFF${[header, ...rows].join('\n')}`, count: bills.length };
|
||
}
|
||
|
||
private buildStoreBillWhere(query: {
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}): Prisma.StoreBillWhereInput {
|
||
const where: Prisma.StoreBillWhereInput = {};
|
||
if (query.status === 'UNPAID' || query.status === 'PAID') where.status = query.status;
|
||
if (query.storeId) where.storeId = BigInt(query.storeId);
|
||
if (query.dateFrom || query.dateTo) {
|
||
where.billDate = {};
|
||
if (query.dateFrom) where.billDate.gte = parseShanghaiYmd(query.dateFrom);
|
||
if (query.dateTo) where.billDate.lte = parseShanghaiYmd(query.dateTo);
|
||
}
|
||
return where;
|
||
}
|
||
|
||
/** @deprecated 兼容旧 daily 聚合视图 */
|
||
async listAdminStoreDailyBills(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
storeId?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
}) {
|
||
return this.listAdminStoreBills(query);
|
||
}
|
||
|
||
// ─── Partner bills ───────────────────────────────────
|
||
|
||
async listPartnerBills(partnerAccountId: bigint) {
|
||
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
||
const bills = await this.prisma.partnerBill.findMany({
|
||
where: {
|
||
partnerAccountId: primary.id,
|
||
status: { in: ['AWAITING_CONFIRM', 'UNPAID', 'PAID', 'REJECTED'] },
|
||
totalAmount: { gt: 0 },
|
||
},
|
||
orderBy: { createdAt: 'desc' },
|
||
});
|
||
this.analyticsService.trackPartnerOneSafe(partnerAccountId, 'PARTNER_H5', {
|
||
partnerAccountId: primary.id,
|
||
eventName: 'partner_bill_view',
|
||
extraJson: { count: bills.length },
|
||
});
|
||
return serializeBigInt(bills.map(withShanghaiPeriod));
|
||
}
|
||
|
||
getPartnerSettlementCycle(anchor = new Date()) {
|
||
return partnerSettlementCycleDto(anchor);
|
||
}
|
||
|
||
async getPartnerSettlementPreview(partnerAccountId: bigint) {
|
||
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
||
const { start } = shanghaiWeekRange();
|
||
const now = new Date();
|
||
const periodEnd = now.getTime() < start.getTime() ? start : now;
|
||
const redeemCommissionRate = Number(primary.redeemCommissionRate ?? 0.03);
|
||
|
||
const orders = await this.prisma.order.findMany({
|
||
where: {
|
||
partnerAccountIdAtPay: primary.id,
|
||
payStatus: 'PAID',
|
||
paidAt: { gte: start, lte: periodEnd },
|
||
},
|
||
select: { payAmount: true, orderCommissionRateAtPay: true },
|
||
});
|
||
const orderCommission = round2(
|
||
orders.reduce((sum, o) => {
|
||
const rate = o.orderCommissionRateAtPay != null ? Number(o.orderCommissionRateAtPay) : 0;
|
||
return sum + Number(o.payAmount) * rate;
|
||
}, 0),
|
||
);
|
||
|
||
const stores = await this.prisma.store.findMany({
|
||
where: { partnerAccountId: primary.id },
|
||
select: { id: true },
|
||
});
|
||
const storeIds = stores.map((s) => s.id);
|
||
const redeems = !storeIds.length
|
||
? []
|
||
: await this.prisma.redeemRecord.findMany({
|
||
where: {
|
||
storeId: { in: storeIds },
|
||
createdAt: { gte: start, lte: periodEnd },
|
||
},
|
||
select: { amount: true },
|
||
});
|
||
const redeemCommission = round2(
|
||
redeems.reduce((sum, r) => sum + Number(r.amount) * redeemCommissionRate, 0),
|
||
);
|
||
|
||
return {
|
||
...partnerSettlementCycleDto(),
|
||
prepaymentAmount: round2(orderCommission + redeemCommission),
|
||
orderCommissionEstimate: orderCommission,
|
||
redeemCommissionEstimate: redeemCommission,
|
||
};
|
||
}
|
||
|
||
async getPartnerBill(partnerAccountId: bigint, billId: bigint) {
|
||
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
||
const bill = await this.prisma.partnerBill.findFirst({
|
||
where: { id: billId, partnerAccountId: primary.id },
|
||
include: { items: { orderBy: { occurredAt: 'asc' } } },
|
||
});
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
if (Number(bill.totalAmount) <= 0) throw new NotFoundException('账单不存在');
|
||
this.analyticsService.trackPartnerOneSafe(partnerAccountId, 'PARTNER_H5', {
|
||
partnerAccountId: primary.id,
|
||
eventName: 'partner_bill_detail_view',
|
||
refType: 'PARTNER_BILL',
|
||
refId: billId,
|
||
extraJson: { billId: billId.toString(), status: bill.status },
|
||
});
|
||
const { items, ...header } = bill;
|
||
return serializeBigInt({
|
||
...withShanghaiPeriod(header),
|
||
partnerId: header.partnerAccountId.toString(),
|
||
...splitPartnerBillItems(items),
|
||
});
|
||
}
|
||
|
||
async listAdminPartnerBills(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
partnerId?: string;
|
||
year?: number;
|
||
month?: number;
|
||
weekStartYmd?: string;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where = this.buildPartnerBillWhere(query);
|
||
|
||
const [rawItems, total, aggregates] = await Promise.all([
|
||
this.prisma.partnerBill.findMany({
|
||
where,
|
||
orderBy: { periodStart: 'desc' },
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: {
|
||
partnerAccount: {
|
||
select: {
|
||
id: true,
|
||
companyName: true,
|
||
name: true,
|
||
phone: true,
|
||
bankAccountName: true,
|
||
bankAccountNo: true,
|
||
bankBranch: true,
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
this.prisma.partnerBill.count({ where }),
|
||
this.prisma.partnerBill.aggregate({
|
||
where,
|
||
_sum: { orderCommission: true, redeemCommission: true, totalAmount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const items = rawItems.map((b) => ({
|
||
...withShanghaiPeriod(b),
|
||
partner: b.partnerAccount,
|
||
}));
|
||
|
||
const summary = {
|
||
count: aggregates._count,
|
||
orderCommission: Number(aggregates._sum.orderCommission ?? 0),
|
||
redeemCommission: Number(aggregates._sum.redeemCommission ?? 0),
|
||
totalAmount: Number(aggregates._sum.totalAmount ?? 0),
|
||
};
|
||
|
||
return serializeBigInt({ items, total, page, pageSize, summary });
|
||
}
|
||
|
||
private buildPartnerBillWhere(query: {
|
||
status?: string;
|
||
partnerId?: string;
|
||
year?: number;
|
||
month?: number;
|
||
weekStartYmd?: string;
|
||
}): Prisma.PartnerBillWhereInput {
|
||
const where: Prisma.PartnerBillWhereInput = {};
|
||
if (query.status) where.status = query.status as Prisma.EnumPartnerBillStatusFilter['equals'];
|
||
if (query.partnerId) where.partnerAccountId = BigInt(query.partnerId);
|
||
if (query.weekStartYmd) {
|
||
const { periodStart, endExclusive } = resolvePartnerWeekPeriod(query.weekStartYmd);
|
||
where.periodStart = { gte: periodStart, lt: endExclusive };
|
||
} else if (query.year && query.month) {
|
||
const { start, endExclusive } = shanghaiMonthRange(query.year, query.month);
|
||
where.periodStart = { gte: start, lt: endExclusive };
|
||
}
|
||
return where;
|
||
}
|
||
|
||
async generateAllPartnerBills(body: { weekStartYmd: string }) {
|
||
const partners = await this.prisma.partnerAccount.findMany({
|
||
where: { isPrimary: 1, status: 'ACTIVE' },
|
||
select: {
|
||
id: true,
|
||
companyName: true,
|
||
name: true,
|
||
bankAccountName: true,
|
||
bankBranch: true,
|
||
bankAccountNo: true,
|
||
city: { select: { name: true } },
|
||
},
|
||
});
|
||
const results: Array<{ partnerId: string; companyName: string; ok: boolean; message?: string }> = [];
|
||
const created: Array<{
|
||
cityName: string;
|
||
partnerLabel: string;
|
||
orderCount?: number;
|
||
redeemCount?: number;
|
||
orderCommission: number;
|
||
redeemCommission: number;
|
||
amount: number;
|
||
bank?: WecomBankLike | null;
|
||
}> = [];
|
||
for (const p of partners) {
|
||
try {
|
||
const bill = await this.generatePartnerBill(
|
||
{
|
||
partnerId: p.id.toString(),
|
||
weekStartYmd: body.weekStartYmd,
|
||
},
|
||
{ notify: false },
|
||
);
|
||
results.push({ partnerId: p.id.toString(), companyName: p.companyName ?? '', ok: true });
|
||
created.push({
|
||
cityName: p.city?.name?.trim() || '—',
|
||
partnerLabel: formatPartnerDashLabel(p.companyName, p.name),
|
||
orderCount: Number(bill.orderCount ?? 0),
|
||
redeemCount: Number(bill.redeemCount ?? 0),
|
||
orderCommission: Number(bill.orderCommission),
|
||
redeemCommission: Number(bill.redeemCommission),
|
||
amount: Number(bill.totalAmount),
|
||
bank: {
|
||
bankAccountName: p.bankAccountName,
|
||
bankBranch: p.bankBranch,
|
||
bankAccountNo: p.bankAccountNo,
|
||
},
|
||
});
|
||
} catch (e) {
|
||
results.push({
|
||
partnerId: p.id.toString(),
|
||
companyName: p.companyName ?? '',
|
||
ok: false,
|
||
message: e instanceof Error ? e.message : '失败',
|
||
});
|
||
}
|
||
}
|
||
this.notifyPartnerBillDigest(body.weekStartYmd, created);
|
||
return {
|
||
total: partners.length,
|
||
success: results.filter((r) => r.ok).length,
|
||
failed: results.filter((r) => !r.ok).length,
|
||
results,
|
||
};
|
||
}
|
||
|
||
/** 每周一任务：生成上一自然周账单 */
|
||
async generatePreviousWeekPartnerBills(anchor = new Date()) {
|
||
const prev = previousShanghaiWeek(anchor);
|
||
return this.generateAllPartnerBills({ weekStartYmd: shanghaiYmd(prev.start) });
|
||
}
|
||
|
||
/** @deprecated 月账任务已改为周账 */
|
||
async generatePreviousMonthPartnerBills(anchor = new Date()) {
|
||
return this.generatePreviousWeekPartnerBills(anchor);
|
||
}
|
||
|
||
async getAdminPartnerBill(id: bigint) {
|
||
const bill = await this.prisma.partnerBill.findUnique({
|
||
where: { id },
|
||
include: { partnerAccount: true, items: { orderBy: { occurredAt: 'asc' } } },
|
||
});
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
const { items, ...header } = bill;
|
||
return serializeBigInt({
|
||
...withShanghaiPeriod(header),
|
||
partnerId: header.partnerAccountId.toString(),
|
||
...splitPartnerBillItems(items),
|
||
});
|
||
}
|
||
|
||
async generatePartnerBill(
|
||
body: { partnerId: string; weekStartYmd: string },
|
||
opts?: { notify?: boolean },
|
||
) {
|
||
const partnerAccountId = BigInt(body.partnerId);
|
||
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
||
const { periodStart, periodEnd, endExclusive } = resolvePartnerWeekPeriod(body.weekStartYmd);
|
||
|
||
const existing = await this.prisma.partnerBill.findFirst({
|
||
where: {
|
||
partnerAccountId: primary.id,
|
||
periodStart: { gte: periodStart, lt: endExclusive },
|
||
},
|
||
});
|
||
if (existing && existing.status !== 'PENDING_REVIEW') {
|
||
throw new BadRequestException('该账期账单已进入审核流程，不可重复生成');
|
||
}
|
||
|
||
if (!primary.cityId) {
|
||
throw new BadRequestException('合伙人未绑定开城城市');
|
||
}
|
||
|
||
const redeemCommissionRate = Number(primary.redeemCommissionRate ?? 0.03);
|
||
|
||
const orders = await this.prisma.order.findMany({
|
||
where: {
|
||
partnerAccountIdAtPay: primary.id,
|
||
payStatus: 'PAID',
|
||
paidAt: { gte: periodStart, lte: periodEnd },
|
||
},
|
||
orderBy: { paidAt: 'asc' },
|
||
});
|
||
const orderRows = orders.map((o) => {
|
||
const rate = o.orderCommissionRateAtPay != null ? Number(o.orderCommissionRateAtPay) : 0;
|
||
const baseAmount = Number(o.payAmount);
|
||
return {
|
||
kind: 'ORDER' as const,
|
||
refId: o.id,
|
||
refNo: o.orderNo,
|
||
title: o.productName,
|
||
extra: `×${o.quantity}`,
|
||
baseAmount,
|
||
rate,
|
||
commission: round2(baseAmount * rate),
|
||
occurredAt: o.paidAt ?? o.createdAt,
|
||
};
|
||
});
|
||
const orderCommission = orderRows.reduce((sum, r) => sum + r.commission, 0);
|
||
|
||
const stores = await this.prisma.store.findMany({
|
||
where: { partnerAccountId: primary.id },
|
||
select: { id: true, name: true },
|
||
});
|
||
const storeIds = stores.map((s) => s.id);
|
||
const storeNameById = new Map(stores.map((s) => [s.id.toString(), s.name]));
|
||
const redeems = !storeIds.length
|
||
? []
|
||
: await this.prisma.redeemRecord.findMany({
|
||
where: {
|
||
storeId: { in: storeIds },
|
||
createdAt: { gte: periodStart, lte: periodEnd },
|
||
},
|
||
orderBy: { createdAt: 'asc' },
|
||
});
|
||
const redeemRows = redeems.map((r) => {
|
||
const baseAmount = Number(r.amount);
|
||
return {
|
||
kind: 'REDEEM' as const,
|
||
refId: r.id,
|
||
refNo: r.redeemNo,
|
||
title: storeNameById.get(r.storeId.toString()) ?? '门店',
|
||
extra: null as string | null,
|
||
baseAmount,
|
||
rate: redeemCommissionRate,
|
||
commission: round2(baseAmount * redeemCommissionRate),
|
||
occurredAt: r.createdAt,
|
||
};
|
||
});
|
||
const redeemCommission = redeemRows.reduce((sum, r) => sum + r.commission, 0);
|
||
|
||
const totalAmount = round2(orderCommission + redeemCommission);
|
||
const itemRows = [...orderRows, ...redeemRows];
|
||
|
||
const bill = await this.prisma.$transaction(async (tx) => {
|
||
const header = existing
|
||
? await tx.partnerBill.update({
|
||
where: { id: existing.id },
|
||
data: {
|
||
orderCommission: round2(orderCommission),
|
||
redeemCommission: round2(redeemCommission),
|
||
totalAmount,
|
||
periodStart,
|
||
periodEnd,
|
||
status: 'PENDING_REVIEW',
|
||
},
|
||
})
|
||
: await tx.partnerBill.create({
|
||
data: {
|
||
billNo: generateBillNo('PB'),
|
||
partnerAccountId: primary.id,
|
||
periodStart,
|
||
periodEnd,
|
||
orderCommission: round2(orderCommission),
|
||
redeemCommission: round2(redeemCommission),
|
||
totalAmount,
|
||
status: 'PENDING_REVIEW',
|
||
},
|
||
});
|
||
|
||
await tx.partnerBillItem.deleteMany({ where: { partnerBillId: header.id } });
|
||
if (itemRows.length > 0) {
|
||
await tx.partnerBillItem.createMany({
|
||
data: itemRows.map((row) => ({
|
||
partnerBillId: header.id,
|
||
kind: row.kind,
|
||
refId: row.refId,
|
||
refNo: row.refNo,
|
||
title: row.title,
|
||
extra: row.extra,
|
||
baseAmount: row.baseAmount,
|
||
rate: new Prisma.Decimal(row.rate.toFixed(4)),
|
||
commission: row.commission,
|
||
occurredAt: row.occurredAt,
|
||
})),
|
||
});
|
||
}
|
||
return header;
|
||
});
|
||
|
||
if (opts?.notify !== false) {
|
||
let cityName = '—';
|
||
if (primary.cityId) {
|
||
const city = await this.prisma.commonCity.findUnique({
|
||
where: { id: primary.cityId },
|
||
select: { name: true },
|
||
});
|
||
cityName = city?.name?.trim() || '—';
|
||
}
|
||
this.notifyPartnerBillDigest(body.weekStartYmd, [
|
||
{
|
||
cityName,
|
||
partnerLabel: formatPartnerDashLabel(primary.companyName, primary.name),
|
||
orderCount: orders.length,
|
||
redeemCount: redeems.length,
|
||
orderCommission: round2(orderCommission),
|
||
redeemCommission: round2(redeemCommission),
|
||
amount: totalAmount,
|
||
bank: {
|
||
bankAccountName: primary.bankAccountName,
|
||
bankBranch: primary.bankBranch,
|
||
bankAccountNo: primary.bankAccountNo,
|
||
},
|
||
},
|
||
]);
|
||
}
|
||
|
||
return serializeBigInt({
|
||
...bill,
|
||
orderCount: orders.length,
|
||
redeemCount: redeems.length,
|
||
});
|
||
}
|
||
|
||
/** HQ：发送给合伙人（待审核 → 待合伙人确认） */
|
||
async sendPartnerBill(id: bigint) {
|
||
const bill = await this.prisma.partnerBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
if (Number(bill.totalAmount) <= 0) {
|
||
throw new BadRequestException('零元账单不同步给合伙人');
|
||
}
|
||
if (bill.status !== 'PENDING_REVIEW' && bill.status !== 'REJECTED') {
|
||
throw new BadRequestException('仅待审核或已驳回账单可发送');
|
||
}
|
||
const updated = await this.prisma.partnerBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'AWAITING_CONFIRM',
|
||
sentAt: new Date(),
|
||
rejectReason: null,
|
||
},
|
||
});
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchSendPartnerBills(ids: string[]) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.sendPartnerBill(BigInt(id));
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
/** @deprecated HQ 代确认：待审核/待确认 → 未打款 */
|
||
async confirmPartnerBill(id: bigint) {
|
||
const bill = await this.prisma.partnerBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
if (bill.status !== 'PENDING_REVIEW' && bill.status !== 'AWAITING_CONFIRM' && bill.status !== 'REJECTED') {
|
||
throw new BadRequestException('当前状态不可确认');
|
||
}
|
||
const updated = await this.prisma.partnerBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'UNPAID',
|
||
confirmedAt: new Date(),
|
||
sentAt: bill.sentAt ?? new Date(),
|
||
rejectReason: null,
|
||
},
|
||
});
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
/** 合伙人确认：待合伙人确认 → 未打款 */
|
||
async partnerConfirmBill(partnerAccountId: bigint, billId: bigint) {
|
||
const primary = await this.partnerCityService.resolvePrimaryAccount(partnerAccountId);
|
||
const bill = await this.prisma.partnerBill.findUnique({ where: { id: billId } });
|
||
if (!bill || bill.partnerAccountId !== primary.id) {
|
||
throw new NotFoundException('账单不存在');
|
||
}
|
||
if (bill.status !== 'AWAITING_CONFIRM') {
|
||
throw new BadRequestException('当前账单不可确认');
|
||
}
|
||
|
||
const updated = await this.prisma.partnerBill.update({
|
||
where: { id: billId },
|
||
data: {
|
||
status: 'UNPAID',
|
||
confirmedAt: new Date(),
|
||
rejectReason: null,
|
||
},
|
||
});
|
||
|
||
this.analyticsService.trackPartnerOneSafe(partnerAccountId, 'PARTNER_H5', {
|
||
partnerAccountId: primary.id,
|
||
eventName: 'partner_bill_confirm',
|
||
refType: 'PARTNER_BILL',
|
||
refId: billId,
|
||
extraJson: { billNo: bill.billNo },
|
||
});
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchPartnerConfirmBills(partnerAccountId: bigint, ids: string[]) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.partnerConfirmBill(partnerAccountId, BigInt(id));
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async rejectPartnerBill(id: bigint, reason: string) {
|
||
const rejectReason = reason.trim();
|
||
if (!rejectReason) throw new BadRequestException('请填写驳回理由');
|
||
if (rejectReason.length > 500) throw new BadRequestException('驳回理由不能超过 500 字');
|
||
|
||
const bill = await this.prisma.partnerBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
if (bill.status !== 'AWAITING_CONFIRM' && bill.status !== 'UNPAID') {
|
||
throw new BadRequestException('仅待合伙人确认或未打款账单可驳回');
|
||
}
|
||
|
||
const updated = await this.prisma.partnerBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'REJECTED',
|
||
rejectReason,
|
||
},
|
||
});
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async markPartnerBillPaid(id: bigint, dto: { paymentRef?: string } = {}) {
|
||
const bill = await this.prisma.partnerBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('账单不存在');
|
||
if (bill.status !== 'UNPAID') throw new BadRequestException('仅未打款账单可标记打款');
|
||
|
||
const updated = await this.prisma.partnerBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'PAID',
|
||
paidAt: new Date(),
|
||
rejectReason: null,
|
||
paymentRef: dto.paymentRef?.trim() || null,
|
||
},
|
||
});
|
||
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchMarkPartnerBillsPaid(ids: string[]) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.markPartnerBillPaid(BigInt(id));
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async exportPartnerBills(query: {
|
||
partnerId?: string;
|
||
status?: string;
|
||
year?: number;
|
||
month?: number;
|
||
weekStartYmd?: string;
|
||
}) {
|
||
const where = this.buildPartnerBillWhere(query);
|
||
const bills = await this.prisma.partnerBill.findMany({
|
||
where,
|
||
include: {
|
||
partnerAccount: {
|
||
select: {
|
||
companyName: true,
|
||
phone: true,
|
||
bankAccountName: true,
|
||
bankAccountNo: true,
|
||
bankBranch: true,
|
||
},
|
||
},
|
||
items: { orderBy: { occurredAt: 'asc' } },
|
||
},
|
||
orderBy: { periodStart: 'desc' },
|
||
});
|
||
|
||
const header = [
|
||
'账单号',
|
||
'合伙人',
|
||
'登录手机',
|
||
'账期起',
|
||
'账期止',
|
||
'酒单佣金',
|
||
'核销佣金',
|
||
'合计应付',
|
||
'状态',
|
||
'发送时间',
|
||
'确认时间',
|
||
'打款时间',
|
||
'打款凭证',
|
||
'收款户名',
|
||
'收款账号',
|
||
'开户行',
|
||
'驳回理由',
|
||
].join(',');
|
||
const rows = bills.map((b) =>
|
||
[
|
||
csvEscape(b.billNo),
|
||
csvEscape(b.partnerAccount.companyName ?? ''),
|
||
csvEscape(b.partnerAccount.phone ?? ''),
|
||
shanghaiBillPeriodYmds(b.periodStart, b.periodEnd).periodStart,
|
||
shanghaiBillPeriodYmds(b.periodStart, b.periodEnd).periodEnd,
|
||
Number(b.orderCommission),
|
||
Number(b.redeemCommission),
|
||
Number(b.totalAmount),
|
||
b.status,
|
||
b.sentAt ? shanghaiYmd(b.sentAt) : '',
|
||
b.confirmedAt ? shanghaiYmd(b.confirmedAt) : '',
|
||
b.paidAt ? shanghaiYmd(b.paidAt) : '',
|
||
csvEscape(b.paymentRef ?? ''),
|
||
csvEscape(b.partnerAccount.bankAccountName ?? ''),
|
||
csvEscape(b.partnerAccount.bankAccountNo ?? ''),
|
||
csvEscape(b.partnerAccount.bankBranch ?? ''),
|
||
csvEscape(b.rejectReason ?? ''),
|
||
].join(','),
|
||
);
|
||
|
||
const itemHeader = ['账单号', '类型', '单号', '标题', '备注', '基数', '费率', '佣金', '发生时间'].join(',');
|
||
const itemRows = bills.flatMap((b) =>
|
||
b.items.map((it) =>
|
||
[
|
||
csvEscape(b.billNo),
|
||
it.kind === 'ORDER' ? '酒订单' : '核销',
|
||
csvEscape(it.refNo),
|
||
csvEscape(it.title ?? ''),
|
||
csvEscape(it.extra ?? ''),
|
||
Number(it.baseAmount),
|
||
Number(it.rate),
|
||
Number(it.commission),
|
||
it.occurredAt.toISOString().slice(0, 19).replace('T', ' '),
|
||
].join(','),
|
||
),
|
||
);
|
||
const csv = ['账单汇总', header, ...rows, '', '酒订单/核销明细', itemHeader, ...itemRows].join('\n');
|
||
return { csv: `\uFEFF${csv}`, count: bills.length };
|
||
}
|
||
|
||
// ─── Winery bills ────────────────────────────────────
|
||
|
||
/** 酒厂账单纳入的配送类型：同城 / 跨城 / 现场提货 */
|
||
private static readonly WINERY_DELIVERY_TYPES = ['LOCAL', 'CROSS_CITY', 'ON_SITE_PICKUP'] as const;
|
||
|
||
/**
|
||
* 历史现场提货单支付即 COMPLETED 但未写 completedAt，补齐为 paidAt，否则核对补生成捞不到。
|
||
*/
|
||
private async backfillMissingCompletedAt() {
|
||
await this.prisma.$executeRaw`
|
||
UPDATE user_order
|
||
SET completed_at = paid_at
|
||
WHERE status = 'COMPLETED'
|
||
AND pay_status = 'PAID'
|
||
AND completed_at IS NULL
|
||
AND paid_at IS NOT NULL
|
||
`;
|
||
}
|
||
|
||
/** 期窗口内已付已完成订单（含同城/跨城/现场提货；completedAt 优先，缺省用 paidAt） */
|
||
private wineryEligibleOrderWhere(start: Date, end: Date): Prisma.OrderWhereInput {
|
||
return {
|
||
status: 'COMPLETED',
|
||
payStatus: 'PAID',
|
||
deliveryType: { in: [...SettlementService.WINERY_DELIVERY_TYPES] },
|
||
OR: [
|
||
{ completedAt: { gte: start, lt: end } },
|
||
{ completedAt: null, paidAt: { gte: start, lt: end } },
|
||
],
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 生成/重算某一出账日的酒厂对账单（T+3 = 每 3 天出一期）。
|
||
* - 仅在周期出账日生成：相对 epoch 每 3 天一张
|
||
* - 纳入上一期 3 个自然日内完成的同城/跨城/现场提货已付订单（含实付/应付为 0）
|
||
* - 出账日无订单也出账（无需打款），保证每隔三天有账单
|
||
* - 已打款账单不回刷；未打款账单可重算；冲突明细从其他未打款账单迁入
|
||
*/
|
||
async generateWineryBillForDay(anchor = new Date(), opts?: { notify?: boolean }) {
|
||
const periodDays = WINERY_SETTLEMENT_PERIOD_DAYS;
|
||
const epochYmd = WINERY_BILL_EPOCH_YMD;
|
||
const billDate = startOfShanghaiDay(anchor);
|
||
const issueYmd = shanghaiYmd(billDate);
|
||
const today = startOfShanghaiDay(new Date());
|
||
if (billDate.getTime() > today.getTime()) {
|
||
return { billDate: issueYmd, skipped: true, reason: '出账日未到' };
|
||
}
|
||
if (!isWineryIssueDay(billDate, periodDays, epochYmd)) {
|
||
return { billDate: issueYmd, skipped: true, reason: '非出账周期日（T+3 每 3 天出账）' };
|
||
}
|
||
|
||
const { start, end } = shanghaiWineryPeriodWindow(billDate, periodDays);
|
||
const rate = WINERY_SETTLEMENT_RATE;
|
||
|
||
const existing =
|
||
(await this.prisma.wineryBill.findUnique({ where: { billDate } })) ??
|
||
(await this.prisma.wineryBill.findFirst({
|
||
where: { createdAt: { gte: billDate, lt: addShanghaiDays(billDate, 1) } },
|
||
}));
|
||
if (existing?.status === 'PAID') {
|
||
return { billDate: issueYmd, skipped: true, reason: '已打款' };
|
||
}
|
||
|
||
// 手工单日出账时也补齐缺 completedAt 的现场单
|
||
await this.backfillMissingCompletedAt();
|
||
|
||
// 期窗口 [出账日−3, 出账日) 内：同城 / 跨城 / 现场提货
|
||
const candidates = await this.prisma.order.findMany({
|
||
where: this.wineryEligibleOrderWhere(start, end),
|
||
include: { city: { select: { name: true } } },
|
||
orderBy: [{ completedAt: 'asc' }, { paidAt: 'asc' }],
|
||
});
|
||
|
||
// 已打款账单上的明细不可再迁；其余订单一律纳入本账
|
||
const candidateIds = candidates.map((o) => o.id);
|
||
const paidLockedIds = new Set<string>();
|
||
if (candidateIds.length) {
|
||
const locked = await this.prisma.wineryBillItem.findMany({
|
||
where: {
|
||
orderId: { in: candidateIds },
|
||
wineryBill: { status: 'PAID' },
|
||
...(existing ? { wineryBillId: { not: existing.id } } : {}),
|
||
},
|
||
select: { orderId: true },
|
||
});
|
||
for (const row of locked) paidLockedIds.add(row.orderId.toString());
|
||
}
|
||
const orders = candidates.filter((o) => !paidLockedIds.has(o.id.toString()));
|
||
|
||
const orderAmount = round2(orders.reduce((s, o) => s + Number(o.payAmount), 0));
|
||
const wineryAmount = round2(orderAmount * rate);
|
||
|
||
const bill = await this.prisma.$transaction(async (tx) => {
|
||
const header = existing
|
||
? await tx.wineryBill.update({
|
||
where: { id: existing.id },
|
||
data: {
|
||
billDate,
|
||
orderCount: orders.length,
|
||
orderAmount,
|
||
wineryRate: rate,
|
||
wineryAmount,
|
||
},
|
||
})
|
||
: await tx.wineryBill.create({
|
||
data: {
|
||
billNo: generateBillNo('WB'),
|
||
billDate,
|
||
orderCount: orders.length,
|
||
orderAmount,
|
||
wineryRate: rate,
|
||
wineryAmount,
|
||
status: 'UNPAID',
|
||
},
|
||
});
|
||
|
||
if (existing) {
|
||
await tx.wineryBillItem.deleteMany({ where: { wineryBillId: header.id } });
|
||
}
|
||
|
||
// 从未打款的其他账单迁出冲突明细，避免 orderId 唯一约束失败导致整日对不上
|
||
const affectedBillIds = new Set<bigint>();
|
||
if (orders.length > 0) {
|
||
const conflicts = await tx.wineryBillItem.findMany({
|
||
where: {
|
||
orderId: { in: orders.map((o) => o.id) },
|
||
wineryBillId: { not: header.id },
|
||
wineryBill: { status: 'UNPAID' },
|
||
},
|
||
select: { id: true, wineryBillId: true },
|
||
});
|
||
for (const c of conflicts) affectedBillIds.add(c.wineryBillId);
|
||
if (conflicts.length) {
|
||
await tx.wineryBillItem.deleteMany({ where: { id: { in: conflicts.map((c) => c.id) } } });
|
||
}
|
||
|
||
await tx.wineryBillItem.createMany({
|
||
data: orders.map((o) => ({
|
||
wineryBillId: header.id,
|
||
orderId: o.id,
|
||
orderNo: o.orderNo,
|
||
deliveryType: o.deliveryType,
|
||
payAmount: o.payAmount,
|
||
wineryAmount: round2(Number(o.payAmount) * rate),
|
||
// 明细时间：支付时间优先；账期归属用 completedAt（现场提货已与支付同时写入）
|
||
paidAt: o.paidAt ?? o.completedAt!,
|
||
})),
|
||
});
|
||
}
|
||
|
||
for (const otherId of affectedBillIds) {
|
||
await this.recalcWineryBillHeader(tx, otherId, rate);
|
||
}
|
||
|
||
return header;
|
||
});
|
||
|
||
const period = issueYmd;
|
||
if (opts?.notify !== false && wineryAmount > 0) {
|
||
const wineryBank = await loadWineryBankConfig(this.prisma);
|
||
const bankParts = wecomBankParts(wineryBank);
|
||
const cityNames = joinLimited(
|
||
orders.map((o) => o.city?.name || ''),
|
||
'城',
|
||
);
|
||
const partnerNames = await this.partnerDashLabels(orders.map((o) => o.partnerAccountIdAtPay));
|
||
void this.wecomPush.dispatchEvent(
|
||
'finance.winery_bill',
|
||
{
|
||
period,
|
||
billCount: '1',
|
||
totalAmount: wineryAmount.toFixed(2),
|
||
cityNames,
|
||
partnerNames,
|
||
orderCount: String(orders.length),
|
||
orderAmount: orderAmount.toFixed(2),
|
||
rate: formatPercent(rate),
|
||
amount: wineryAmount.toFixed(2),
|
||
payee: bankParts.payee,
|
||
accountNo: bankParts.accountNo,
|
||
bankBranch: bankParts.bankBranch,
|
||
bankAccount: formatWecomBankAccount(wineryBank),
|
||
},
|
||
{ handlePath: '/finance/winery-bills' },
|
||
);
|
||
}
|
||
|
||
return serializeBigInt({
|
||
billDate: period,
|
||
skipped: false,
|
||
bill,
|
||
orderCount: orders.length,
|
||
orderAmount,
|
||
wineryAmount,
|
||
lockedOnPaid: paidLockedIds.size,
|
||
});
|
||
}
|
||
|
||
/** 按明细重算酒厂账单表头（应付为 0 保留账单，展示为无需打款） */
|
||
private async recalcWineryBillHeader(
|
||
tx: Prisma.TransactionClient,
|
||
wineryBillId: bigint,
|
||
rate = WINERY_SETTLEMENT_RATE,
|
||
) {
|
||
const items = await tx.wineryBillItem.findMany({ where: { wineryBillId } });
|
||
const orderAmount = round2(items.reduce((s, i) => s + Number(i.payAmount), 0));
|
||
const wineryAmount = round2(orderAmount * rate);
|
||
await tx.wineryBill.update({
|
||
where: { id: wineryBillId },
|
||
data: {
|
||
orderCount: items.length,
|
||
orderAmount,
|
||
wineryRate: rate,
|
||
wineryAmount,
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 按出账日区间核对补生成酒厂账单：只处理 T+3 周期出账日，捞回未入账的同城/跨城/现场提货订单，并清理误生成的非周期日空账单。
|
||
*/
|
||
async reconcileWineryBills(body?: { dateFrom?: string; dateTo?: string }) {
|
||
const periodDays = WINERY_SETTLEMENT_PERIOD_DAYS;
|
||
const epochYmd = WINERY_BILL_EPOCH_YMD;
|
||
const today = startOfShanghaiDay(new Date());
|
||
const to = body?.dateTo ? parseShanghaiYmd(body.dateTo) : today;
|
||
const from = body?.dateFrom
|
||
? parseShanghaiYmd(body.dateFrom)
|
||
: addShanghaiDays(today, -60);
|
||
if (Number.isNaN(from.getTime()) || Number.isNaN(to.getTime())) {
|
||
throw new BadRequestException('日期格式无效，请使用 YYYY-MM-DD');
|
||
}
|
||
if (from.getTime() > to.getTime()) {
|
||
throw new BadRequestException('开始日期不能晚于结束日期');
|
||
}
|
||
|
||
// 先补历史现场提货等缺 completedAt 的已完成单，再按期入账
|
||
await this.backfillMissingCompletedAt();
|
||
|
||
const endIssue = to.getTime() > today.getTime() ? today : to;
|
||
const startIssue = from.getTime() > endIssue.getTime() ? endIssue : from;
|
||
|
||
const issueYmids = new Set(
|
||
listWineryIssueDays(startIssue, endIssue, periodDays, epochYmd).map(shanghaiYmd),
|
||
);
|
||
|
||
// 捞仍未入账的孤儿订单（同城/跨城/现场提货），按其完成日归属到对应出账日
|
||
const orphanLookbackStart = addShanghaiDays(startIssue, -periodDays - 90);
|
||
const orphanLookbackEnd = addShanghaiDays(today, 1);
|
||
const windowOrders = await this.prisma.order.findMany({
|
||
where: this.wineryEligibleOrderWhere(orphanLookbackStart, orphanLookbackEnd),
|
||
select: { id: true, completedAt: true, paidAt: true },
|
||
});
|
||
const billedSet = new Set(
|
||
windowOrders.length === 0
|
||
? []
|
||
: (
|
||
await this.prisma.wineryBillItem.findMany({
|
||
where: { orderId: { in: windowOrders.map((o) => o.id) } },
|
||
select: { orderId: true },
|
||
})
|
||
).map((r) => r.orderId.toString()),
|
||
);
|
||
|
||
let orphanCount = 0;
|
||
for (const o of windowOrders) {
|
||
const attributedAt = o.completedAt ?? o.paidAt;
|
||
if (!attributedAt || billedSet.has(o.id.toString())) continue;
|
||
const issue = wineryIssueDateFromCompletedAt(attributedAt, periodDays, epochYmd);
|
||
if (issue.getTime() > today.getTime()) continue;
|
||
issueYmids.add(shanghaiYmd(issue));
|
||
orphanCount += 1;
|
||
}
|
||
|
||
const sorted = [...issueYmids].sort();
|
||
const results: Array<{
|
||
billDate: string;
|
||
skipped: boolean;
|
||
reason?: string;
|
||
orderCount?: number;
|
||
wineryAmount?: number;
|
||
}> = [];
|
||
|
||
for (const ymd of sorted) {
|
||
const r = await this.generateWineryBillForDay(parseShanghaiYmd(ymd), { notify: false });
|
||
results.push({
|
||
billDate: String(r.billDate),
|
||
skipped: Boolean(r.skipped),
|
||
reason: 'reason' in r ? String(r.reason ?? '') : undefined,
|
||
orderCount: 'orderCount' in r ? Number(r.orderCount ?? 0) : undefined,
|
||
wineryAmount: 'wineryAmount' in r ? Number(r.wineryAmount ?? 0) : undefined,
|
||
});
|
||
}
|
||
|
||
// 清理旧「每日出账」留下的非周期日出账单（明细已迁走后为空）
|
||
let cleaned = 0;
|
||
const strayBills = await this.prisma.wineryBill.findMany({
|
||
where: {
|
||
status: 'UNPAID',
|
||
billDate: { gte: startIssue, lte: endIssue },
|
||
},
|
||
include: { _count: { select: { items: true } } },
|
||
});
|
||
for (const b of strayBills) {
|
||
if (isWineryIssueDay(b.billDate, periodDays, epochYmd)) continue;
|
||
if (b._count.items > 0) {
|
||
await this.prisma.$transaction(async (tx) => {
|
||
await this.recalcWineryBillHeader(tx, b.id);
|
||
});
|
||
continue;
|
||
}
|
||
await this.prisma.wineryBill.delete({ where: { id: b.id } });
|
||
cleaned += 1;
|
||
}
|
||
|
||
return {
|
||
dateFrom: shanghaiYmd(startIssue),
|
||
dateTo: shanghaiYmd(endIssue),
|
||
days: results.length,
|
||
generated: results.filter((r) => !r.skipped).length,
|
||
skipped: results.filter((r) => r.skipped).length,
|
||
orphanOrders: orphanCount,
|
||
cleanedNonIssueBills: cleaned,
|
||
results,
|
||
};
|
||
}
|
||
|
||
async listAdminWineryBills(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where = this.buildWineryBillWhere(query);
|
||
|
||
const [items, total, aggregates] = await Promise.all([
|
||
this.prisma.wineryBill.findMany({
|
||
where,
|
||
orderBy: { billDate: 'desc' },
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
}),
|
||
this.prisma.wineryBill.count({ where }),
|
||
this.prisma.wineryBill.aggregate({
|
||
where,
|
||
_sum: { orderAmount: true, wineryAmount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const summary = {
|
||
count: aggregates._count,
|
||
orderAmount: Number(aggregates._sum.orderAmount ?? 0),
|
||
wineryAmount: Number(aggregates._sum.wineryAmount ?? 0),
|
||
totalAmount: Number(aggregates._sum.wineryAmount ?? 0),
|
||
};
|
||
|
||
return serializeBigInt({
|
||
items: items.map((b) => ({ ...b, billDate: shanghaiYmd(b.billDate) })),
|
||
total,
|
||
page,
|
||
pageSize,
|
||
summary,
|
||
});
|
||
}
|
||
|
||
async getAdminWineryBill(id: bigint) {
|
||
const bill = await this.prisma.wineryBill.findUnique({
|
||
where: { id },
|
||
include: { items: { orderBy: { paidAt: 'desc' } } },
|
||
});
|
||
if (!bill) throw new NotFoundException('酒厂对账单不存在');
|
||
const wineryBank = await loadWineryBankConfig(this.prisma);
|
||
return serializeBigInt({ ...bill, billDate: shanghaiYmd(bill.billDate), wineryBank });
|
||
}
|
||
|
||
async confirmWineryBill(id: bigint, dto: { paymentRef?: string } = {}) {
|
||
const bill = await this.prisma.wineryBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('酒厂对账单不存在');
|
||
if (bill.status !== 'UNPAID') throw new BadRequestException('仅未打款账单可确认打款');
|
||
if (Number(bill.wineryAmount) === 0) {
|
||
throw new BadRequestException('应付为 0，无需打款');
|
||
}
|
||
const updated = await this.prisma.wineryBill.update({
|
||
where: { id },
|
||
data: {
|
||
status: 'PAID',
|
||
paidAt: new Date(),
|
||
paymentRef: dto.paymentRef?.trim() || null,
|
||
},
|
||
});
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchConfirmWineryBills(ids: string[]) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.confirmWineryBill(BigInt(id));
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async exportAdminWineryBills(query: {
|
||
status?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}) {
|
||
const where = this.buildWineryBillWhere(query);
|
||
const bills = await this.prisma.wineryBill.findMany({
|
||
where,
|
||
include: { items: true },
|
||
orderBy: { billDate: 'desc' },
|
||
});
|
||
const wineryBank = await loadWineryBankConfig(this.prisma);
|
||
|
||
const header = [
|
||
'账单号',
|
||
'账单日',
|
||
'订单号',
|
||
'配送类型',
|
||
'实付金额',
|
||
'酒厂比例',
|
||
'应付',
|
||
'支付时间',
|
||
'账单状态',
|
||
'打款凭证',
|
||
'收款户名',
|
||
'开户银行',
|
||
'开户支行',
|
||
'收款账号',
|
||
].join(',');
|
||
const rows: string[] = [];
|
||
const statusLabel = (b: { status: string; wineryAmount: Prisma.Decimal | number }) => {
|
||
if (Number(b.wineryAmount) === 0) return '无需打款';
|
||
if (b.status === 'PAID') return '已打款';
|
||
if (b.status === 'UNPAID') return '未打款';
|
||
return b.status;
|
||
};
|
||
const bankCols = (b: { paymentRef?: string | null }) => [
|
||
csvEscape(b.paymentRef ?? ''),
|
||
csvEscape(wineryBank.bankAccountName ?? ''),
|
||
csvEscape(wineryBank.bankName ?? ''),
|
||
csvEscape(wineryBank.bankBranch ?? ''),
|
||
csvEscape(wineryBank.bankAccountNo ?? ''),
|
||
];
|
||
for (const b of bills) {
|
||
if (b.items.length === 0) {
|
||
rows.push(
|
||
[
|
||
csvEscape(b.billNo),
|
||
shanghaiYmd(b.billDate),
|
||
'',
|
||
'',
|
||
Number(b.orderAmount),
|
||
Number(b.wineryRate),
|
||
Number(b.wineryAmount),
|
||
'',
|
||
statusLabel(b),
|
||
...bankCols(b),
|
||
].join(','),
|
||
);
|
||
continue;
|
||
}
|
||
for (const item of b.items) {
|
||
rows.push(
|
||
[
|
||
csvEscape(b.billNo),
|
||
shanghaiYmd(b.billDate),
|
||
csvEscape(item.orderNo),
|
||
item.deliveryType === 'LOCAL'
|
||
? '同城'
|
||
: item.deliveryType === 'CROSS_CITY'
|
||
? '跨城'
|
||
: item.deliveryType === 'ON_SITE_PICKUP'
|
||
? '现场提货'
|
||
: item.deliveryType,
|
||
Number(item.payAmount),
|
||
Number(b.wineryRate),
|
||
Number(item.wineryAmount),
|
||
item.paidAt.toISOString().slice(0, 19).replace('T', ' '),
|
||
statusLabel(b),
|
||
...bankCols(b),
|
||
].join(','),
|
||
);
|
||
}
|
||
}
|
||
return { csv: `\uFEFF${[header, ...rows].join('\n')}`, count: rows.length };
|
||
}
|
||
|
||
private buildWineryBillWhere(query: {
|
||
status?: string;
|
||
dateFrom?: string;
|
||
dateTo?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}): Prisma.WineryBillWhereInput {
|
||
const where: Prisma.WineryBillWhereInput = {};
|
||
if (query.status === 'NO_PAYMENT_NEEDED') {
|
||
where.wineryAmount = 0;
|
||
} else if (query.status === 'UNPAID') {
|
||
where.status = 'UNPAID';
|
||
where.wineryAmount = { gt: 0 };
|
||
} else if (query.status === 'PAID') {
|
||
where.status = 'PAID';
|
||
where.wineryAmount = { gt: 0 };
|
||
}
|
||
if (query.year && query.month) {
|
||
const { start, endExclusive } = shanghaiMonthRange(query.year, query.month);
|
||
where.billDate = { gte: start, lt: endExclusive };
|
||
} else if (query.dateFrom || query.dateTo) {
|
||
where.billDate = {};
|
||
if (query.dateFrom) where.billDate.gte = parseShanghaiYmd(query.dateFrom);
|
||
if (query.dateTo) where.billDate.lte = parseShanghaiYmd(query.dateTo);
|
||
}
|
||
return where;
|
||
}
|
||
|
||
// ─── Logistics bills (按承运商月结) ───────────────────
|
||
|
||
async generatePreviousMonthLogisticsBills(anchor = new Date()) {
|
||
const prev = previousShanghaiMonth(anchor);
|
||
return this.generateAllLogisticsBills({
|
||
year: prev.year,
|
||
month: prev.month,
|
||
});
|
||
}
|
||
|
||
async generateAllLogisticsBills(body: { year: number; month: number }) {
|
||
const providers = await this.prisma.fulfillmentProvider.findMany({
|
||
where: { status: 'ACTIVE' },
|
||
orderBy: { code: 'asc' },
|
||
});
|
||
const results: Array<{
|
||
providerId: string;
|
||
providerCode: string;
|
||
providerName: string;
|
||
ok: boolean;
|
||
skipped?: boolean;
|
||
message?: string;
|
||
billId?: string;
|
||
}> = [];
|
||
const created: Array<{
|
||
cityNames: string;
|
||
partnerNames: string;
|
||
providerName: string;
|
||
settlementMethod: string;
|
||
orderCount: number;
|
||
bottleCount: number;
|
||
amount: number;
|
||
bank?: WecomBankLike | null;
|
||
}> = [];
|
||
|
||
for (const p of providers) {
|
||
try {
|
||
const bill = await this.generateLogisticsBill(
|
||
{
|
||
providerId: p.id.toString(),
|
||
year: body.year,
|
||
month: body.month,
|
||
},
|
||
{ notify: false },
|
||
);
|
||
results.push({
|
||
providerId: p.id.toString(),
|
||
providerCode: p.code,
|
||
providerName: p.name,
|
||
ok: true,
|
||
skipped: Boolean(bill.skipped),
|
||
message: bill.reason,
|
||
billId:
|
||
bill.bill?.id != null
|
||
? typeof bill.bill.id === 'string'
|
||
? bill.bill.id
|
||
: String(bill.bill.id)
|
||
: undefined,
|
||
});
|
||
if (!bill.skipped && bill.wecom) {
|
||
created.push(bill.wecom);
|
||
}
|
||
} catch (e) {
|
||
results.push({
|
||
providerId: p.id.toString(),
|
||
providerCode: p.code,
|
||
providerName: p.name,
|
||
ok: false,
|
||
message: e instanceof Error ? e.message : '失败',
|
||
});
|
||
}
|
||
}
|
||
|
||
this.notifyLogisticsBillDigest(
|
||
`${body.year}-${String(body.month).padStart(2, '0')}`,
|
||
created,
|
||
);
|
||
|
||
return {
|
||
total: providers.length,
|
||
success: results.filter((r) => r.ok).length,
|
||
failed: results.filter((r) => !r.ok).length,
|
||
results,
|
||
};
|
||
}
|
||
|
||
private async partnerDashLabels(ids: Array<bigint | null | undefined>, max = 5): Promise<string> {
|
||
const uniq = [...new Set(ids.filter((id): id is bigint => id != null))];
|
||
if (!uniq.length) return '—';
|
||
const partners = await this.prisma.partnerAccount.findMany({
|
||
where: { id: { in: uniq } },
|
||
select: { name: true, companyName: true },
|
||
});
|
||
return joinLimited(
|
||
partners.map((p) => formatPartnerDashLabel(p.companyName, p.name)),
|
||
'家',
|
||
max,
|
||
);
|
||
}
|
||
|
||
async generateLogisticsBill(
|
||
body: { providerId: string; year: number; month: number },
|
||
opts?: { notify?: boolean },
|
||
) {
|
||
const fulfillmentProviderId = BigInt(body.providerId);
|
||
const provider = await this.prisma.fulfillmentProvider.findUnique({
|
||
where: { id: fulfillmentProviderId },
|
||
});
|
||
if (!provider) throw new NotFoundException('仓配承运商不存在');
|
||
|
||
const { start: periodStart, endExclusive } = shanghaiMonthRange(body.year, body.month);
|
||
const periodEnd = shanghaiMonthLastInstant(body.year, body.month);
|
||
|
||
const existing = await this.prisma.logisticsBill.findFirst({
|
||
where: {
|
||
fulfillmentProviderId,
|
||
periodStart: { gte: periodStart, lt: endExclusive },
|
||
},
|
||
});
|
||
if (existing?.status === 'PAID') {
|
||
return {
|
||
skipped: true,
|
||
reason: '该月账单已结算',
|
||
bill: serializeBigInt(existing),
|
||
};
|
||
}
|
||
|
||
const pricing =
|
||
this.fulfillmentProviderService.parsePricingRules(provider.pricingRulesJson) ??
|
||
(provider.code.toUpperCase() === 'XFX' || provider.code.toUpperCase() === 'XIAOFEIXIA'
|
||
? { ...DEFAULT_XFX_LOGISTICS_PRICING }
|
||
: null);
|
||
if (!pricing) {
|
||
throw new BadRequestException(`承运商 ${provider.name} 未配置计价标准`);
|
||
}
|
||
|
||
const deliveries = await this.prisma.orderDelivery.findMany({
|
||
where: {
|
||
fulfillmentProviderId,
|
||
OR: [
|
||
{ shippingAt: { gte: periodStart, lte: periodEnd } },
|
||
{
|
||
shippingAt: null,
|
||
outWarehouseAt: { gte: periodStart, lte: periodEnd },
|
||
},
|
||
],
|
||
},
|
||
include: {
|
||
order: {
|
||
select: {
|
||
id: true,
|
||
orderNo: true,
|
||
quantity: true,
|
||
deliveryType: true,
|
||
payStatus: true,
|
||
partnerAccountIdAtPay: true,
|
||
city: { select: { name: true } },
|
||
},
|
||
},
|
||
},
|
||
orderBy: [{ shippingAt: 'asc' }, { outWarehouseAt: 'asc' }],
|
||
});
|
||
|
||
const eligible = deliveries.filter(
|
||
(d) =>
|
||
d.order.payStatus === 'PAID' &&
|
||
(d.order.deliveryType === 'LOCAL' || d.order.deliveryType === 'CROSS_CITY'),
|
||
);
|
||
|
||
if (eligible.length === 0 && !existing) {
|
||
return { skipped: true, reason: '无发货订单', bill: null };
|
||
}
|
||
|
||
const items = eligible.map((d) => {
|
||
const qty = d.order.quantity;
|
||
const fee = calcLogisticsFeeByBottles(qty, pricing as LogisticsPricingRule);
|
||
const shippedAt = d.shippingAt ?? d.outWarehouseAt ?? periodStart;
|
||
return {
|
||
orderId: d.order.id,
|
||
orderNo: d.order.orderNo,
|
||
quantity: qty,
|
||
logisticsAmount: fee,
|
||
shippedAt,
|
||
};
|
||
});
|
||
|
||
const orderCount = items.length;
|
||
const bottleCount = items.reduce((s, i) => s + i.quantity, 0);
|
||
const logisticsAmount = round2(items.reduce((s, i) => s + i.logisticsAmount, 0));
|
||
const settlementMethod = provider.settlementMethod;
|
||
const pricingSnapshotJson = JSON.stringify(pricing);
|
||
|
||
const bill = await this.prisma.$transaction(async (tx) => {
|
||
const header = existing
|
||
? await tx.logisticsBill.update({
|
||
where: { id: existing.id },
|
||
data: {
|
||
periodStart,
|
||
periodEnd,
|
||
orderCount,
|
||
bottleCount,
|
||
logisticsAmount,
|
||
settlementMethod,
|
||
pricingSnapshotJson,
|
||
status: 'UNPAID',
|
||
paidAt: null,
|
||
},
|
||
})
|
||
: await tx.logisticsBill.create({
|
||
data: {
|
||
billNo: generateBillNo('LB'),
|
||
fulfillmentProviderId,
|
||
periodStart,
|
||
periodEnd,
|
||
orderCount,
|
||
bottleCount,
|
||
logisticsAmount,
|
||
settlementMethod,
|
||
pricingSnapshotJson,
|
||
status: 'UNPAID',
|
||
},
|
||
});
|
||
|
||
if (existing) {
|
||
await tx.logisticsBillItem.deleteMany({ where: { logisticsBillId: header.id } });
|
||
}
|
||
|
||
if (items.length > 0) {
|
||
await tx.logisticsBillItem.createMany({
|
||
data: items.map((i) => ({
|
||
logisticsBillId: header.id,
|
||
orderId: i.orderId,
|
||
orderNo: i.orderNo,
|
||
quantity: i.quantity,
|
||
logisticsAmount: i.logisticsAmount,
|
||
shippedAt: i.shippedAt,
|
||
})),
|
||
});
|
||
}
|
||
|
||
// 充值模式：余额充足则自动扣款并标记已结算
|
||
if (settlementMethod === 'PREPAID' && logisticsAmount > 0) {
|
||
const deducted = await this.fulfillmentProviderService.deductPrepaid(
|
||
fulfillmentProviderId,
|
||
logisticsAmount,
|
||
header.id,
|
||
tx,
|
||
);
|
||
if (deducted.ok) {
|
||
return tx.logisticsBill.update({
|
||
where: { id: header.id },
|
||
data: { status: 'PAID', paidAt: new Date() },
|
||
});
|
||
}
|
||
}
|
||
|
||
return header;
|
||
});
|
||
|
||
const wecom = {
|
||
cityNames: joinLimited(
|
||
eligible.map((d) => d.order.city?.name || ''),
|
||
'城',
|
||
),
|
||
partnerNames: await this.partnerDashLabels(eligible.map((d) => d.order.partnerAccountIdAtPay)),
|
||
providerName: provider.name,
|
||
settlementMethod:
|
||
LOGISTICS_SETTLEMENT_METHOD_LABELS[
|
||
provider.settlementMethod as keyof typeof LOGISTICS_SETTLEMENT_METHOD_LABELS
|
||
] ?? String(provider.settlementMethod),
|
||
orderCount,
|
||
bottleCount,
|
||
amount: Number(bill.logisticsAmount),
|
||
bank: {
|
||
bankAccountName: provider.bankAccountName,
|
||
bankName: provider.bankName,
|
||
bankBranch: provider.bankBranch,
|
||
bankAccountNo: provider.bankAccountNo,
|
||
},
|
||
};
|
||
|
||
if (opts?.notify !== false) {
|
||
this.notifyLogisticsBillDigest(`${body.year}-${String(body.month).padStart(2, '0')}`, [
|
||
wecom,
|
||
]);
|
||
}
|
||
|
||
return {
|
||
skipped: false,
|
||
bill: serializeBigInt(bill),
|
||
wecom,
|
||
};
|
||
}
|
||
|
||
async listAdminLogisticsBills(query: {
|
||
page?: number;
|
||
pageSize?: number;
|
||
status?: string;
|
||
providerId?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}) {
|
||
const page = query.page ?? 1;
|
||
const pageSize = query.pageSize ?? 20;
|
||
const where = this.buildLogisticsBillWhere(query);
|
||
|
||
const [rawItems, total, aggregates] = await Promise.all([
|
||
this.prisma.logisticsBill.findMany({
|
||
where,
|
||
orderBy: { periodStart: 'desc' },
|
||
skip: (page - 1) * pageSize,
|
||
take: pageSize,
|
||
include: {
|
||
fulfillmentProvider: {
|
||
select: {
|
||
id: true,
|
||
code: true,
|
||
name: true,
|
||
settlementMethod: true,
|
||
prepaidBalance: true,
|
||
bankAccountName: true,
|
||
bankName: true,
|
||
bankAccountNo: true,
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
this.prisma.logisticsBill.count({ where }),
|
||
this.prisma.logisticsBill.aggregate({
|
||
where,
|
||
_sum: { logisticsAmount: true, bottleCount: true, orderCount: true },
|
||
_count: true,
|
||
}),
|
||
]);
|
||
|
||
const items = rawItems.map((b) => ({
|
||
...withShanghaiPeriod(b),
|
||
providerCode: b.fulfillmentProvider.code,
|
||
providerName: b.fulfillmentProvider.name,
|
||
pricingSnapshot: this.fulfillmentProviderService.parsePricingRules(b.pricingSnapshotJson),
|
||
}));
|
||
|
||
const summary = {
|
||
count: aggregates._count,
|
||
logisticsAmount: Number(aggregates._sum.logisticsAmount ?? 0),
|
||
bottleCount: Number(aggregates._sum.bottleCount ?? 0),
|
||
totalAmount: Number(aggregates._sum.logisticsAmount ?? 0),
|
||
};
|
||
|
||
return serializeBigInt({ items, total, page, pageSize, summary });
|
||
}
|
||
|
||
async listLogisticsProviderSummary(query: { year?: number; month?: number }) {
|
||
const fallback = shanghaiYearMonth();
|
||
const year = query.year ?? fallback.year;
|
||
const month = query.month ?? fallback.month;
|
||
const { start: periodStart, endExclusive } = shanghaiMonthRange(year, month);
|
||
const periodEnd = new Date(endExclusive.getTime() - 1);
|
||
|
||
const providers = await this.prisma.fulfillmentProvider.findMany({
|
||
orderBy: { code: 'asc' },
|
||
});
|
||
|
||
const rows: Array<{
|
||
providerId: string;
|
||
providerCode: string;
|
||
providerName: string;
|
||
settlementMethod: string;
|
||
prepaidBalance: number;
|
||
bankAccountName: string | null;
|
||
bankName: string | null;
|
||
bankAccountNo: string | null;
|
||
pricingRules: ReturnType<FulfillmentProviderService['parsePricingRules']>;
|
||
orderCount: number;
|
||
bottleCount: number;
|
||
logisticsAmount: number;
|
||
billId: string | null;
|
||
billStatus: string | null;
|
||
billAmount: number | null;
|
||
}> = [];
|
||
for (const p of providers) {
|
||
const pricing =
|
||
this.fulfillmentProviderService.parsePricingRules(p.pricingRulesJson) ??
|
||
(p.code.toUpperCase() === 'XFX' || p.code.toUpperCase() === 'XIAOFEIXIA'
|
||
? { ...DEFAULT_XFX_LOGISTICS_PRICING }
|
||
: null);
|
||
|
||
const deliveries = await this.prisma.orderDelivery.findMany({
|
||
where: {
|
||
fulfillmentProviderId: p.id,
|
||
OR: [
|
||
{ shippingAt: { gte: periodStart, lte: periodEnd } },
|
||
{
|
||
shippingAt: null,
|
||
outWarehouseAt: { gte: periodStart, lte: periodEnd },
|
||
},
|
||
],
|
||
},
|
||
include: {
|
||
order: { select: { quantity: true, payStatus: true, deliveryType: true } },
|
||
},
|
||
});
|
||
|
||
const eligible = deliveries.filter(
|
||
(d) =>
|
||
d.order.payStatus === 'PAID' &&
|
||
(d.order.deliveryType === 'LOCAL' || d.order.deliveryType === 'CROSS_CITY'),
|
||
);
|
||
const orderCount = eligible.length;
|
||
const bottleCount = eligible.reduce((s, d) => s + d.order.quantity, 0);
|
||
let logisticsAmount = 0;
|
||
if (pricing) {
|
||
logisticsAmount = round2(
|
||
eligible.reduce(
|
||
(s, d) => s + calcLogisticsFeeByBottles(d.order.quantity, pricing as LogisticsPricingRule),
|
||
0,
|
||
),
|
||
);
|
||
}
|
||
|
||
const bill = await this.prisma.logisticsBill.findFirst({
|
||
where: {
|
||
fulfillmentProviderId: p.id,
|
||
periodStart: { gte: periodStart, lt: endExclusive },
|
||
},
|
||
});
|
||
|
||
rows.push({
|
||
providerId: p.id.toString(),
|
||
providerCode: p.code,
|
||
providerName: p.name,
|
||
settlementMethod: p.settlementMethod,
|
||
prepaidBalance: Number(p.prepaidBalance),
|
||
bankAccountName: p.bankAccountName,
|
||
bankName: p.bankName,
|
||
bankAccountNo: p.bankAccountNo,
|
||
pricingRules: pricing,
|
||
orderCount,
|
||
bottleCount,
|
||
logisticsAmount,
|
||
billId: bill?.id?.toString() ?? null,
|
||
billStatus: bill?.status ?? null,
|
||
billAmount: bill ? Number(bill.logisticsAmount) : null,
|
||
});
|
||
}
|
||
|
||
return { year, month, items: rows };
|
||
}
|
||
|
||
async getAdminLogisticsBill(id: bigint) {
|
||
const bill = await this.prisma.logisticsBill.findUnique({
|
||
where: { id },
|
||
include: {
|
||
fulfillmentProvider: true,
|
||
items: { orderBy: { shippedAt: 'desc' } },
|
||
},
|
||
});
|
||
if (!bill) throw new NotFoundException('物流对账单不存在');
|
||
return serializeBigInt({
|
||
...withShanghaiPeriod(bill),
|
||
providerCode: bill.fulfillmentProvider.code,
|
||
providerName: bill.fulfillmentProvider.name,
|
||
pricingSnapshot: this.fulfillmentProviderService.parsePricingRules(bill.pricingSnapshotJson),
|
||
});
|
||
}
|
||
|
||
async confirmLogisticsBill(id: bigint, dto: { paymentRef?: string } = {}) {
|
||
const bill = await this.prisma.logisticsBill.findUnique({ where: { id } });
|
||
if (!bill) throw new NotFoundException('物流对账单不存在');
|
||
if (bill.status !== 'UNPAID') throw new BadRequestException('仅未结算账单可确认');
|
||
|
||
const paidData = {
|
||
status: 'PAID' as const,
|
||
paidAt: new Date(),
|
||
paymentRef: dto.paymentRef?.trim() || null,
|
||
};
|
||
|
||
if (bill.settlementMethod === 'PREPAID') {
|
||
const deducted = await this.prisma.$transaction(async (tx) => {
|
||
const result = await this.fulfillmentProviderService.deductPrepaid(
|
||
bill.fulfillmentProviderId,
|
||
Number(bill.logisticsAmount),
|
||
bill.id,
|
||
tx,
|
||
);
|
||
if (!result.ok) {
|
||
throw new BadRequestException(
|
||
`充值余额不足（当前 ¥${result.balance.toFixed(2)}，应付 ¥${Number(bill.logisticsAmount).toFixed(2)}）`,
|
||
);
|
||
}
|
||
return tx.logisticsBill.update({
|
||
where: { id },
|
||
data: paidData,
|
||
});
|
||
});
|
||
return serializeBigInt(deducted);
|
||
}
|
||
|
||
const updated = await this.prisma.logisticsBill.update({
|
||
where: { id },
|
||
data: paidData,
|
||
});
|
||
return serializeBigInt(updated);
|
||
}
|
||
|
||
async batchConfirmLogisticsBills(ids: string[]) {
|
||
const results: Array<{ id: string; ok: boolean; message?: string }> = [];
|
||
for (const id of ids) {
|
||
try {
|
||
await this.confirmLogisticsBill(BigInt(id));
|
||
results.push({ id, ok: true });
|
||
} catch (e) {
|
||
results.push({ id, ok: false, message: e instanceof Error ? e.message : '失败' });
|
||
}
|
||
}
|
||
return results;
|
||
}
|
||
|
||
async exportAdminLogisticsBills(query: {
|
||
status?: string;
|
||
providerId?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}) {
|
||
const where = this.buildLogisticsBillWhere(query);
|
||
const bills = await this.prisma.logisticsBill.findMany({
|
||
where,
|
||
include: {
|
||
fulfillmentProvider: {
|
||
select: {
|
||
code: true,
|
||
name: true,
|
||
bankAccountName: true,
|
||
bankName: true,
|
||
bankBranch: true,
|
||
bankAccountNo: true,
|
||
},
|
||
},
|
||
items: true,
|
||
},
|
||
orderBy: { periodStart: 'desc' },
|
||
});
|
||
|
||
const header = [
|
||
'账单号',
|
||
'承运商编码',
|
||
'承运商名称',
|
||
'账期起',
|
||
'账期止',
|
||
'结算方式',
|
||
'订单号',
|
||
'瓶数',
|
||
'物流费',
|
||
'发货时间',
|
||
'账单状态',
|
||
'打款凭证',
|
||
'收款户名',
|
||
'开户银行',
|
||
'开户支行',
|
||
'收款账号',
|
||
].join(',');
|
||
const rows: string[] = [];
|
||
for (const b of bills) {
|
||
const p = b.fulfillmentProvider;
|
||
const bankCols = [
|
||
csvEscape(b.paymentRef ?? ''),
|
||
csvEscape(p.bankAccountName ?? ''),
|
||
csvEscape(p.bankName ?? ''),
|
||
csvEscape(p.bankBranch ?? ''),
|
||
csvEscape(p.bankAccountNo ?? ''),
|
||
];
|
||
if (b.items.length === 0) {
|
||
rows.push(
|
||
[
|
||
csvEscape(b.billNo),
|
||
csvEscape(p.code),
|
||
csvEscape(p.name),
|
||
shanghaiPeriodYmds(b.periodStart).periodStart,
|
||
shanghaiPeriodYmds(b.periodStart).periodEnd,
|
||
b.settlementMethod,
|
||
'',
|
||
b.bottleCount,
|
||
Number(b.logisticsAmount),
|
||
'',
|
||
b.status,
|
||
...bankCols,
|
||
].join(','),
|
||
);
|
||
continue;
|
||
}
|
||
for (const item of b.items) {
|
||
rows.push(
|
||
[
|
||
csvEscape(b.billNo),
|
||
csvEscape(p.code),
|
||
csvEscape(p.name),
|
||
shanghaiPeriodYmds(b.periodStart).periodStart,
|
||
shanghaiPeriodYmds(b.periodStart).periodEnd,
|
||
b.settlementMethod,
|
||
csvEscape(item.orderNo),
|
||
item.quantity,
|
||
Number(item.logisticsAmount),
|
||
item.shippedAt.toISOString().slice(0, 19).replace('T', ' '),
|
||
b.status,
|
||
...bankCols,
|
||
].join(','),
|
||
);
|
||
}
|
||
}
|
||
return { csv: `\uFEFF${[header, ...rows].join('\n')}`, count: rows.length };
|
||
}
|
||
|
||
private buildLogisticsBillWhere(query: {
|
||
status?: string;
|
||
providerId?: string;
|
||
year?: number;
|
||
month?: number;
|
||
}): Prisma.LogisticsBillWhereInput {
|
||
const where: Prisma.LogisticsBillWhereInput = {};
|
||
if (query.status === 'UNPAID' || query.status === 'PAID') where.status = query.status;
|
||
if (query.providerId) where.fulfillmentProviderId = BigInt(query.providerId);
|
||
if (query.year && query.month) {
|
||
const { start, endExclusive } = shanghaiMonthRange(query.year, query.month);
|
||
where.periodStart = { gte: start, lt: endExclusive };
|
||
}
|
||
return where;
|
||
}
|
||
}
|