收款原型 pay-proto:渠道抽象层 + 爱发电主通道 + 当面付辅助通道(占位符配置,内置模拟网关)

Browse Source
- core:支付单 / 流水 / 待办三张表,统一到账入口 settle_payment()(幂等、金额闸门、迟到恢复、重复付款进待办),
  定时任务:爱发电对账、当面付补查、支付单过期关单、订单超时关闭、迟到付款扫描;演示时钟可快进。
- channels:爱发电(专链 custom_order_id/custom_price、Webhook RSA 验签、query-order 按订单号精确反查);
  当面付(precreate/query/close/refund,请求应用私钥 RSA2 签名、响应与异步通知用支付宝公钥验签;熔断、限额、节奏控制)。
- mockgw:占位符时的模拟爱发电收银台 / 查单接口与模拟支付宝网关 / 扫码页。
- 付款页 + 后台页;场景测试 24 条(本机与甲骨文 ARM 均全过)。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yws
2026-10-07 05:53:12 +00:00
co-authored by Claude Opus 5.5
parent 8fbffd8408
commit 56c1fa648a
11 changed files with 2175 additions and 0 deletions
+317
View File
@@ -0,0 +1,317 @@
# -*- coding: utf-8 -*-
"""支付原型核心:数据库、时钟、统一到账入口 settle_payment()、订单状态机、定时任务。
订单状态:unpaid → waiting(到账)/ closed(超时)/ void(注销);closed → waiting(宽限期内迟到付款)
支付单状态:created → paid / mismatch / closed;closed → paid(迟到);paid / mismatch → refunded
"""
import json, os, secrets, sqlite3, threading, time
import config as C
LOCK = threading.RLock()
_DB = None
# ---------------------------------------------------------------- 时钟(原型可快进,方便演示超时)
def now():
return time.time() + float(kv_get("clock_offset", 0) or 0)
def advance_clock(seconds):
kv_set("clock_offset", float(kv_get("clock_offset", 0) or 0) + seconds)
# ---------------------------------------------------------------- 数据库
SCHEMA = """
CREATE TABLE IF NOT EXISTS orders(
oid TEXT PRIMARY KEY, token TEXT, state TEXT, n_img INTEGER, amount INTEGER,
created_at REAL, paid_at REAL, closed_at REAL, buyer_claim_at REAL, note TEXT DEFAULT '');
CREATE TABLE IF NOT EXISTS payments(
pay_id TEXT PRIMARY KEY, oid TEXT, channel TEXT, amount_due INTEGER, state TEXT,
created_at REAL, expire_at REAL, trade_no TEXT UNIQUE, amount_paid REAL, paid_at REAL,
last_query_at REAL DEFAULT 0, display TEXT DEFAULT '{}', note TEXT DEFAULT '');
CREATE INDEX IF NOT EXISTS pay_oid ON payments(oid);
CREATE TABLE IF NOT EXISTS pay_events(
id INTEGER PRIMARY KEY AUTOINCREMENT, ts REAL, channel TEXT, kind TEXT,
pay_id TEXT, oid TEXT, result TEXT, raw TEXT);
CREATE TABLE IF NOT EXISTS pay_todo(
id INTEGER PRIMARY KEY AUTOINCREMENT, ts REAL, kind TEXT, oid TEXT, pay_id TEXT, channel TEXT,
trade_no TEXT, amount_due REAL, amount_paid REAL, detail TEXT, state TEXT DEFAULT 'open',
resolution TEXT DEFAULT '', resolved_at REAL);
CREATE TABLE IF NOT EXISTS kv(k TEXT PRIMARY KEY, v TEXT);
"""
def db():
global _DB
if _DB is None:
os.makedirs(C.DATA_DIR, exist_ok=True)
_DB = sqlite3.connect(os.path.join(C.DATA_DIR, "pay.db"), check_same_thread=False,
isolation_level=None)
_DB.row_factory = sqlite3.Row
_DB.execute("PRAGMA journal_mode=WAL")
_DB.executescript(SCHEMA)
return _DB
def q(sql, args=()):
with LOCK:
return [dict(r) for r in db().execute(sql, args).fetchall()]
def q1(sql, args=()):
r = q(sql, args)
return r[0] if r else None
def x(sql, args=()):
with LOCK:
return db().execute(sql, args)
def kv_get(k, d=None):
with LOCK:
r = db().execute("SELECT v FROM kv WHERE k=?", (k,)).fetchone()
if not r:
return d
try:
return json.loads(r[0])
except ValueError:
return d
def kv_set(k, v):
x("INSERT INTO kv(k,v) VALUES(?,?) ON CONFLICT(k) DO UPDATE SET v=excluded.v", (k, json.dumps(v)))
def event(channel, kind, pay_id="", oid="", result="", raw=""):
raw = raw if isinstance(raw, str) else json.dumps(raw, ensure_ascii=False)
x("INSERT INTO pay_events(ts,channel,kind,pay_id,oid,result,raw) VALUES(?,?,?,?,?,?,?)",
(now(), channel, kind, pay_id, oid, result, raw[:4096]))
def todo(kind, detail, oid="", pay_id="", channel="", trade_no="", amount_due=None, amount_paid=None):
# 同一笔渠道流水只进一次待办(回调 + 对账可能各报一次)
if trade_no and q1("SELECT id FROM pay_todo WHERE trade_no=? AND kind=?", (trade_no, kind)):
return
x("INSERT INTO pay_todo(ts,kind,oid,pay_id,channel,trade_no,amount_due,amount_paid,detail) "
"VALUES(?,?,?,?,?,?,?,?,?)", (now(), kind, oid, pay_id, channel, trade_no, amount_due, amount_paid, detail))
event(channel, "todo", pay_id, oid, kind, detail)
# ---------------------------------------------------------------- 订单 / 支付单
def new_order(n_img):
n = max(1, min(int(n_img or 1), 20))
oid = "YS" + "".join(secrets.choice("ABCDEFGHJKLMNPQRSTUVWXYZ23456789") for _ in range(6))
tok = secrets.token_urlsafe(12)
x("INSERT INTO orders(oid,token,state,n_img,amount,created_at) VALUES(?,?,?,?,?,?)",
(oid, tok, "unpaid", n, n * C.PRICE_UNIT, now()))
event("", "order_created", "", oid, "unpaid", {"n_img": n, "amount": n * C.PRICE_UNIT})
return get_order(oid)
def get_order(oid):
return q1("SELECT * FROM orders WHERE oid=?", (oid,))
def order_payments(oid):
return q("SELECT * FROM payments WHERE oid=? ORDER BY created_at", (oid,))
def get_payment(pay_id):
return q1("SELECT * FROM payments WHERE pay_id=?", (pay_id,))
def new_payment(order, channel, ttl):
with LOCK:
seq = (q1("SELECT COUNT(*) AS c FROM payments WHERE oid=?", (order["oid"],)) or {}).get("c", 0) + 1
pay_id = "%sP%d" % (order["oid"], seq)
t = now()
x("INSERT INTO payments(pay_id,oid,channel,amount_due,state,created_at,expire_at) VALUES(?,?,?,?,?,?,?)",
(pay_id, order["oid"], channel, order["amount"], "created", t, t + ttl))
event(channel, "payment_created", pay_id, order["oid"], "created", {"amount_due": order["amount"]})
return get_payment(pay_id)
def set_display(pay_id, display):
x("UPDATE payments SET display=? WHERE pay_id=?", (json.dumps(display, ensure_ascii=False), pay_id))
# ---------------------------------------------------------------- 统一到账入口
def settle_payment(channel, pay_id, trade_no, amount_paid, source, raw=""):
"""所有「钱到了」都只走这里。回调、对账、轮询、买家自查、后台认领都调它。
返回 {"result": ...}:
activated 首次到账,订单激活
reopened 订单已超时关闭,但在宽限期内 → 恢复并激活
dup_trade 这笔渠道流水已经处理过(幂等,什么都不做)
already 这张支付单早就到账了,这次是另一笔钱 → 待办「重复付款」
short 金额不足 → 待办
late 超过宽限才付 / 订单已注销 → 待办
duplicate 订单已经被别的支付单激活过 → 待办「重复付款」
unknown 对不上本地支付单 → 待办
"""
trade_no = str(trade_no or "")
to_close = []
with LOCK:
conn = db()
conn.execute("BEGIN IMMEDIATE")
try:
if trade_no and conn.execute("SELECT 1 FROM payments WHERE trade_no=?", (trade_no,)).fetchone():
conn.execute("COMMIT")
event(channel, "settle", pay_id, "", "dup_trade", {"trade_no": trade_no, "source": source})
return {"result": "dup_trade"}
p = conn.execute("SELECT * FROM payments WHERE pay_id=?", (pay_id,)).fetchone()
if not p:
conn.execute("COMMIT")
todo("unknown", "渠道报了一笔对不上本地支付单的到账(%s)" % pay_id, "", pay_id, channel,
trade_no, None, amount_paid)
return {"result": "unknown"}
p = dict(p)
oid = p["oid"]
if p["state"] in ("paid", "refunded"):
conn.execute("COMMIT")
todo("duplicate", "同一张支付单又来了一笔钱(第一笔 %s)" % p["trade_no"], oid, pay_id, channel,
trade_no, p["amount_due"], amount_paid)
return {"result": "already"}
if float(amount_paid or 0) + 0.005 < float(p["amount_due"]):
conn.execute("UPDATE payments SET state='mismatch',trade_no=?,amount_paid=?,paid_at=?,note=? "
"WHERE pay_id=?", (trade_no or None, amount_paid, now(), "金额不足", pay_id))
conn.execute("COMMIT")
todo("short", "实付 ¥%s,应付 ¥%s,未激活" % (amount_paid, p["amount_due"]), oid, pay_id,
channel, trade_no, p["amount_due"], amount_paid)
return {"result": "short"}
conn.execute("UPDATE payments SET state='paid',trade_no=?,amount_paid=?,paid_at=?,note=? WHERE pay_id=?",
(trade_no or None, amount_paid, now(), "到账(%s)" % source, pay_id))
o = dict(conn.execute("SELECT * FROM orders WHERE oid=?", (oid,)).fetchone())
if o["state"] == "unpaid":
res = "activated"
elif o["state"] == "closed" and now() - float(o["closed_at"] or 0) <= C.LATE_GRACE:
res = "reopened"
elif o["state"] in ("closed", "void"):
res = "late"
else:
res = "duplicate"
if res in ("activated", "reopened"):
conn.execute("UPDATE orders SET state='waiting',paid_at=? WHERE oid=?", (now(), oid))
to_close = [dict(r) for r in conn.execute(
"SELECT * FROM payments WHERE oid=? AND state='created' AND pay_id<>?", (oid, pay_id))]
conn.execute("UPDATE payments SET state='closed',note='订单已在别的支付单付过' "
"WHERE oid=? AND state='created' AND pay_id<>?", (oid, pay_id))
conn.execute("COMMIT")
except Exception:
conn.execute("ROLLBACK")
raise
event(channel, "settle", pay_id, oid, res, {"trade_no": trade_no, "amount": amount_paid, "source": source})
if res == "late":
todo("late", "订单已%s,超过宽限才到账" % ("注销" if o["state"] == "void" else "关闭"), oid, pay_id,
channel, trade_no, p["amount_due"], amount_paid)
elif res == "duplicate":
todo("duplicate", "订单已经付过(状态 %s),这笔是重复付款" % o["state"], oid, pay_id, channel,
trade_no, p["amount_due"], amount_paid)
if to_close:
import channels
for op in to_close:
channels.safe_close(op)
return {"result": res}
# ---------------------------------------------------------------- 定时任务
def job_afdian_reconcile():
import channels
ch = channels.get("afdian")
oldest = q1("SELECT MIN(created_at) AS t FROM payments WHERE channel='afdian' AND "
"(state='created' OR (state='closed' AND created_at>?))", (now() - C.LATE_GRACE,))
if not oldest or not oldest.get("t"):
return 0
n = 0
for f in ch.list_paid_since(oldest["t"] - 600):
if f.get("pay_id"):
p = get_payment(f["pay_id"])
if p and p["state"] in ("created", "closed"):
r = settle_payment("afdian", f["pay_id"], f["trade_no"], f["amount"], "reconcile", f.get("raw", ""))
n += r["result"] in ("activated", "reopened")
return n
def job_alipay_poll():
import channels
ch = channels.get("alipay")
t = now()
rows = q("SELECT * FROM payments WHERE channel='alipay' AND state='created' AND created_at<? AND last_query_at<?",
(t - 60, t - 30))
for p in rows:
poll_payment(ch, p, "poll")
return len(rows)
def poll_payment(ch, p, source):
x("UPDATE payments SET last_query_at=? WHERE pay_id=?", (now(), p["pay_id"]))
f = ch.query(p)
if f and f.get("paid"):
return settle_payment(ch.name, p["pay_id"], f["trade_no"], f["amount"], source, f.get("raw", ""))
return {"result": "unpaid"}
def job_expire_payments():
import channels
rows = q("SELECT * FROM payments WHERE state='created' AND expire_at<=?", (now(),))
for p in rows:
ch = channels.get(p["channel"])
f = ch.query(p) # 关单前最后查一次,防止「刚付就被关」
if f and f.get("paid"):
settle_payment(ch.name, p["pay_id"], f["trade_no"], f["amount"], "expire_check", f.get("raw", ""))
continue
x("UPDATE payments SET state='closed',note='过期' WHERE pay_id=? AND state='created'", (p["pay_id"],))
channels.safe_close(p)
event(ch.name, "payment_expired", p["pay_id"], p["oid"], "closed")
return len(rows)
def job_close_orders():
t = now()
rows = q("SELECT * FROM orders WHERE state='unpaid' AND created_at<=?", (t - C.ORDER_TTL,))
n = 0
for o in rows:
if q1("SELECT 1 AS y FROM payments WHERE oid=? AND state='created'", (o["oid"],)):
continue
x("UPDATE orders SET state='closed',closed_at=? WHERE oid=? AND state='unpaid'", (t, o["oid"]))
event("", "order_closed", "", o["oid"], "closed", "超过 %d 小时未付款" % (C.ORDER_TTL // 3600))
n += 1
return n
def job_late_scan():
"""最近宽限期内关闭的当面付支付单再查一次,抓迟到付款(爱发电的由对账覆盖)。"""
import channels
ch = channels.get("alipay")
rows = q("SELECT * FROM payments WHERE channel='alipay' AND state='closed' AND created_at>? AND last_query_at<?",
(now() - C.LATE_GRACE, now() - 600))
for p in rows:
poll_payment(ch, p, "late_scan")
return len(rows)
JOBS = [("爱发电对账", job_afdian_reconcile), ("当面付补查", job_alipay_poll),
("支付单过期", job_expire_payments), ("订单超时关闭", job_close_orders), ("迟到付款扫描", job_late_scan)]
def run_jobs():
out = {}
for name, fn in JOBS:
try:
out[name] = fn()
except Exception as e: # 单个任务失败不影响其他任务
out[name] = "错误:%r" % e
event("", "job_error", "", "", name, repr(e))
return out
def scheduler():
while True:
time.sleep(C.JOB_TICK)
run_jobs()
def start_scheduler():
threading.Thread(target=scheduler, daemon=True).start()