集简云付费系统:计费点、四层模型与策略模式落地草稿
用途:简历项目四「计费履约层」的细节支撑 + 面试追问应答。 证据来源:
admin-backend-master(运营后台)、payment-master(支付独立服务)、winpro`(业务侧调用点)。 结论先行:这是一套「指标字典 → 套餐模板 → 履约实例 → 账本流水」四层嵌套 +「6 类计费点 + 3 种交易策略 + 双轨账扣减」的 SaaS 计费系统。
文档关系:配套备忘录 06.purchase-strage.md(2025-06-04)也是同一套系统,但写于月付尚未引入的「年付假设」阶段——其 UpgradeStrategy 把 total_duration = 365 写死再算 (新−旧)×剩余比例,数学上等价于本系统 §3.2 点名的「旧公式」。即该备忘录是本系统年付版早期策略骨架,正是月付上线后它失效、才催生出 §3.2 的按周期折算新公式与 §4 的策略族重构。两份不合并为平级方案:本文以生产现状为准,那份作「演进前」快照引用。
0. 两个仓库的分工(先说清楚,避免面试时说串)
| 仓库 | 角色 | 端口 / 形态 | 内容 |
|---|---|---|---|
payment-master | 支付独立服务 | Flask :5005,独立部署 | 下单、二维码、支付回调、二次支付、钱包充值;三个 blueprint:/pay、/pay/wallet、/pay/plugin |
admin-backend-master | 运营后台 | Django | 产品(套餐模板)管理、资源包(履约实例)管理、订单运维、计费点校验接口、账户余额 |
winpro | 业务侧 | 业务应用 | 只调两个 HTTP 接口(查权限 / 查余额),不持有任何计费逻辑 |
一句话:计费规则在 admin,交易与支付在 payment,业务侧只做「问一句能不能用」。
1. 付费点 = 6 类计费模式
paymentcalculation.py:20-32
CHARGE_TYPES = {
1: '周期计费', # x 元/年,主套餐默认
2: '费率计费', # 按次付费的单次费率(per_unit_price)
3: '包次计费', # 资源包总次数(app_total_amount + price + validity)
4: '包时计费', # 总价 = 单价 × 月数
5: '扣费字段', # 扣费依据在第三方响应里(discount_key),按真实用量
6: '余额抵扣', # 直接扣余额,资源包只负责关系绑定
}
PAY_APP_CHARGE_TYPES = [2, 3, 4, 5, 6] # 付费应用(连接器动作)走这 5 种两层含义要分清:
- 第 1 种是「卖套餐」:企业买一个版本(基础版 / 团队版 / 企业版),按年付费,里面含一堆指标额度。
- 第 2-6 种是「卖动作」:单个连接器动作是一个独立收费点,绑定一种计费模式。
relation_action_products.action_identify是动作标识,charge_type决定怎么算钱。
第 5 种「扣费字段」最特殊:扣费依据不来自我们,来自第三方接口的响应(如发短信接口返回 count、OCR 返回 pages),用 discount_key 指定取哪个字段,plugin.py:440 eval_usage 用 eval 动态取值。这是「按真实用量计费」的土办法,也是这套系统最灵活的一类。
计量的原子单位:metrics 表(resource.py:107)
| 字段 | 作用 | 取值 |
|---|---|---|
category | 计费策略类型 | switch(布尔开关)/ counter(计数)/ rate(速率)/ basic(基础量) |
aggregation_type | 多资源包时怎么合并 | count 累加 / sum 求和 / max 取最大 |
default_value | 默认额度 | — |
unit / mark | 单位与说明 | 次 / 条 / 人 / 秒 |
desc_key | 业务代码里用的键 | process_number / step_number / balance_payment |
为什么要 aggregation_type:一个企业可能同时持有多个资源包(主套餐 + 增量包 + 共享包)。同一个指标在多个包里各有一份额度,合并时 count/sum 要求和,max 要取最大值(并发上限这类限制不能相加,否则买两个包并发变两倍)。
2. 四层数据模型(这是「解耦」的骨架)
metrics (指标字典:有哪些计量维度)
↓ 被引用
plan_function (套餐模板的功能点:这个版本含哪些指标、额度多少、单价多少)
↓ 购买时复制
subscription (履约实例的功能点:企业手上这个包,每个指标的 bind_value / usage)
↑ 挂在
company_resource_bundle (履约实例:包 id、到期日、状态、优先级、bundle_type、订单号)
↑ 被订单指向
order_info (订单:金额、支付渠道、trade_type、is_pay、is_cancelled)
↓ 支付后产生
company_balance_record (账本流水:余额变动、transaction_id、commit_id、consume_type、detail)各层的字段语义(面试可直接背)
company_resource_bundle(履约实例,paymentcalculation.py:1666 create_bundle)
| 字段 | 作用 |
|---|---|
bundle_id / company_id / product_id | 基本标识 |
expiration_time | 到期日(续费只改这个) |
state | 1 激活 / 2 禁用(升级时旧包置 2,ban_bundle) |
priority | 同企业多包并存时的扣减优先级(越大越优先) |
bundle_type | 10 类:语义分析 / 数据流程 / 免费版 / 基础版 / 团队协作版 / 企业协作版 / 企业高级版 / 企业定制版 / 增量包 / 付费应用包 |
order_id | 订单号(1 个包可对应 N 个订单,因为续费不新建包) |
price | 成交价 |
subscription(履约实例的功能点)
(bundle_id, metric_id, bind_value, is_main_ctrl, per_unit_price, usage)
↑额度 ↑主控开关 ↑单价 ↑已用量is_main_ctrl 是关键设计:一个包里可以指定一个「主控指标」,主控一票否决——主控没额度,同包其他指标全部不可用(event_track.py:459-464 用 pandas 做了整包置 False)。这是「套餐整体停服」的开关,不用逐个指标去关。
模板 vs 实例:为什么要分离
- 改模板(
products.py里改价格/额度)不动存量用户——已经卖出去的包按当时的额度跑。 - 存量用户要改,只能走运营手工改单个包(
costlogic.py:441 BundlesDetail.patch),且改价会回写订单金额(update_external_of_order)。 - 这套分层的代价就是运维成本,但收益是改价不会引发存量用户纠纷。
这是 SaaS 计费的硬约束,不是设计过度。
共享资源包:同一份额度被多个租户共享
paymentcalculation.py:1099 class SharedBundles(中间表 shared_bundles_info)
机制:主企业买了包,可以让子公司共用——不复制额度,只授予可见性。
| 环节 | 做法 | 代码 |
|---|---|---|
| 主企业建包 | 正常 create_bundle,同时在中间表写入「企业 ↔ 产品」关系 | create_bundle |
| 副企业「开通」 | 不建包,只把中间表的 state=1、bundle_id 指向主企业的包 | active_share_bundle(company_id, product_id, bundle_id, priority) |
| 扣减 | 副企业消耗落到同一个 bundle_id → 同一份 subscription.usage | track_access 走同一路径 |
| 白名单 | 主企业可在 plan_function 的 share_company 绑定值里限制共享给谁 | limit_company / filter_input_function_info_by_key |
| 优先级 | 副企业可能同时持有自有包 + 共享包,靠中间表 priority 决定扣减顺序 | update_priority_of_shared |
三个必须处理的坑(这也是它成为难点的原因):
- 去重:副企业既有自有包、又被共享了同一个包时,查询必须避免同一条
bundle_id被算两次。做法是 UNION 左表(自有包)与右表(非主企业的共享包),右表再加S.bundle_id NOT IN (该企业的自有包)(query_union_bundle_sql)。 - 状态联动:共享包的 6 个状态(1 激活 / 2 禁用 / 3 过期 / 4 完成 / 5 未生效 / 6 已删除)要经
update_state_of_shared_bundle与主包同步;check_is_forbidden_active在激活前拦掉 2/3/4/6。 - 取消共享的前置检查:关联表里还有别的企业在用就不能删(
check_is_able_to_remove_shared),否则会把别人的服务直接掐掉。
面试可以说的一句:共享包的本质是「把 bundle_id 的可见性授予出去,而不是复制一份额度」——所以它天然带两个风险:重复计数(要 UNION 去重)和越权可见(要白名单)。这两个都是设计时就定了,不是事后补的。
3. 三种交易 = 三条履约路径
trade_type:1 开通 / 2 续费 / 3 升级(order_info.trade_type)。
支付回调 pay_callback.py:79 after_pay_action 里分派:
| trade_type | 履约动作 | 资源包 | 订单关系 | 到期日 |
|---|---|---|---|---|
| 1 开通 | 先继承免费版包的 usage → create_bundle → ban_bundle 旧包 | 新建 | 1:1 | 按套餐周期算 |
| 2 续费 | renewal() 只改 expiration_time | 原地延期 | 1 包 : N 订单 | 原到期日 + 周期 |
| 3 升级 | upgrade_subs() 合并功能点 → create_bundle → ban_bundle 旧包 → 把新包到期日改回旧包到期日 | 新建 + 禁用旧包 | 新包 1:1 | 不变(纯升级不改周期) |
3.1 升级的合并规则(全系统最有价值的一条业务规则)
paymentcalculation.py:2142 upgrade_subs 的 docstring 原文:
bind_value以新的产品包为准,usage以旧的产品的为准
实现用 pandas combine_first(新 DataFrame 为主,旧值填空)。
为什么必须这样:如果升级时 usage 也清零,用户就可以「先在低版本把额度刷光 → 再花小钱升级 → 白拿一份新额度」。这是计费系统的经典漏洞,堵法就是把已用量带过去。 开通时继承免费版 usage(pay_callback.py:137-150)是同一个漏洞的另一种封堵。
3.2 升级补差价公式的演进(真实的技术演进证据)
| 版本 | 公式 | 位置 | 问题 |
|---|---|---|---|
| 旧 | (新价 − 原价) / 365 × 剩余天数 | admin-backend/view/order.py:193 | 分母硬编码 365,只适用年付 |
| 新 | (新价 / 新周期天数 − 原价 / 原周期天数) × 剩余天数 | payment-master/pay.py:58 | 按各自实际周期折算日均价 |
新版的注释直接写明了动因:
# 向下取整 当加入按月付费时,validity 不是365换成:引入月付后旧公式失效,改成按 validity_to_day 各自折算。 这是可以拿去讲「技术演进」的真材料——比「我用了策略模式」硬得多。
如果同时升级 + 续费(is_extend=True),公式追加 + 新价 × 周期数(pay.py:62-64)。
这套「旧公式」的早期形态,就是
06.purchase-strage.md(2025-06-04 备忘录)里的UpgradeStrategy:total_duration = 365写死,再(new - old) * (1 - time_used/365)——与本表「旧公式」完全等价(因剩余天数 = 365 − time_used)。换言之该备忘录是引入月付前的年付假设版骨架,本系统上线月付后它才失效、直接催生了按周期折算的新公式。 面试讲「技术演进」时,这份备忘录就是实物证据:先有 2-method 纯计算骨架(假设年付),月付 + 6 计费点 + 四层模型上线后写死的 365 分母失效,才重构成 §4 的 3-method、报结对账策略族。
3.3 现状:同一套规则被写了 4 遍
| # | 位置 | 职责 | 内容 |
|---|---|---|---|
| 1 | pay.py:177-288 | 下单前算价 | 校验 + 算 pay_amount + 算到期日 + 合并功能点 |
| 2 | pay.py:522-613 | 二次支付算价 | 几乎逐行复制第 1 处 |
| 3 | pay_callback.py:134-204 | 支付回调履约 | 校验(无)+ 建包/延期/换包 |
| 4 | upgrade_rule ×2 | 差价公式 | admin 一版(365)、payment 一版(按周期) |
这就是「该抽策略却没抽」的证据:四份拷贝里任何一份改动没同步,都会让报价与结算不一致。这不是理论风险——upgrade_rule 已经出现两版并存了。
4. 策略模式落地草稿
4.1 目标
- 把 4 处
trade_type分派收敛到 1 个策略族; - 让报价与履约共用同一个策略对象 → 支付回调时可以反算对账;
- 新增一种交易(降级、加购增量包、试用转正)只需加一个类 + 注册一行,不改执行链路。
4.2 伪代码(可直接照着写)
# app/trade/strategy.py —— 交易策略族
from abc import ABC, abstractmethod
from dataclasses import dataclass
@dataclass
class TradeContext:
"""一次交易的全部上下文,由 prepare() 统一填充"""
company_id: str
product_id: str
trade_type: int
is_extend: bool = False # 升级时是否同时续费
revolution: int = 1 # 续费周期数
# 以下由 prepare() 填
product: dict | None = None # 目标套餐(含 function_info / validity / price / vip_version)
origin: dict | None = None # 现持有包(bundle_info + subscription 明细)
left_days: int | None = None # 剩余天数
@dataclass
class Quote:
"""报价单:一次算价的结果,下单与回调共用"""
pay_amount: int # 应付金额(分)
rule_text: str # 计价口径文案(给用户看的「怎么算的」)
next_expiration: str | None # 新到期日
merged_funcs: list | None # 合并后的功能点(仅升级)
@dataclass
class FulfillResult:
bundle_id: str
ban_bundle_id: str | None # 需禁用的旧包
expiration: str | None
class TradeStrategy(ABC):
"""三种交易的公共契约:校验 → 报价 → 履约"""
trade_type: int = 0
@abstractmethod
def validate(self, ctx: TradeContext) -> None:
"""前置校验,不通过抛业务异常"""
@abstractmethod
def quote(self, ctx: TradeContext) -> Quote:
"""报价。下单前算一次,支付回调可再算一次做对账"""
@abstractmethod
def fulfill(self, ctx: TradeContext, quote: Quote,
order_sn: str, pay_amount: int) -> FulfillResult:
"""履约。建包 / 延期 / 换包"""
# ---------- 1 开通 ----------
class SubscribeStrategy(TradeStrategy):
trade_type = 1
def validate(self, ctx):
if ctx.origin and ctx.origin["vip_version"] > 0:
raise ProductConflict("已持有付费套餐,请走升级")
def quote(self, ctx):
p = ctx.product
return Quote(
pay_amount=p["price"],
rule_text=f"{p['price']}(周期计费,{p['validity']}{p['validity_type']})",
next_expiration=ValidityCtrl().validity_with_extend(
p["validity_type"], p["validity"], prod_type=p["prod_type"]),
merged_funcs=None,
)
def fulfill(self, ctx, quote, order_sn, pay_amount):
# 继承免费版已用量:防「买付费版重置额度」
free = find_free_bundle(ctx.company_id, ctx.product["prod_id"])
merged = merge_funcs(ctx.product["function_info"], funcs_of(free)) if free else None
bid = ResourceInfo().create_bundle(
ctx.product_id, ctx.company_id, order_sn, pay_amount,
function_info=merged, expiration_time=quote.next_expiration)
return FulfillResult(bundle_id=bid,
ban_bundle_id=free["bundle_id"] if free else None,
expiration=quote.next_expiration)
# ---------- 2 续费 ----------
class RenewStrategy(TradeStrategy):
trade_type = 2
def validate(self, ctx):
o = ctx.origin
if not o:
raise ProductNotActive("未持有套餐,无法续费")
if o["vip_version"] == 0:
raise FreeProdBuyLimit("免费版不支持续费")
if o["product_id"] != ctx.product_id:
raise ProductConflict("续费须与在用套餐一致")
def quote(self, ctx):
p = ctx.product
exp = ValidityCtrl().validity_with_extend(
p["validity_type"], p["validity"],
revolution=ctx.revolution, is_extend=ctx.is_extend,
prod_type=p["prod_type"], expiration_time=ctx.origin["expiration_time"])
return Quote(pay_amount=p["price"],
rule_text="按周期顺延,不新建资源包",
next_expiration=exp, merged_funcs=None)
def fulfill(self, ctx, quote, order_sn, pay_amount):
# 原地延期:1 个包对 N 个订单
ResourceInfo().renewal(ctx.origin["bundle_id"], order_sn)
return FulfillResult(bundle_id=ctx.origin["bundle_id"],
ban_bundle_id=None,
expiration=quote.next_expiration)
# ---------- 3 升级 ----------
class UpgradeStrategy(TradeStrategy):
trade_type = 3
def validate(self, ctx):
o, p = ctx.origin, ctx.product
if not o:
raise ProductNotActive("未持有套餐,无法升级")
if o["prod_id"] != p["prod_id"]:
raise ProductConflict("非同类产品不可升级")
if o["vip_version"] > p["vip_version"]:
raise NotUpgradeable("不支持降级")
if ctx.left_days < 0:
raise ProdExpired("原套餐已过期")
def quote(self, ctx):
o, p = ctx.origin, ctx.product
new_day = ValidityCtrl().convert_validity_to_day(p["validity_type"], p["validity"])
old_day = ValidityCtrl().convert_validity_to_day(o["validity_type"], o["validity"])
# 日均价差 × 剩余天数;旧公式 (新-原)/365 在月付下失效
amount = int((p["price"] / new_day - o["price"] / old_day) * ctx.left_days)
rule = f"({p['price']}/{new_day} − {o['price']}/{old_day}) × {ctx.left_days}天"
exp = o["expiration_time"]
if ctx.is_extend: # 升级 + 续费
amount += ctx.revolution * p["price"]
rule += f" + {p['price']}×{ctx.revolution}"
exp = ValidityCtrl().validity_with_extend(
p["validity_type"], p["validity"], revolution=ctx.revolution,
is_extend=True, prod_type=p["prod_type"],
expiration_time=o["expiration_time"])
return Quote(
pay_amount=amount, rule_text=rule, next_expiration=exp,
# 额度取新、已用取旧 —— 堵「先刷光再升级」
merged_funcs=merge_funcs(p["function_info"], funcs_of(o["bundle_id"])),
)
def fulfill(self, ctx, quote, order_sn, pay_amount):
bid = ResourceInfo().create_bundle(
ctx.product_id, ctx.company_id, order_sn, pay_amount,
function_info=quote.merged_funcs, expiration_time=quote.next_expiration)
return FulfillResult(bundle_id=bid,
ban_bundle_id=ctx.origin["bundle_id"],
expiration=quote.next_expiration)
# ---------- 注册表 + 工厂 ----------
STRATEGIES: dict[int, TradeStrategy] = {
s.trade_type: s for s in (
SubscribeStrategy(), RenewStrategy(), UpgradeStrategy(),
)
}
def get_strategy(trade_type) -> TradeStrategy:
try:
return STRATEGIES[int(trade_type)]
except (KeyError, TypeError):
raise InvalidArgsError(f"不支持的交易类型: {trade_type}")4.3 调用侧怎么改(关键:报价与履约同一个对象)
# ① 下单(原 pay.py:177-288 的 if/elif 全部消失)
ctx = prepare_ctx(company_id, product_id, trade_type, is_extend, revolution)
st = get_strategy(trade_type)
st.validate(ctx)
quote = st.quote(ctx)
order_sn = create_order(..., pay_amount=quote.pay_amount,
remark={"rule": quote.rule_text, "is_extend": is_extend})
create_payment(ctx.product, order_sn, quote.pay_amount, ...)
# ② 二次支付(原 pay.py:522-613 的副本直接删掉,复用同一段)
ctx = prepare_ctx(...)
quote = get_strategy(trade_type).quote(ctx)
# ③ 支付回调(原 pay_callback.py:134-204 的 if/elif 全部消失)
st = get_strategy(order.trade_type)
quote = st.quote(ctx)
result = st.fulfill(ctx, quote, order_sn, pay_amount)
if result.ban_bundle_id:
ResourceInfo().ban_bundle(result.ban_bundle_id)
bind_order_to_bundle(result.bundle_id, order_sn)
# ④ 新增:报价-结算一致性自检(策略模式换来的真收益)
if quote.pay_amount != order.amount:
alert("报价与结算不一致", order_sn=order_sn,
quoted=quote.pay_amount, paid=order.amount)4.4 改造清单(面试被问「改了哪些文件」时用)
| # | 文件 / 位置 | 现状 | 改造后 |
|---|---|---|---|
| 1 | pay.py:177-288 | 90 行 if/elif 算价 | 4 行调用 |
| 2 | pay.py:522-613 | 又复制一份 | 与 #1 复用同一段 |
| 3 | pay_callback.py:134-204 | 70 行 if/elif 履约 | st.fulfill(...) |
| 4 | upgrade_rule × 2 处 | 两版公式并存(365 / 按周期) | 只在 UpgradeStrategy.quote |
| 5 | 新增 strategy.py | — | 3 个类 + 注册表,约 180 行 |
净效果:删掉约 250 行重复分派,新增约 180 行,且新增一种交易类型的改动从「4 个文件」降到「1 个类 + 1 行注册」。
4.5 为什么这个抽象是安全的(不是为模式而模式)
- 三个策略的接口天然一致:都把
(company, 目标套餐, 现持有包, 剩余天数)变成(应付金额, 新到期日, 要禁用的旧包)。这是同一件事的三种算法,不是硬凑。 - 差异点集中在
quote():开通不算差价、续费只延期、升级算差价 + 合并功能点。分派维度单一,抽象边界清晰。 - 收敛后能做对账:策略对象既报价又履约,支付回调可反算一次比对订单金额——这是改造前结构上做不到的(算价逻辑有 2 份拷贝,不知道以哪份为准)。
这一条是面试最有杀伤力的落点:策略模式在这里的收益不是「好扩展」,而是「让报价与结算有唯一真源,从而可对账」。
5. 付费校验前置:业务侧零计费逻辑
5.1 两跳 HTTP(winpro/comm/gpt/gpt_keys.py:174-197)
def function_points_and_balances(company_id, money=0):
# 第一跳:查权限(额度够不够)
POST /v2/api/main/events/check_access/ {company_id, metric_key: 'balance_payment'}
→ access_info.has_access # 落到 event_track.check_metric_access
# 第二跳:查余额(钱够不够)
GET /v2/api/main/company/balance?company_id=...
→ Data.balance
# 判定
if money: return money <= balance # 预付费模式:余额必须够这次的钱
else: return balance > 0 # 只验「开通了没」业务侧调用点(证明「动作级收费」是真实铺开的):
| 业务 | 单价写法 | 位置 |
|---|---|---|
| 文件翻译 | 0.04 / 0.028(不同语向不同价) | fileTranslate/view.py:461,501,563 |
| OCR | fee_amount_dict.get(str(action_id)) | jjyOCR/view.py:635 |
| 页面操作 | 1 / 0.02 | jjyPageOperator/view.py:291,498 |
| AI 对话 | deduct_amount | neiChatGpt/chat_gpt.py 多处 |
| 立方检查 | amount | cubeJcsk/cube_jcsk_view.py:451 |
业务代码里没有任何计费规则,只有「这次大概多少钱」。这是解耦最干净的一层。
5.2 扣减侧:双轨账级联(event_track.py:138 track_access)
docstring 自己写的优先级:
1. 抵扣剩余次数(资源包额度 subscription.usage)
否则,如果有余额
2. 没有次数,但是传了扣除金额,则抵扣余额
3. 有抵扣次数,没有传余额,根据单价计算,进行抵扣直白说:额度用完 → 自动转按量扣现金余额,不中断执行(update_balance_silence 的注释:「以保证程序执行」)。余额也没有才抛 NotSupportedError。
余额扣减的并发安全(balance.py):
select balance from corp_info WHERE company_id=%s for update # 行锁
update corp_info set balance = balance + %s WHERE company_id=%s # DB 侧原子加法
if float(ob) + float(amount) >= 0: ... # 不允许扣成负数余额告警只在刚跨过阈值那一刻发一次:
if (float(ob) > 1) and (float(balance) <= 1): # 从 >1 掉到 <=1
publisher.publish({'event_type': 'balance_warn'})5.3 速率型:真正的限流
rate 类指标不是查表算的,是用 Redis 滑动窗口实时限流(comm/rate_limiter.py):
from limits import storage, parse, strategies
move_win = strategies.MovingWindowRateLimiter(storage.RedisStorage(redis_url))
move_win.hit(rate_limit, identifier) # identifier = f"{company_id}-{desc_key}"check_metric_access 里对 rate 的处理是检查即记录(查一次就等于消耗一次窗口额度)。
5.4 多包合并的 any / all 不对称(真实设计洞察)
event_track.py:496-525:
| 场景 | 聚合方式 | 为什么 |
|---|---|---|
同一指标在多个资源包里(count/sum/basic) | any()——任一包有余量就放行 | 额度是可叠加的:主套餐用完,增量包还能顶上 |
同一指标是 rate 型 | all()——所有包都必须不超速 | 速率是共享同一个物理上限,取最严的那个 |
多指标同时检查(is_mix_check) | all() | 全部满足才算通过 |
这个 any/all 的不对称不是随手写的:额度型资源可以加总,速率型不能加总(买两个包不会让第三方接口的 QPS 变两倍)。这是计费系统里最容易写错、也最能体现「真做过」的一处。
5.5 主控指标一票否决
is_main_ctrl=1 的指标没额度 → 同 bundle_id 下所有指标强制置 False(event_track.py:459-464)。这是「套餐整体停服」的开关,避免逐个指标去关。
5.6 付费状态 → 权限系统:钱和「能不能用」是两套账
计费系统管钱,权限系统管能不能调用,两者靠「激活 / 禁用」这个动作同步。
| 方向 | 动作 | 代码 |
|---|---|---|
| 付费成功 → 授予 | 先查是否已激活(幂等),再给企业建角色 plugin_{company_id}_role 并授予产品资源权限 | plugin.py:683 add_permission_for_company,由 pay_callback.py:211-218 触发 |
| 禁用 / 过期 → 回收 | 遍历企业权限列表按 prod_id 匹配删除 | plugin.py:704 remove_permission_of_company,由运营 costlogic.py 的 BundlesDetail.patch 触发 |
注意它是走权限中台的(PluginPermission.get_company_resources 是 GraphQL 客户端),不是直接写 Casbin 策略表。所以更准确的说法是「付费状态驱动权限中台的角色与策略变更」——Casbin 只是权限中台内部用的模型。
为什么必须这样分层:执行链路每次调用都查一次计费库代价太高,所以权限系统做快速门禁(一次查角色就够),计费系统做精确记账(额度、单价、余额)。两者不一致时以计费库为准,权限侧靠运维手工纠正。
6. 解耦做得好的 / 没做的(技术债清单)
做对了
| 项 | 证据 |
|---|---|
| 业务侧零计费逻辑 | 只调两个 HTTP 接口,单价写死在业务侧(function_points_and_balances) |
| 模板与实例分离 | 改 plan_function 不动存量 subscription |
| 计费服务独立进程 | payment-master 独立 Flask :5005,三个 blueprint |
| 额度耗尽降级不中断 | update_balance_silence 自动转扣余额 |
| 升级不重置已用量 | upgrade_subs 的 bind_value 取新、usage 取旧 |
| 并发安全 | 余额走行锁 + DB 侧原子加法;速率走 Redis 滑动窗口 |
没做到(诚实清单,追问时主动说反而加分)
| 项 | 现状 | 风险 |
|---|---|---|
| 交易策略未抽象 | trade_type 分派 4 处拷贝;upgrade_rule 两版公式并存 | 报价与结算可能不一致 |
| 无事务 | create_bundle 里 sub_inst.create 失败靠手工 delete 补偿;回调全程顺序 SQL,失败只 logger.error | 建包与订单关联非原子 |
| 计费内核两仓库漂移 | payment-master 的 Subscriptions 缺 rate_check_access(admin 侧在 resource.py:818);两版 paymentcalculation.py 已差 618 行(2792 vs 2174) | 同一套规则双份维护,改一处漏一处 |
| 单价两条路径并存 | subscription.per_unit_price 有值,但业务侧仍传硬编码单价(0.04 / 0.028 / 1 / 0.02) | 调价要改代码 |
| 无缓存 | 余额每次直查 DB 且每次新建 pymysql 连接;data_migrate.py:362 的缓存只是注释里的设想 | 高频扣费打 DB |
| 异常路径连接泄漏 | balance.py 的 except 里 rollback() 后还 commit(),且漏了 cursor.close() / con.close() | 长跑可能堆积连接 |
| 审计不留前后值 | costlogic.py 的 record_audit 只有 FIXME: 记录将 a 更新为 b | 改价无法追溯原值 |
| 服务间鉴权用固定 token | pay_token 硬编码在业务侧 | 令牌轮换成本高 |
7. 面试追问应答(14 问)
Q1:你们的计费系统怎么分层的?
四层:指标字典(
metrics,定义有哪些计量维度、按什么方式聚合)→ 套餐模板(plan_function,某个版本含哪些指标和额度)→ 履约实例(company_resource_bundle+subscription,企业手上这个包的额度和已用量)→ 账本流水(余额变动)。分层的意义是改模板不动存量用户。
Q2:为什么要模板和实例两层,不能一张表?
因为「卖掉了再改规则」是必然发生的。改价格、调额度如果直接动实例,会动摇已付费用户的权益。分离后改模板只影响新订单,存量要走运营手工变更并留审计。代价是运维成本,但避免了合同纠纷。
Q3:付费点有几种?
六类:周期计费(卖套餐)、费率计费(按次单价)、包次计费(买次数包)、包时计费(按时长)、扣费字段(按第三方返回的实际用量扣)、余额抵扣(直接扣钱包)。前一种是卖版本,后五种是卖动作——单个连接器动作就是一个收费点。
Q4:策略模式具体怎么用的?
三种交易(开通 / 续费 / 升级)各一个策略类,统一契约是
validate → quote → fulfill。开通是「建新包 + 继承免费版已用量」,续费是「原地延期、一个包对多个订单」,升级是「合功能点 + 建新包 + 禁用旧包 + 到期日不变」。 关键收益:同一个策略对象既用于下单报价、又用于回调履约,报价与结算共用一份规则,所以支付回调时可以反算一次做对账。改造前算价有 2 份拷贝,结构上做不到对账。
Q5:抽策略的边界怎么定的?
分派维度只有
trade_type一个,三个策略的输入输出天然一致(输入公司 + 目标套餐 + 现持有包 + 剩余天数,输出应付金额 + 新到期日 + 要禁用的旧包),差异集中在算价那一步。所以不算硬凑。
Q6:新增一种交易类型要改什么?
加一个类实现三个方法,注册表里加一行。改造前要改 4 个地方:两处算价、一处履约、一处公式。
Q7:升级时额度怎么算?
bind_value以新套餐为准,usage以旧包的为准——也就是只重置额度,不重置已用量。否则用户可以先把低版本额度刷光再升级,等于白拿一份新额度。开通时继承免费版已用量是同一个漏洞的另一种堵法。
Q8:升级补差价怎么算?
按日均价差乘剩余天数:
(新价/新周期天数 − 原价/原周期天数) × 剩余天数。早先版本是(新价−原价)/365 × 剩余天数,分母写死 365,只适用年付;引入月付后失效,才改成按各自validity_to_day折算。纯升级不改到期日,同时续费才顺延。
Q9:怎么保证不超用?
前置校验:业务侧执行动作前调两个接口,一个查权限额度(
events/check_access)、一个查余额。业务代码里没有任何计费规则,只有「这次大约多少钱」。扣减时先扣资源包额度,额度不够自动按单价折算扣现金余额,保证不中断执行,余额也没了才拒绝。
Q10:一个企业有多个资源包,额度怎么合并?
看指标的
aggregation_type:count/sum求和,max取最大(并发上限这类不能相加)。权限判定上额度型用any(任一包有余量就放行),速率型用all(速率共享同一个物理上限,取最严的)。这个不对称是有意的。
Q11:并发扣费怎么保证不扣成负数?
余额更新走
select ... for update行锁,更新语句是balance = balance + amount让数据库做原子加法,然后在同一事务里判断结果非负。速率型指标用 Redis 滑动窗口(limits库的MovingWindowRateLimiter),按company_id-指标键做 identifier。
Q12:这套有什么问题?
五个:① 交易策略没抽出来,
trade_type分派散在 4 处,公式还并存两版——这是我最想重构的;② 建包与订单关联没有事务,靠手工补偿;③ 计费单价有两条路径(表里的per_unit_price和业务侧硬编码),调价要改代码;④ 余额每次直查 DB 且新建连接,高频扣费会打数据库;⑤ 计费内核在两个仓库各存一份,已经漂移了——payment 侧的Subscriptions连rate_check_access都没同步过去,两边paymentcalculation差了 600 多行。前两条是架构问题,后三条是工程债,第 5 条的根因是缺一个共享内核包。
Q13:子公司共用主企业的包,额度怎么算?
不复制额度,只授予可见性。主企业正常建包,中间表记一条「企业 ↔ 产品」关系;子公司「开通」时只是把中间表
state置 1、bundle_id指向主企业的包,所以消耗落在同一份usage上。两个坑:一是查询要去重——子公司可能既有自有包、又被共享了同一个包,用 UNION 左表自有、右表共享,共享侧再排掉自己的包,避免算两次;二是取消共享前要检查关联表里还有没有别的企业在用,否则会把别人的服务直接掐掉。另外每个共享关系带priority,决定它和自有包同时存在时的扣减顺序。
Q14:付费之后为什么还要单独做权限?不能每次调用都查计费库吗?
两套账目的不同:权限系统做快速门禁(查一次角色就知道能不能用),计费系统做精确记账(额度、单价、余额)。每次调用都走计费库,一是多一次跨库查询,二是计费的判定比权限重得多(多包聚合、限流窗口、余额折算)。所以付费成功后同步授予角色,禁用或过期时回收;两边不一致时以计费库为准,权限侧靠运维纠正。代价是这个同步点本身要幂等——所以授予前会先查一次是否已经激活。
8. 数据可信度表(区分「代码实证」和「设计意图」)
| 内容 | 可信度 | 依据 |
|---|---|---|
| 6 类计费模式 | 代码实证 | paymentcalculation.py:20-32 CHARGE_TYPES |
category 四类 + aggregation_type 三种 | 代码实证 | resource.py:107 Metrics、event_track.py 分派 |
| 模板 / 实例四层 | 代码实证 | 四张表结构与 create_bundle 的复制关系 |
| 三种交易三路径 | 代码实证 | pay_callback.py:134-204 |
| 升级额度取新、已用取旧 | 代码实证(docstring 明写) | paymentcalculation.py:2142 |
| 差价公式两版演进 | 代码实证 | order.py:193(旧)vs pay.py:58(新) |
| 两跳前置校验 | 代码实证 | gpt_keys.py:174-197 |
| 额度→余额级联扣减 | 代码实证 | event_track.py:138 docstring + update_balance_silence |
| any/all 不对称 | 代码实证 | event_track.py:496-525 |
| 限流用 Redis 滑动窗口 | 代码实证 | comm/rate_limiter.py |
| 共享资源包(多租户共额度) | 代码实证 | SharedBundles + shared_bundles_info,§2.5 |
| 付费状态 ↔ 权限中台联动 | 代码实证 | plugin.py:683/704,由 pay_callback.py:211 与运营禁用触发 |
| 两仓库内核已漂移 | 代码实证 | payment 侧 Subscriptions 缺 rate_check_access;两版 paymentcalculation.py 差 618 行 |
| 交易策略族(策略模式) | 设计方案,未落地 | 本文 §4 草稿;代码现状是 4 处分派 |
| 报价-结算对账 | 设计方案,未落地 | 依赖策略族,见 §4.3 ④ |
⚠️ 面试口径:策略模式这块按「识别出 4 处重复分派 → 收敛为策略族」讲,能讲清抽什么、边界在哪、收益是对账,但不要声称已经上线并量化收益(如「性能提升 xx%」)。被问到「什么时候做的」时按实际回答:当时是
trade_type字段驱动分派,策略族是后续整理出的重构方案。
