626 lines
24 KiB
TypeScript
626 lines
24 KiB
TypeScript
import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
|
|
import { Prisma } from '@prisma/client';
|
|
import { assertMoneyUnits, moneyToNumber } from '../common/money';
|
|
import { PrismaService } from '../prisma/prisma.service';
|
|
|
|
export interface CreateTenantAccountDto {
|
|
tenantId: string;
|
|
balanceCents?: number;
|
|
creditCents?: number;
|
|
status?: string;
|
|
}
|
|
|
|
export interface UpdateCreditLimitDto {
|
|
creditCents: number;
|
|
operatorId?: string;
|
|
remark?: string;
|
|
}
|
|
|
|
export interface CreateAccountTransactionDto {
|
|
tenantId: string;
|
|
transactionType: string;
|
|
idempotencyKey?: string;
|
|
amountCents?: number;
|
|
balanceAfter?: number;
|
|
relatedType?: string;
|
|
relatedId?: string;
|
|
remark?: string;
|
|
}
|
|
|
|
export interface CreateBillingRuleDto {
|
|
code: string;
|
|
name: string;
|
|
chargeBasis?: string;
|
|
unitPrice: number;
|
|
status?: string;
|
|
}
|
|
|
|
export interface CreateRechargeOrderDto {
|
|
tenantId: string;
|
|
amountCents: number;
|
|
payMethod?: string;
|
|
operatorId?: string;
|
|
remark?: string;
|
|
}
|
|
|
|
export interface CreateManualRechargeDto {
|
|
tenantId: string;
|
|
amountCents: number;
|
|
expectedAccountUpdatedAt: string;
|
|
idempotencyKey: string;
|
|
operatorId?: string;
|
|
remark?: string;
|
|
}
|
|
|
|
export interface ManualRechargePreflightDto {
|
|
tenantId: string;
|
|
amountCents: number;
|
|
}
|
|
|
|
export interface EstimateSmsCostDto {
|
|
tenantId: string;
|
|
applicationId?: string;
|
|
content: string;
|
|
phoneCount: number;
|
|
unitPrice?: number;
|
|
taskId?: string;
|
|
}
|
|
|
|
export interface BillingActionDto {
|
|
tenantId: string;
|
|
idempotencyKey?: string;
|
|
amountCents?: number;
|
|
relatedType?: string;
|
|
relatedId?: string;
|
|
remark?: string;
|
|
}
|
|
|
|
export interface CreateSmsBillingRecordDto {
|
|
tenantId: string;
|
|
applicationId?: string;
|
|
taskId?: string;
|
|
messageId?: string;
|
|
phoneNumber?: string;
|
|
content: string;
|
|
unitPrice?: number;
|
|
}
|
|
|
|
@Injectable()
|
|
export class BillingService {
|
|
constructor(private readonly prisma: PrismaService) {}
|
|
|
|
listAccounts() {
|
|
return this.prisma.tenantAccount.findMany({
|
|
include: { tenant: true },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
}
|
|
|
|
createAccount(data: CreateTenantAccountDto) {
|
|
assertMoneyUnits(data.balanceCents ?? 0, '账户余额', { allowNegative: true });
|
|
assertMoneyUnits(data.creditCents ?? 0, '授信额度', { allowNegative: true });
|
|
const createData: Prisma.TenantAccountUncheckedCreateInput = {
|
|
tenantId: data.tenantId,
|
|
balanceCents: data.balanceCents ?? 0,
|
|
creditCents: data.creditCents ?? 0,
|
|
status: data.status ?? 'active',
|
|
};
|
|
return this.prisma.tenantAccount.create({ data: createData });
|
|
}
|
|
|
|
async updateCreditLimit(tenantId: string, data: UpdateCreditLimitDto) {
|
|
assertMoneyUnits(data.creditCents, '授信额度', { allowNegative: true });
|
|
const account = await this.getAccountOrCreate(tenantId);
|
|
const updated = await this.prisma.tenantAccount.update({
|
|
where: { tenantId },
|
|
data: { creditCents: data.creditCents },
|
|
});
|
|
await this.prisma.operationLog.create({
|
|
data: {
|
|
tenantId,
|
|
userId: data.operatorId,
|
|
action: 'billing.credit_limit_updated',
|
|
resource: 'tenant_account',
|
|
resourceId: account.id,
|
|
detail: {
|
|
previousCreditCents: moneyToNumber(account.creditCents),
|
|
creditCents: data.creditCents,
|
|
remark: data.remark,
|
|
} as Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
return updated;
|
|
}
|
|
|
|
listRechargeOrders(tenantId?: string) {
|
|
return this.prisma.rechargeOrder.findMany({
|
|
where: tenantId ? { tenantId } : undefined,
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
}
|
|
|
|
async listRechargeOrdersPage(query: { tenantId?: string; page?: number; pageSize?: number }) {
|
|
const page = Math.max(1, Math.floor(Number(query.page) || 1));
|
|
const pageSize = Math.min(100, Math.max(1, Math.floor(Number(query.pageSize) || 10)));
|
|
const where: Prisma.RechargeOrderWhereInput = query.tenantId ? { tenantId: query.tenantId } : {};
|
|
const [items, total] = await Promise.all([
|
|
this.prisma.rechargeOrder.findMany({ where, orderBy: { createdAt: 'desc' }, skip: (page - 1) * pageSize, take: pageSize }),
|
|
this.prisma.rechargeOrder.count({ where }),
|
|
]);
|
|
return { items, total, page, pageSize };
|
|
}
|
|
|
|
async listManualRechargeRecords(tenantId?: string) {
|
|
const orders = await this.prisma.rechargeOrder.findMany({
|
|
where: {
|
|
tenantId,
|
|
payMethod: 'manual_topup',
|
|
},
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
const orderIds = orders.map((order) => order.id);
|
|
if (orderIds.length === 0) {
|
|
return orders;
|
|
}
|
|
|
|
const operatorIds = [...new Set(orders.map((order) => order.operatorId).filter((id): id is string => Boolean(id)))];
|
|
const [transactions, operators] = await Promise.all([
|
|
this.prisma.accountTransaction.findMany({
|
|
where: {
|
|
relatedType: 'recharge_order',
|
|
relatedId: { in: orderIds },
|
|
},
|
|
select: { relatedId: true, balanceAfter: true },
|
|
}),
|
|
operatorIds.length ? this.prisma.user.findMany({
|
|
where: { id: { in: operatorIds } },
|
|
select: { id: true, displayName: true, username: true },
|
|
}) : [],
|
|
]);
|
|
const balanceAfterByOrderId = new Map(transactions.map((transaction) => [transaction.relatedId, moneyToNumber(transaction.balanceAfter)]));
|
|
const operatorNameById = new Map(operators.map((operator) => [operator.id, operator.displayName || operator.username]));
|
|
|
|
return orders.map((order) => ({
|
|
...order,
|
|
balanceAfterCents: balanceAfterByOrderId.get(order.id) ?? null,
|
|
operatorName: order.operatorId ? operatorNameById.get(order.operatorId) ?? null : null,
|
|
}));
|
|
}
|
|
|
|
async listManualRechargeRecordsPage(query: { tenantId?: string; enterpriseKeyword?: string; createdAtFrom?: string; createdAtTo?: string; page?: number; pageSize?: number }) {
|
|
const page = Math.max(1, Math.floor(Number(query.page) || 1));
|
|
const pageSize = Math.min(100, Math.max(1, Math.floor(Number(query.pageSize) || 10)));
|
|
const where: Prisma.RechargeOrderWhereInput = {
|
|
tenantId: query.tenantId,
|
|
payMethod: 'manual_topup',
|
|
tenant: query.enterpriseKeyword?.trim() ? { name: { contains: query.enterpriseKeyword.trim() } } : undefined,
|
|
createdAt: query.createdAtFrom || query.createdAtTo ? {
|
|
gte: query.createdAtFrom ? new Date(`${query.createdAtFrom}T00:00:00+08:00`) : undefined,
|
|
lte: query.createdAtTo ? new Date(`${query.createdAtTo}T23:59:59.999+08:00`) : undefined,
|
|
} : undefined,
|
|
};
|
|
const [orders, total] = await Promise.all([
|
|
this.prisma.rechargeOrder.findMany({ where, include: { tenant: true }, orderBy: { createdAt: 'desc' }, skip: (page - 1) * pageSize, take: pageSize }),
|
|
this.prisma.rechargeOrder.count({ where }),
|
|
]);
|
|
const orderIds = orders.map((order) => order.id);
|
|
const operatorIds = [...new Set(orders.map((order) => order.operatorId).filter((id): id is string => Boolean(id)))];
|
|
const [transactions, operators] = await Promise.all([
|
|
orderIds.length ? this.prisma.accountTransaction.findMany({
|
|
where: { relatedType: 'recharge_order', relatedId: { in: orderIds } },
|
|
select: { relatedId: true, balanceAfter: true },
|
|
}) : [],
|
|
operatorIds.length ? this.prisma.user.findMany({
|
|
where: { id: { in: operatorIds } },
|
|
select: { id: true, displayName: true, username: true },
|
|
}) : [],
|
|
]);
|
|
const balances = new Map(transactions.map((item) => [item.relatedId, moneyToNumber(item.balanceAfter)]));
|
|
const operatorNames = new Map(operators.map((operator) => [operator.id, operator.displayName || operator.username]));
|
|
return {
|
|
items: orders.map((order) => ({
|
|
...order,
|
|
balanceAfterCents: balances.get(order.id) ?? null,
|
|
operatorName: order.operatorId ? operatorNames.get(order.operatorId) ?? null : null,
|
|
})),
|
|
total,
|
|
page,
|
|
pageSize,
|
|
};
|
|
}
|
|
|
|
async createRechargeOrder(data: CreateRechargeOrderDto) {
|
|
const amountCents = data.amountCents;
|
|
assertMoneyUnits(amountCents, '充值金额', { allowNegative: true, allowZero: false });
|
|
const order = await this.prisma.rechargeOrder.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
orderNo: `R${Date.now()}${Math.floor(Math.random() * 10000).toString().padStart(4, '0')}`,
|
|
amountCents,
|
|
status: 'paid',
|
|
payMethod: data.payMethod ?? 'manual',
|
|
paidAt: new Date(),
|
|
operatorId: data.operatorId,
|
|
remark: data.remark,
|
|
},
|
|
});
|
|
|
|
await this.applyAccountDelta({
|
|
tenantId: data.tenantId,
|
|
transactionType: 'recharge',
|
|
amountCents,
|
|
relatedType: 'recharge_order',
|
|
relatedId: order.id,
|
|
remark: data.remark,
|
|
});
|
|
|
|
return order;
|
|
}
|
|
|
|
async createManualRecharge(data: CreateManualRechargeDto) {
|
|
assertMoneyUnits(data.amountCents, '充值金额', { allowNegative: true, allowZero: false });
|
|
const idempotencyKey = data.idempotencyKey?.trim();
|
|
if (!idempotencyKey || idempotencyKey.length < 8 || idempotencyKey.length > 128) {
|
|
throw new BadRequestException('人工充值幂等键长度必须为 8 至 128 个字符');
|
|
}
|
|
const expectedUpdatedAt = new Date(data.expectedAccountUpdatedAt);
|
|
if (Number.isNaN(expectedUpdatedAt.getTime())) throw new BadRequestException('账户版本无效，请重新核对充值信息');
|
|
|
|
const replay = await this.prisma.operationLog.findFirst({
|
|
where: { action: 'billing.manual_recharge', detail: { path: ['idempotencyKey'], equals: idempotencyKey } },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
if (replay) return this.manualRechargeReplay(replay, data);
|
|
|
|
return this.prisma.$transaction(async (tx) => {
|
|
await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'manual-recharge:' + idempotencyKey}))`;
|
|
const existing = await tx.operationLog.findFirst({
|
|
where: { action: 'billing.manual_recharge', detail: { path: ['idempotencyKey'], equals: idempotencyKey } },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
if (existing) {
|
|
const detail = asRecord(existing.detail);
|
|
if (existing.tenantId !== data.tenantId || Number(detail.amountCents) !== data.amountCents) {
|
|
throw new ConflictException('该幂等键已用于另一笔人工充值');
|
|
}
|
|
const order = existing.resourceId ? await tx.rechargeOrder.findUnique({ where: { id: existing.resourceId } }) : null;
|
|
if (!order) throw new ConflictException('幂等充值记录不完整，请联系管理员核查');
|
|
const transaction = await tx.accountTransaction.findFirst({
|
|
where: { relatedType: 'recharge_order', relatedId: order.id },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
return { ...order, balanceAfterCents: moneyToNumber(transaction?.balanceAfter), operationId: existing.id, replayed: true };
|
|
}
|
|
|
|
const tenant = await tx.tenant.findFirst({ where: { id: data.tenantId, status: { not: 'deleted' } }, select: { id: true } });
|
|
if (!tenant) throw new NotFoundException('充值企业不存在或已删除');
|
|
const account = await tx.tenantAccount.findUnique({ where: { tenantId: data.tenantId } });
|
|
if (!account) throw new ConflictException('企业账户尚未初始化，请重新核对充值信息');
|
|
const previousBalanceCents = moneyToNumber(account.balanceCents);
|
|
const changed = await tx.tenantAccount.updateMany({
|
|
where: { tenantId: data.tenantId, updatedAt: expectedUpdatedAt },
|
|
data: { balanceCents: { increment: data.amountCents } },
|
|
});
|
|
if (changed.count !== 1) throw new ConflictException('企业余额已变化，请重新核对后再充值');
|
|
const balanceAfterCents = previousBalanceCents + data.amountCents;
|
|
const order = await tx.rechargeOrder.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
orderNo: `MR${Date.now()}${Math.floor(Math.random() * 10000).toString().padStart(4, '0')}`,
|
|
amountCents: data.amountCents,
|
|
status: 'paid',
|
|
payMethod: 'manual_topup',
|
|
paidAt: new Date(),
|
|
operatorId: data.operatorId,
|
|
remark: data.remark,
|
|
},
|
|
});
|
|
await tx.accountTransaction.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
transactionType: 'recharge',
|
|
amountCents: data.amountCents,
|
|
balanceAfter: balanceAfterCents,
|
|
relatedType: 'recharge_order',
|
|
relatedId: order.id,
|
|
remark: data.remark,
|
|
},
|
|
});
|
|
const operation = await tx.operationLog.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
userId: data.operatorId,
|
|
action: 'billing.manual_recharge',
|
|
resource: 'recharge_order',
|
|
resourceId: order.id,
|
|
detail: {
|
|
idempotencyKey,
|
|
amountCents: data.amountCents,
|
|
previousBalanceCents,
|
|
balanceAfterCents,
|
|
orderNo: order.orderNo,
|
|
remark: data.remark,
|
|
} as Prisma.InputJsonValue,
|
|
},
|
|
});
|
|
return { ...order, balanceAfterCents, operationId: operation.id, replayed: false };
|
|
}, { isolationLevel: Prisma.TransactionIsolationLevel.Serializable });
|
|
}
|
|
|
|
async manualRechargePreflight(data: ManualRechargePreflightDto) {
|
|
assertMoneyUnits(data.amountCents, '充值金额', { allowNegative: true, allowZero: false });
|
|
const tenant = await this.prisma.tenant.findFirst({
|
|
where: { id: data.tenantId, status: { not: 'deleted' } },
|
|
select: { id: true, name: true, code: true },
|
|
});
|
|
if (!tenant) throw new NotFoundException('充值企业不存在或已删除');
|
|
const account = await this.getAccountOrCreate(data.tenantId);
|
|
const balanceCents = moneyToNumber(account.balanceCents);
|
|
return {
|
|
tenant,
|
|
accountId: account.id,
|
|
expectedAccountUpdatedAt: account.updatedAt.toISOString(),
|
|
balanceCents,
|
|
creditCents: moneyToNumber(account.creditCents),
|
|
amountCents: data.amountCents,
|
|
balanceAfterCents: balanceCents + data.amountCents,
|
|
direction: data.amountCents > 0 ? 'topup' : 'correction',
|
|
allowedActions: ['confirm'],
|
|
blockedReasons: [],
|
|
};
|
|
}
|
|
|
|
private async manualRechargeReplay(log: { id: string; tenantId: string | null; resourceId: string | null; detail: Prisma.JsonValue | null }, data: CreateManualRechargeDto) {
|
|
const detail = asRecord(log.detail);
|
|
if (log.tenantId !== data.tenantId || Number(detail.amountCents) !== data.amountCents) {
|
|
throw new ConflictException('该幂等键已用于另一笔人工充值');
|
|
}
|
|
const order = log.resourceId ? await this.prisma.rechargeOrder.findUnique({ where: { id: log.resourceId } }) : null;
|
|
if (!order) throw new ConflictException('幂等充值记录不完整，请联系管理员核查');
|
|
const transaction = await this.prisma.accountTransaction.findFirst({
|
|
where: { relatedType: 'recharge_order', relatedId: order.id },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
return { ...order, balanceAfterCents: moneyToNumber(transaction?.balanceAfter), operationId: log.id, replayed: true };
|
|
}
|
|
|
|
estimateSmsCost(data: EstimateSmsCostDto) {
|
|
const billingUnits = estimateBillingUnits(data.content);
|
|
const unitPrice = data.unitPrice ?? 0;
|
|
assertMoneyUnits(unitPrice, '短信单价');
|
|
const totalUnits = billingUnits * data.phoneCount;
|
|
const amountCents = totalUnits * unitPrice;
|
|
assertMoneyUnits(amountCents, '短信计费金额');
|
|
return {
|
|
tenantId: data.tenantId,
|
|
applicationId: data.applicationId,
|
|
taskId: data.taskId,
|
|
contentLength: [...data.content].length,
|
|
phoneCount: data.phoneCount,
|
|
billingUnitsPerMessage: billingUnits,
|
|
totalBillingUnits: totalUnits,
|
|
unitPrice,
|
|
amountCents,
|
|
};
|
|
}
|
|
|
|
async checkAccount(data: BillingActionDto) {
|
|
const account = await this.getAccountOrCreate(data.tenantId);
|
|
const requiredAmount = data.amountCents ?? 0;
|
|
const balanceCents = moneyToNumber(account.balanceCents);
|
|
const creditCents = moneyToNumber(account.creditCents);
|
|
const availableAmount = balanceCents + creditCents;
|
|
return {
|
|
tenantId: data.tenantId,
|
|
requiredAmount,
|
|
availableAmount,
|
|
balanceCents,
|
|
creditCents,
|
|
canSend: availableAmount >= requiredAmount,
|
|
};
|
|
}
|
|
|
|
freeze(data: BillingActionDto) {
|
|
return this.applyAccountDelta({
|
|
...data,
|
|
transactionType: 'frozen',
|
|
amountCents: -(data.amountCents ?? 0),
|
|
});
|
|
}
|
|
|
|
charge(data: BillingActionDto) {
|
|
return this.applyAccountDelta({
|
|
...data,
|
|
transactionType: 'charged',
|
|
amountCents: -(data.amountCents ?? 0),
|
|
});
|
|
}
|
|
|
|
async settleFrozenCharge(data: { tenantId: string; amountCents: number; messageId: string; taskId: string; remark?: string }) {
|
|
const amountCents = data.amountCents ?? 0;
|
|
if (amountCents <= 0) return null;
|
|
const releaseKey = `sms-charge-release:${data.messageId}`;
|
|
const chargeKey = `sms-charge:${data.messageId}`;
|
|
const existing = await this.prisma.accountTransaction.findMany({
|
|
where: { idempotencyKey: { in: [releaseKey, chargeKey] } },
|
|
});
|
|
const charge = existing.find((row) => row.idempotencyKey === chargeKey);
|
|
if (charge) return charge;
|
|
const release = existing.find((row) => row.idempotencyKey === releaseKey);
|
|
if (release) {
|
|
// Recover the legacy two-transaction boundary: a crash may have committed
|
|
// release before charge, so this path must perform the missing balance debit.
|
|
return this.applyAccountDelta({
|
|
tenantId: data.tenantId, transactionType: 'charged', idempotencyKey: chargeKey,
|
|
amountCents: -amountCents, relatedType: 'sms_message_record', relatedId: data.messageId,
|
|
remark: '提交成功扣费（恢复既有已释放冻结）',
|
|
});
|
|
}
|
|
const rows = await this.prisma.$queryRaw<Array<{ id: string; idempotencyKey: string }>>(Prisma.sql`
|
|
WITH account AS (
|
|
SELECT "balanceCents" FROM "TenantAccount" WHERE "tenantId" = ${data.tenantId}
|
|
), inserted AS (
|
|
INSERT INTO "AccountTransaction" (
|
|
id, "tenantId", "transactionType", "idempotencyKey", "amountCents",
|
|
"balanceAfter", "relatedType", "relatedId", remark, "createdAt"
|
|
)
|
|
SELECT gen_random_uuid()::text, ${data.tenantId}, ledger."transactionType", ledger."idempotencyKey",
|
|
ledger."amountCents", account."balanceCents" + ledger."balanceDelta",
|
|
ledger."relatedType", ledger."relatedId", ledger.remark, (NOW() AT TIME ZONE 'UTC')
|
|
FROM account
|
|
CROSS JOIN (VALUES
|
|
('released', ${releaseKey}, ${amountCents}::bigint, ${amountCents}::bigint, 'sms_batch_task', ${data.taskId}, ${data.remark ?? null}),
|
|
('charged', ${chargeKey}, ${-amountCents}::bigint, 0::bigint, 'sms_message_record', ${data.messageId}, '提交成功扣费')
|
|
) AS ledger("transactionType", "idempotencyKey", "amountCents", "balanceDelta", "relatedType", "relatedId", remark)
|
|
ON CONFLICT ("idempotencyKey") DO NOTHING
|
|
RETURNING id, "idempotencyKey"
|
|
)
|
|
SELECT id, "idempotencyKey" FROM inserted WHERE "idempotencyKey" = ${chargeKey}
|
|
UNION ALL
|
|
SELECT id, "idempotencyKey" FROM "AccountTransaction" WHERE "idempotencyKey" = ${chargeKey}
|
|
LIMIT 1
|
|
`);
|
|
if (rows[0]) return rows[0];
|
|
// A concurrent identical callback can win ON CONFLICT while remaining
|
|
// invisible to this statement's snapshot; one read repairs that MVCC edge.
|
|
return this.prisma.accountTransaction.findUniqueOrThrow({ where: { idempotencyKey: chargeKey } });
|
|
}
|
|
|
|
release(data: BillingActionDto) {
|
|
return this.applyAccountDelta({
|
|
...data,
|
|
transactionType: 'released',
|
|
amountCents: data.amountCents ?? 0,
|
|
});
|
|
}
|
|
|
|
refund(data: BillingActionDto) {
|
|
return this.applyAccountDelta({
|
|
...data,
|
|
transactionType: 'refunded',
|
|
amountCents: data.amountCents ?? 0,
|
|
});
|
|
}
|
|
|
|
adjust(data: BillingActionDto) {
|
|
return this.applyAccountDelta({
|
|
...data,
|
|
transactionType: 'adjusted',
|
|
amountCents: data.amountCents ?? 0,
|
|
});
|
|
}
|
|
|
|
async createSmsBillingRecord(data: CreateSmsBillingRecordDto) {
|
|
const estimate = this.estimateSmsCost({
|
|
tenantId: data.tenantId,
|
|
applicationId: data.applicationId,
|
|
taskId: data.taskId,
|
|
content: data.content,
|
|
phoneCount: 1,
|
|
unitPrice: data.unitPrice ?? 0,
|
|
});
|
|
return this.prisma.smsBillingRecord.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
applicationId: data.applicationId,
|
|
taskId: data.taskId,
|
|
messageId: data.messageId,
|
|
phoneNumber: data.phoneNumber,
|
|
contentLength: estimate.contentLength,
|
|
billingUnits: estimate.billingUnitsPerMessage,
|
|
unitPrice: estimate.unitPrice,
|
|
amountCents: estimate.amountCents,
|
|
billingStatus: 'estimated',
|
|
},
|
|
});
|
|
}
|
|
|
|
listSmsBillingRecords(tenantId?: string, taskId?: string) {
|
|
return this.prisma.smsBillingRecord.findMany({
|
|
where: { tenantId, taskId },
|
|
orderBy: { createdAt: 'desc' },
|
|
});
|
|
}
|
|
|
|
listRules() {
|
|
return this.prisma.billingRule.findMany({ orderBy: { createdAt: 'desc' } });
|
|
}
|
|
|
|
createRule(data: CreateBillingRuleDto) {
|
|
assertMoneyUnits(data.unitPrice, '计费规则单价');
|
|
return this.prisma.billingRule.create({
|
|
data: {
|
|
code: data.code,
|
|
name: data.name,
|
|
chargeBasis: data.chargeBasis ?? 'submit_success',
|
|
unitPrice: data.unitPrice,
|
|
status: data.status ?? 'active',
|
|
},
|
|
});
|
|
}
|
|
|
|
private async getAccountOrCreate(tenantId: string) {
|
|
return this.prisma.tenantAccount.upsert({
|
|
where: { tenantId },
|
|
update: {},
|
|
create: { tenantId, balanceCents: 0, creditCents: 0, status: 'active' },
|
|
});
|
|
}
|
|
|
|
private async applyAccountDelta(data: CreateAccountTransactionDto) {
|
|
const amountCents = data.amountCents ?? 0;
|
|
const idempotencyKey = data.idempotencyKey?.trim() || null;
|
|
return this.prisma.$transaction(async (tx) => {
|
|
await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtextextended(${'tenant-account:' + data.tenantId}, 0))`;
|
|
if (idempotencyKey) {
|
|
const existing = await tx.accountTransaction.findUnique({ where: { idempotencyKey } });
|
|
if (existing) {
|
|
if (
|
|
existing.tenantId !== data.tenantId
|
|
|| existing.transactionType !== data.transactionType
|
|
|| moneyToNumber(existing.amountCents) !== amountCents
|
|
|| existing.relatedType !== (data.relatedType ?? null)
|
|
|| existing.relatedId !== (data.relatedId ?? null)
|
|
) {
|
|
throw new ConflictException('账务幂等键已用于另一笔交易');
|
|
}
|
|
return existing;
|
|
}
|
|
}
|
|
await tx.tenantAccount.upsert({
|
|
where: { tenantId: data.tenantId },
|
|
update: {},
|
|
create: { tenantId: data.tenantId, balanceCents: 0, creditCents: 0, status: 'active' },
|
|
});
|
|
const account = await tx.tenantAccount.update({
|
|
where: { tenantId: data.tenantId },
|
|
data: { balanceCents: { increment: amountCents } },
|
|
});
|
|
return tx.accountTransaction.create({
|
|
data: {
|
|
tenantId: data.tenantId,
|
|
transactionType: data.transactionType,
|
|
idempotencyKey,
|
|
amountCents,
|
|
balanceAfter: account.balanceCents,
|
|
relatedType: data.relatedType,
|
|
relatedId: data.relatedId,
|
|
remark: data.remark,
|
|
},
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
function estimateBillingUnits(content: string) {
|
|
const length = [...content].length;
|
|
if (length <= 70) {
|
|
return 1;
|
|
}
|
|
return Math.ceil(length / 67);
|
|
}
|
|
|
|
function asRecord(value: Prisma.JsonValue | null | undefined): Record<string, Prisma.JsonValue> {
|
|
return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, Prisma.JsonValue> : {};
|
|
}
|