Files
jinzuanwork/backend/pay-proto/core.py
T
ywsandClaude Opus 5.5 973afd7886 收款原型并进预览站:下单表单 + 收银台 / 订单页 + 收款后台(参考 Epusdt 收银台、独角数卡浏览器缓存查单)
- 预览站 order.html:模板多选、分辨率、皮肤三色灯(绿放行 / 黄勾无视风险 / 红拦住),吸底金额条;
  「我的订单」= 本机下过的单 + 订单号/取件码查单。
- 新 pay.html:用站点「票据」样式做收银台(爱发电 / 支付宝扫码、二维码 + 倒计时、自动轮询、付好了没反应),
  到账后同页变订单页;超时关闭态;取件码存根、复制订单链接。
- cms/pay.html:收款后台(待办 / 认领 / 渠道熔断 / 订单 / 支付单 / 流水)。演示控制台收进顶部预览横幅。
- 后端:订单记模板 / 分辨率 / 皮肤名,金额按模板数;取件码 10 位好抄;接口挂 /svc/,原型独立页撤掉。
- 测试 26 条;浏览器端到端 22 条(桌面 + 手机)。

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-07 06:58:21 +00:00

332 lines
14 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 '',
templates TEXT DEFAULT '[]', res INTEGER DEFAULT 1000, skin_name 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)
for col, decl in (("templates", "TEXT DEFAULT '[]'"), ("res", "INTEGER DEFAULT 1000"),
("skin_name", "TEXT DEFAULT ''")):
try: # 老库补列
_DB.execute("ALTER TABLE orders ADD COLUMN %s %s" % (col, decl))
except sqlite3.OperationalError:
pass
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(templates=None, res=1000, skin_name="", n_img=None):
"""下单。templates = 模板 key 列表(一张皮肤 × 每个模板出一张);老调用只给 n_img 也行。"""
tpls = [t for t in (templates or []) if t in C.TEMPLATES]
tpls = list(dict.fromkeys(tpls))
if tpls:
n = len(tpls)
else:
n = max(1, min(int(n_img or 1), 20))
res = int(res or 1000) if int(res or 1000) in C.RESOLUTIONS else 1000
oid = "YS" + "".join(secrets.choice("ABCDEFGHJKLMNPQRSTUVWXYZ23456789") for _ in range(6))
tok = "".join(secrets.choice("ABCDEFGHJKLMNPQRSTUVWXYZ23456789") for _ in range(10)) # 取件码:好抄、不混淆
x("INSERT INTO orders(oid,token,state,n_img,amount,created_at,templates,res,skin_name) VALUES(?,?,?,?,?,?,?,?,?)",
(oid, tok, "unpaid", n, n * C.PRICE_UNIT, now(), json.dumps(tpls), res, str(skin_name or "")[:80]))
event("", "order_created", "", oid, "unpaid", {"templates": tpls, "res": res, "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()