Files
jinzuanwork/backend/pay-proto/core.py
T
ywsandClaude Opus 5.5 56c1fa648a 收款原型 pay-proto:渠道抽象层 + 爱发电主通道 + 当面付辅助通道(占位符配置,内置模拟网关)
- 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>
2026-10-07 05:53:12 +00:00

318 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# -*- 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()