收款原型 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
+2
View File
@@ -0,0 +1,2 @@
data/
__pycache__/
+36
View File
@@ -0,0 +1,36 @@
# 收款原型(pay-proto)
设计文档里「渠道抽象层 + 爱发电主通道 + 当面付辅助通道」的可运行原型。
标准库 + SQLite + `cryptography`,只绑 127.0.0.1,由 nginx 反代。
## 占位符
`config.py` 里所有账号 / 密钥都是 `<占位符>`。值还是占位符的渠道,自动接到内置的**模拟网关**(`mockgw.py`):
签名、验签、HTTP 调用都是真实代码,只是对面换成模拟的爱发电 / 支付宝。填上真实值(环境变量)即切到真渠道。
| 环境变量 | 说明 |
|---|---|
| `AFDIAN_USER_ID` / `AFDIAN_TOKEN` | 爱发电开放接口(query-order 的 md5 签名) |
| `AFDIAN_PUBKEY_FILE` | 爱发电 Webhook 验签公钥(PEM) |
| `AFDIAN_PLAN_ID` | 承载 `custom_price` 的「自选金额」方案 |
| `ALIPAY_APP_ID` | 当面付应用 AppID |
| `ALIPAY_APP_PRIVATE_KEY_FILE` | 应用私钥(PEM,权限 600,只放服务器) |
| `ALIPAY_PUBLIC_KEY_FILE` | 支付宝公钥(验响应 / 异步通知) |
| `PAY_ADMIN_TOKEN` | 后台口令;占位符时首次启动自动生成到 `data/admin_token` |
| `PAY_BASE_URL` / `PAY_PORT` / `PAY_DATA_DIR` | 对外地址 / 端口 / 数据目录 |
## 结构
- `core.py`:数据库、演示时钟、统一到账入口 `settle_payment()`、定时任务(爱发电对账 / 当面付补查 / 支付单过期 / 订单超时 / 迟到扫描)
- `channels.py`:渠道抽象层,`Afdian`、`AlipayF2F`(create / verify_notify / query / close / refund)
- `mockgw.py`:模拟网关(只在占位符时用)
- `app.py`:HTTP 服务;`static/`:付款页、后台页、二维码库(qrcode-generator 1.4.4,MIT)
## 测试
`python3 tests/test_proto.py`:临时目录起一份服务,从 HTTP 层打 24 个场景。
## 预览部署(甲骨文 ARM)
`/opt/jz-pay-proto` + systemd `jz-pay-proto`(DynamicUser,数据 `/var/lib/jz-pay-proto`),
nginx `jz-preview.conf` 里 `/pay-proto/` 反代到 `127.0.0.1:18100`。
+363
View File
@@ -0,0 +1,363 @@
# -*- coding: utf-8 -*-
"""支付原型 HTTP 服务(标准库,只绑 127.0.0.1,由 nginx 反代到 /pay-proto/)。
买家: POST api/order · GET api/order · POST api/pay · GET api/pay · POST api/check
回调: POST api/notify/afdian · POST api/notify/alipay
后台: api/admin/*(请求头 X-Admin-Token)
演示: api/demo/*(快进时钟、立即跑定时任务、模拟场景 —— 只在原型里有)
模拟网关:mock/afdian/* · mock/alipay/*
"""
import json, mimetypes, os, secrets, sys, urllib.parse
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import config as C # noqa: E402
import core # noqa: E402
import channels # noqa: E402
import mockgw # noqa: E402
STATIC = os.path.join(C.HERE, "static")
STATE_TEXT = {"unpaid": "待付款", "waiting": "已到账 · 排队中", "working": "渲染中", "done": "已完成",
"failed": "渲染失败", "closed": "已关闭(超时未付)", "void": "已注销"}
PAY_TEXT = {"created": "等待付款", "paid": "已到账", "mismatch": "金额不足", "closed": "已关闭", "refunded": "已退款"}
def admin_token():
if not C.is_placeholder(C.ADMIN_TOKEN):
return C.ADMIN_TOKEN
p = os.path.join(C.DATA_DIR, "admin_token")
if not os.path.exists(p):
os.makedirs(C.DATA_DIR, exist_ok=True)
with open(p, "w") as f:
f.write(secrets.token_urlsafe(18))
os.chmod(p, 0o600)
return open(p).read().strip()
# ---------------------------------------------------------------- 视图
def pay_view(p, with_display=True):
d = {k: p[k] for k in ("pay_id", "channel", "state", "amount_due", "amount_paid", "trade_no",
"created_at", "expire_at", "paid_at", "note")}
d["state_text"] = PAY_TEXT.get(p["state"], p["state"])
d["display"] = json.loads(p["display"] or "{}") if (with_display and p["state"] == "created") else {}
return d
def order_view(o):
pays = core.order_payments(o["oid"])
chans = []
for ch in channels.all_channels():
ok, why = ch.available(o)
chans.append({"name": ch.name, "label": ch.label, "ok": ok, "reason": why, "mock": ch.mock})
ev = core.q("SELECT ts,channel,kind,pay_id,result FROM pay_events WHERE oid=? OR pay_id LIKE ? "
"ORDER BY id DESC LIMIT 40", (o["oid"], o["oid"] + "P%"))
return {"ok": True, "now": core.now(), "order": {
"oid": o["oid"], "state": o["state"], "state_text": STATE_TEXT.get(o["state"], o["state"]),
"n_img": o["n_img"], "amount": o["amount"], "created_at": o["created_at"], "paid_at": o["paid_at"],
"closed_at": o["closed_at"], "expire_at": o["created_at"] + C.ORDER_TTL},
"payments": [pay_view(p) for p in pays], "channels": chans, "events": ev,
"params": {"qr_ttl": C.QR_TTL, "order_ttl": C.ORDER_TTL, "late_grace": C.LATE_GRACE,
"ali_max": C.ALI_MAX_AMOUNT}}
# ---------------------------------------------------------------- 动作
def create_payment(o, chname):
if o["state"] != "unpaid":
return {"ok": False, "error": "订单现在是「%s」,不能再付款" % STATE_TEXT.get(o["state"], o["state"])}
ch = channels.get(chname)
ok, why = ch.available(o)
if not ok:
return {"ok": False, "error": why}
for p in core.order_payments(o["oid"]): # 同渠道还有没过期的支付单 → 直接复用
if p["channel"] == chname and p["state"] == "created" and p["expire_at"] > core.now() + 30:
return {"ok": True, "payment": pay_view(p)}
p = core.new_payment(o, chname, ch.ttl())
try:
disp = ch.create(o, p)
except Exception as e:
core.x("UPDATE payments SET state='closed',note=? WHERE pay_id=?", ("创建失败:%s" % e, p["pay_id"]))
core.event(chname, "create_failed", p["pay_id"], o["oid"], "error", repr(e))
return {"ok": False, "error": "%s暂时不可用,请换爱发电付款" % ch.label}
core.set_display(p["pay_id"], disp)
return {"ok": True, "payment": pay_view(core.get_payment(p["pay_id"]))}
def buyer_check(o):
"""买家点「付好了没反应?」→ 立刻把这单所有没到账的支付单查一遍。"""
core.x("UPDATE orders SET buyer_claim_at=? WHERE oid=?", (core.now(), o["oid"]))
core.event("", "buyer_check", "", o["oid"], "requested")
found = []
for p in core.order_payments(o["oid"]):
if p["state"] in ("created", "closed"):
try:
r = core.poll_payment(channels.get(p["channel"]), p, "buyer_check")
found.append(r["result"])
except Exception as e:
core.event(p["channel"], "query_failed", p["pay_id"], o["oid"], "error", repr(e))
o2 = core.get_order(o["oid"])
if o2["state"] == "waiting":
return {"ok": True, "found": True, "msg": "找到了,已到账 —— 正在排队出图"}
if "short" in found:
return {"ok": True, "found": True, "msg": "收到了付款,但金额不足,已通知金钻核对"}
return {"ok": True, "found": False, "msg": "暂时还没查到到账。刚付完可能要等几十秒;超过几分钟还没有,请点「呼叫金钻」。"}
def handle_notify(chname, body, ctype):
ch = channels.get(chname)
try:
facts, why, resp = ch.verify_notify(body, ctype)
except Exception as e:
core.event(chname, "notify", "", "", "error", repr(e))
return resp_default(chname)
core.event(chname, "notify", (facts or {}).get("pay_id", ""), "", why,
body.decode("utf-8", "replace") if isinstance(body, bytes) else str(body))
if facts:
if not facts["pay_id"]:
# 没带 custom_order_id:买家直接在爱发电店铺下的单 → 按「买卡密」处理(正式版沿用现有发码逻辑)
core.event(chname, "card_purchase", "", "", "(原型)会按实付金额发一张卡密",
{"trade_no": facts["trade_no"], "amount": facts["amount"]})
else:
core.settle_payment(chname, facts["pay_id"], facts["trade_no"], facts["amount"], "notify", facts["raw"])
return resp
def resp_default(chname):
return json.dumps({"ec": 200, "em": ""}) if chname == "afdian" else "fail"
def admin_overview():
return {"ok": True, "now": core.now(), "clock_offset": core.kv_get("clock_offset", 0),
"todo": core.q("SELECT * FROM pay_todo ORDER BY state='done', id DESC LIMIT 100"),
"payments": [dict(pay_view(p, False), oid=p["oid"]) for p in
core.q("SELECT * FROM payments ORDER BY created_at DESC LIMIT 60")],
"orders": core.q("SELECT oid,state,amount,created_at,paid_at,closed_at,buyer_claim_at FROM orders "
"ORDER BY created_at DESC LIMIT 40"),
"events": core.q("SELECT * FROM pay_events ORDER BY id DESC LIMIT 80"),
"breaker": channels.get("alipay").breaker(),
"channels": [{"name": c.name, "label": c.label, "mock": c.mock} for c in channels.all_channels()],
"mock_alipay_risk": bool(core.kv_get("mock_alipay_risk"))}
def admin_todo(d):
t = core.q1("SELECT * FROM pay_todo WHERE id=?", (int(d.get("id") or 0),))
if not t:
return {"ok": False, "error": "没有这条待办"}
act, note = d.get("action"), str(d.get("note") or "")[:200]
p = core.get_payment(t["pay_id"]) if t["pay_id"] else None
msg = ""
if act == "confirm": # 金额不足 → 人工确认补齐,按到账处理
if not p:
return {"ok": False, "error": "这条待办没有关联支付单"}
core.x("UPDATE payments SET state='paid',note='人工确认补齐' WHERE pay_id=?", (p["pay_id"],))
core.x("UPDATE orders SET state='waiting',paid_at=? WHERE oid=? AND state IN ('unpaid','closed')",
(core.now(), p["oid"]))
msg = "已确认,订单激活"
elif act == "activate":
core.x("UPDATE orders SET state='waiting',paid_at=? WHERE oid=? AND state IN ('unpaid','closed','void')",
(core.now(), t["oid"]))
msg = "订单已手动激活"
elif act == "refund":
if not p:
return {"ok": False, "error": "这条待办没有关联支付单"}
amt = float(t["amount_paid"] or p["amount_paid"] or 0)
try:
ch = channels.get(p["channel"])
if t["kind"] == "duplicate" and t["trade_no"] and t["trade_no"] != p["trade_no"]:
return {"ok": False, "error": "重复付款的第二笔不在本地支付单上:请到%s后台按交易号 %s 退款" % (ch.label, t["trade_no"])}
ch.refund(p, amt)
core.x("UPDATE payments SET state='refunded',note='已退款 ¥%.2f' WHERE pay_id=?" % amt, (p["pay_id"],))
msg = "已退款 ¥%.2f" % amt
except Exception as e:
return {"ok": False, "error": str(e)}
elif act != "ignore":
return {"ok": False, "error": "不认识的操作"}
core.x("UPDATE pay_todo SET state='done',resolution=?,resolved_at=? WHERE id=?",
("%s:%s %s" % (act, msg, note), core.now(), t["id"]))
core.event(t["channel"] or "", "todo_resolved", t["pay_id"] or "", t["oid"] or "", act, note)
return {"ok": True, "msg": msg or "已处理"}
def admin_claim(d):
"""按爱发电订单号认领到某张订单(买家没走专链、或 custom_order_id 丢了)。"""
o = core.get_order(str(d.get("oid") or "").upper())
if not o:
return {"ok": False, "error": "没有这张订单"}
ch = channels.get("afdian")
real = ch.query_trade(str(d.get("trade_no") or "").strip())
if not real:
return {"ok": False, "error": "爱发电查不到这个订单号"}
f = ch.facts(real)
if not f["paid"]:
return {"ok": False, "error": "这笔爱发电订单还没付款"}
p = core.new_payment(o, "afdian", ch.ttl())
r = core.settle_payment("afdian", p["pay_id"], f["trade_no"], f["amount"], "admin_claim", f["raw"])
return {"ok": True, "msg": "认领结果:%s" % r["result"]}
def demo(d):
k = d.get("kind")
if k == "clock":
core.advance_clock(float(d.get("seconds") or 0))
return {"ok": True, "jobs": core.run_jobs()}
if k == "jobs":
return {"ok": True, "jobs": core.run_jobs()}
if k == "alipay_risk":
core.kv_set("mock_alipay_risk", bool(d.get("on")))
return {"ok": True}
if k == "breaker_reset":
core.kv_set("alipay_breaker", {"fails": 0, "open_until": 0, "reason": ""})
return {"ok": True}
if k == "afdian_direct":
o = mockgw.afd_create_order("", d.get("amount") or 12, "直接在爱发电店铺下单(没带订单号)")
return {"ok": True, "trade_no": o["out_trade_no"]}
if k == "afdian_forge":
fake = {"out_trade_no": "FORGED" + secrets.token_hex(4), "custom_order_id": str(d.get("pay_id") or ""),
"user_id": "evil", "plan_id": "mock-plan", "total_amount": "999.00", "status": 2,
"remark": "", "create_time": int(core.now())}
return {"ok": True, "result": mockgw.afd_push(fake, forge=True)}
return {"ok": False, "error": "unknown"}
# ---------------------------------------------------------------- HTTP
class H(BaseHTTPRequestHandler):
server_version = "jz-pay-proto"
def log_message(self, fmt, *a):
pass
def send(self, code, ctype, body, extra=None):
if isinstance(body, str):
body = body.encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", ctype)
self.send_header("Content-Length", str(len(body)))
self.send_header("Cache-Control", "no-store")
for k, v in (extra or {}).items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(body)
def js(self, obj, code=200):
self.send(code, "application/json; charset=utf-8", json.dumps(obj, ensure_ascii=False))
def body(self):
n = int(self.headers.get("Content-Length") or 0)
return self.rfile.read(min(n, 65536)) if n > 0 else b""
def jbody(self):
try:
return json.loads(self.body() or b"{}")
except ValueError:
return {}
def order_auth(self, oid, tok):
o = core.get_order(str(oid or "").upper())
if not o or not secrets.compare_digest(o["token"], str(tok or "")):
return None
return o
def is_admin(self):
return secrets.compare_digest(self.headers.get("X-Admin-Token") or "", admin_token())
def static(self, name):
p = os.path.normpath(os.path.join(STATIC, name))
if not p.startswith(STATIC + os.sep) or not os.path.isfile(p):
return self.send(404, "text/plain; charset=utf-8", "not found")
ctype = (mimetypes.guess_type(p)[0] or "application/octet-stream")
if ctype.startswith("text/") or ctype.endswith("javascript"):
ctype += "; charset=utf-8"
with open(p, "rb") as f:
self.send(200, ctype, f.read())
def do_GET(self):
u = urllib.parse.urlparse(self.path)
p, qs = u.path, urllib.parse.parse_qs(u.query)
g = lambda k: (qs.get(k) or [""])[0]
try:
if p in ("/", "/index.html"):
return self.static("index.html")
if p in ("/admin", "/admin.html"):
return self.static("admin.html")
if p.startswith("/static/"):
return self.static(p[len("/static/"):])
if p == "/api/order":
o = self.order_auth(g("oid"), g("t"))
return self.js(order_view(o)) if o else self.js({"ok": False, "error": "订单不存在"}, 404)
if p == "/api/pay":
pay = core.get_payment(g("pay_id"))
o = self.order_auth(pay["oid"] if pay else "", g("t"))
if not (pay and o):
return self.js({"ok": False, "error": "支付单不存在"}, 404)
gap = C.QUERY_MIN_GAP if pay["channel"] == "alipay" else 15
if pay["state"] == "created" and core.now() - (pay["last_query_at"] or 0) >= gap:
try:
core.poll_payment(channels.get(pay["channel"]), pay, "page_poll")
except Exception as e:
core.event(pay["channel"], "query_failed", pay["pay_id"], o["oid"], "error", repr(e))
return self.js(order_view(core.get_order(o["oid"])))
if p == "/api/admin/overview":
return self.js(admin_overview()) if self.is_admin() else self.js({"ok": False, "error": "口令不对"}, 403)
if p == "/mock/afdian/order/create":
return self.send(*mockgw.afd_checkout(qs))
if p.startswith("/mock/alipay/scan/"):
return self.send(*mockgw.ali_scan(p.rsplit("/", 1)[-1]))
return self.send(404, "text/plain; charset=utf-8", "not found")
except Exception as e:
core.event("", "http_error", "", "", p, repr(e))
return self.js({"ok": False, "error": "服务器出错了"}, 500)
def do_POST(self):
p = urllib.parse.urlparse(self.path).path
try:
if p == "/api/order":
o = core.new_order(self.jbody().get("n_img"))
return self.js(dict(order_view(o), token=o["token"]))
if p in ("/api/pay", "/api/check"):
d = self.jbody()
o = self.order_auth(d.get("oid"), d.get("t"))
if not o:
return self.js({"ok": False, "error": "订单不存在"}, 404)
return self.js(create_payment(o, d.get("channel")) if p == "/api/pay" else buyer_check(o))
if p == "/api/notify/afdian":
return self.send(200, "application/json", handle_notify("afdian", self.body(), self.headers.get("Content-Type")))
if p == "/api/notify/alipay":
return self.send(200, "text/plain", handle_notify("alipay", self.body(), self.headers.get("Content-Type")))
if p.startswith("/api/admin/"):
if not self.is_admin():
return self.js({"ok": False, "error": "口令不对"}, 403)
d = self.jbody()
if p == "/api/admin/todo":
return self.js(admin_todo(d))
if p == "/api/admin/claim":
return self.js(admin_claim(d))
return self.js({"ok": False, "error": "unknown"}, 404)
if p == "/api/demo":
return self.js(demo(self.jbody()))
if p == "/mock/afdian/order/pay":
return self.send(*mockgw.afd_pay(urllib.parse.parse_qs(self.body().decode())))
if p.startswith("/mock/afdian/api/open/"):
return self.send(*mockgw.afd_api(p, self.body()))
if p == "/mock/alipay/gateway.do":
return self.send(*mockgw.ali_gateway(self.body()))
if p == "/mock/alipay/scanpay":
return self.send(*mockgw.ali_scanpay(urllib.parse.parse_qs(self.body().decode())))
return self.js({"ok": False, "error": "not found"}, 404)
except Exception as e:
core.event("", "http_error", "", "", p, repr(e))
return self.js({"ok": False, "error": "服务器出错了"}, 500)
def main():
core.db()
mockgw.init()
channels.init()
admin_token() # 首次启动就生成后台口令(data/admin_token,600)
core.start_scheduler()
print("支付原型启动 :%d 对外 %s 爱发电=%s 当面付=%s" % (
C.PORT, C.BASE_URL, "模拟" if channels.get("afdian").mock else "真实",
"模拟" if channels.get("alipay").mock else "真实"), flush=True)
ThreadingHTTPServer(("127.0.0.1", C.PORT), H).serve_forever()
if __name__ == "__main__":
main()
+373
View File
@@ -0,0 +1,373 @@
# -*- coding: utf-8 -*-
"""支付渠道抽象层。
每个渠道只做五件事:生成付款方式 create / 验证回调 verify_notify / 主动查单 query / 关单 close / 退款 refund。
到账一律交给 core.settle_payment(),渠道自己不改订单。
「事实」facts = {"pay_id", "trade_no", "amount", "paid", "raw"},只来自验过真的数据。
"""
import base64, hashlib, json, os, re, time, urllib.parse, urllib.request
from datetime import datetime, timedelta, timezone
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.exceptions import InvalidSignature
import config as C
import core
CST = timezone(timedelta(hours=8))
# ---------------------------------------------------------------- RSA 小工具(签名 / 验签分开两把钥匙)
def load_pub(path):
with open(path, "rb") as f:
data = f.read()
if b"BEGIN" not in data: # 支付宝后台给的常是不带头尾的一行 base64
data = b"-----BEGIN PUBLIC KEY-----\n" + data.strip() + b"\n-----END PUBLIC KEY-----\n"
return serialization.load_pem_public_key(data)
def load_priv(path):
with open(path, "rb") as f:
return serialization.load_pem_private_key(f.read(), password=None)
def rsa_sign(priv, text):
return base64.b64encode(priv.sign(text.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())).decode()
def rsa_verify(pub, text, sig_b64):
try:
pub.verify(base64.b64decode(sig_b64 or ""), text.encode("utf-8"), padding.PKCS1v15(), hashes.SHA256())
return True
except (InvalidSignature, ValueError, TypeError):
return False
def http_post(url, body, ctype, timeout=10):
req = urllib.request.Request(url, data=body, method="POST", headers={"Content-Type": ctype})
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.read().decode("utf-8")
def fmt_cst(ts):
return datetime.fromtimestamp(ts, CST).strftime("%Y-%m-%d %H:%M:%S")
# ---------------------------------------------------------------- 基类
class Channel:
name = ""
label = ""
mock = False
def available(self, order):
return True, ""
def ttl(self):
return 3600
def create(self, order, pay):
raise NotImplementedError
def verify_notify(self, body, ctype):
"""返回 (facts 或 None, 说明, 给渠道的应答文本)"""
raise NotImplementedError
def query(self, pay):
return None
def close(self, pay):
return True
def refund(self, pay, amount):
raise RuntimeError("这个渠道不支持接口退款")
# ================================================================ 爱发电
class Afdian(Channel):
name, label = "afdian", "爱发电"
def __init__(self):
cfg = dict(C.AFDIAN)
self.mock = any(C.is_placeholder(v) for v in cfg.values())
if self.mock:
import mockgw
cfg.update(user_id="mock-user", token="mock-token", plan_id="mock-plan",
pubkey_file=mockgw.key_path("afdian_platform", public=True),
api=C.INTERNAL_URL + "/mock/afdian/api/open",
checkout=C.BASE_URL + "/mock/afdian/order/create")
self.cfg = cfg
self.pub = load_pub(cfg["pubkey_file"]) if os.path.exists(cfg["pubkey_file"]) else None
def ttl(self):
return C.AFD_TTL
def create(self, order, pay):
qs = urllib.parse.urlencode({"user_id": self.cfg["user_id"], "plan_id": self.cfg["plan_id"],
"product_type": 0, "custom_price": pay["amount_due"],
"custom_order_id": pay["pay_id"], "remark": order["oid"]})
url = self.cfg["checkout"] + "?" + qs
return {"type": "redirect", "url": url, "qr": url}
# ---- OpenAPI:sign = md5(token + "params" + params + "ts" + ts + "user_id" + user_id)
def api(self, path, params):
p = json.dumps(params, separators=(",", ":"))
ts = int(time.time())
sign = hashlib.md5(("%sparams%sts%duser_id%s" % (self.cfg["token"], p, ts, self.cfg["user_id"]))
.encode()).hexdigest()
body = json.dumps({"user_id": self.cfg["user_id"], "params": p, "ts": ts, "sign": sign}).encode()
r = json.loads(http_post(self.cfg["api"] + "/" + path, body, "application/json"))
if r.get("ec") != 200:
raise RuntimeError("爱发电接口错误:%s %s" % (r.get("ec"), r.get("em")))
return r.get("data") or {}
@staticmethod
def facts(o):
return {"pay_id": str(o.get("custom_order_id") or ""), "trade_no": str(o.get("out_trade_no") or ""),
"amount": float(o.get("total_amount") or 0), "paid": int(o.get("status") or 0) == 2,
"raw": json.dumps(o, ensure_ascii=False)[:2000]}
def query_trade(self, out_trade_no):
lst = (self.api("query-order", {"out_trade_no": out_trade_no}).get("list") or [])
return lst[0] if lst else None
def list_paid_since(self, since_ts, max_pages=10):
"""从最新往前翻,翻到早于 since_ts 为止;只返回已付款的。"""
out = []
for page in range(1, max_pages + 1):
d = self.api("query-order", {"page": page})
lst = d.get("list") or []
for o in lst:
if int(o.get("status") or 0) == 2:
out.append(self.facts(o))
if not lst or page >= int(d.get("total_page") or 1) or \
min(float(o.get("create_time") or 0) for o in lst) < since_ts:
break
return out
def verify_notify(self, body, ctype):
ok_resp = json.dumps({"ec": 200, "em": ""})
try:
obj = json.loads(body or b"{}")
except ValueError:
return None, "报文不是 JSON", ok_resp
data = obj.get("data") or {}
o = data.get("order") or {}
otn = str(o.get("out_trade_no") or "")
if not otn:
return None, "缺 out_trade_no", ok_resp
# ① 验签:out_trade_no + user_id + plan_id + total_amount,平台公钥,SHA256,Base64
if self.pub is not None:
content = "%s%s%s%s" % (otn, o.get("user_id") or "", o.get("plan_id") or "", o.get("total_amount") or "")
if not rsa_verify(self.pub, content, data.get("sign")):
return None, "验签失败", ok_resp
# ② 用开放接口按订单号精确反查,之后只认反查结果
real = self.query_trade(otn)
if not real:
return None, "接口反查不到这笔单", ok_resp
f = self.facts(real)
if not f["paid"]:
return None, "反查结果未付款", ok_resp
return f, "ok", ok_resp
def query(self, pay):
for f in self.list_paid_since(pay["created_at"] - 600, max_pages=5):
if f["pay_id"] == pay["pay_id"]:
return f
return None
def close(self, pay):
return True # 爱发电无法远程关单,只在本地标记
def refund(self, pay, amount):
raise RuntimeError("爱发电没有退款接口:请到爱发电后台对订单 %s 手动退款" % pay.get("trade_no"))
# ================================================================ 支付宝当面付
RISK_CODES = ("ACQ.ACCESS_FORBIDDEN", "ACQ.SELLER_BEEN_BLOCKED", "ACQ.RISK_CONTROL", "isv.insufficient-isv-permissions",
"ACQ.MERCHANT_STATUS_NOT_NORMAL", "ACQ.PAYMENT_AUTH_CODE_INVALID")
class AlipayF2F(Channel):
name, label = "alipay", "支付宝扫码"
def __init__(self):
cfg = dict(C.ALIPAY)
self.mock = any(C.is_placeholder(cfg[k]) for k in ("app_id", "app_private_key_file", "alipay_public_key_file"))
if self.mock:
import mockgw
cfg.update(app_id="mock-app", app_private_key_file=mockgw.key_path("alipay_app"),
alipay_public_key_file=mockgw.key_path("alipay_platform", public=True),
gateway=C.INTERNAL_URL + "/mock/alipay/gateway.do")
self.cfg = cfg
self.priv = load_priv(cfg["app_private_key_file"])
self.pub = load_pub(cfg["alipay_public_key_file"])
def ttl(self):
return C.QR_TTL
# ---- 熔断(连续失败 / 风控类错误码 → 关 6 小时)
def breaker(self):
return core.kv_get("alipay_breaker", {"fails": 0, "open_until": 0, "reason": ""})
def _ok(self):
b = self.breaker()
if b["fails"]:
b["fails"] = 0
core.kv_set("alipay_breaker", b)
def _fail(self, reason, risk=False):
b = self.breaker()
b["fails"] += 1
b["reason"] = reason
if risk or b["fails"] >= C.BREAKER_FAILS:
b["open_until"] = core.now() + C.BREAKER_COOL
core.event("alipay", "breaker_open", "", "", reason, b)
core.kv_set("alipay_breaker", b)
def available(self, order):
b = self.breaker()
if b["open_until"] > core.now():
return False, "支付宝扫码暂时不可用"
if order["amount"] > C.ALI_MAX_AMOUNT:
return False, "金额超过 ¥%d,请用爱发电" % C.ALI_MAX_AMOUNT
t = core.now()
n_order = core.q1("SELECT COUNT(*) AS c FROM payments WHERE oid=? AND channel='alipay' AND created_at>?",
(order["oid"], t - 600))["c"]
if n_order >= C.ALI_PER_ORDER_10MIN:
return False, "二维码生成太频繁,稍后再试或用爱发电"
n_all = core.q1("SELECT COUNT(*) AS c FROM payments WHERE channel='alipay' AND state='created'")["c"]
if n_all >= C.ALI_GLOBAL_PENDING:
return False, "当前扫码人数较多,请用爱发电"
return True, ""
# ---- 网关调用:请求用应用私钥签,响应用支付宝公钥验
def call(self, method, biz, notify=False):
params = {"app_id": self.cfg["app_id"], "method": method, "format": "JSON", "charset": "utf-8",
"sign_type": "RSA2", "timestamp": fmt_cst(time.time()), "version": "1.0",
"biz_content": json.dumps(biz, ensure_ascii=False, separators=(",", ":"))}
if notify:
params["notify_url"] = C.BASE_URL + "/api/notify/alipay"
params["sign"] = rsa_sign(self.priv, "&".join("%s=%s" % (k, params[k]) for k in sorted(params)))
try:
text = http_post(self.cfg["gateway"], urllib.parse.urlencode(params).encode(),
"application/x-www-form-urlencoded;charset=utf-8")
except Exception as e:
self._fail("网关不通:%r" % e)
raise
node = method.replace(".", "_") + "_response"
raw_node = extract_json_node(text, node)
sign = json.loads(text).get("sign")
if raw_node is None or not rsa_verify(self.pub, raw_node, sign):
self._fail("响应验签失败")
raise RuntimeError("支付宝响应验签失败")
r = json.loads(raw_node)
code, sub = str(r.get("code")), str(r.get("sub_code") or "")
if code != "10000" and sub in RISK_CODES:
self._fail("风控/权限:%s %s" % (sub, r.get("sub_msg")), risk=True)
elif code in ("10000", "40004"):
self._ok()
else:
self._fail("%s %s" % (code, sub))
return r
def create(self, order, pay):
r = self.call("alipay.trade.precreate", {
"out_trade_no": pay["pay_id"], "total_amount": "%.2f" % pay["amount_due"],
"subject": "%s %s" % (self.cfg["subject"], order["oid"]),
"time_expire": fmt_cst(core.now() + C.QR_TTL)}, notify=True)
if str(r.get("code")) != "10000":
raise RuntimeError("预下单失败:%s %s" % (r.get("sub_code") or r.get("code"), r.get("sub_msg") or r.get("msg")))
return {"type": "qr", "qr": r["qr_code"], "expire_at": pay["expire_at"]}
def query(self, pay):
r = self.call("alipay.trade.query", {"out_trade_no": pay["pay_id"]})
if str(r.get("code")) != "10000":
return None
st = r.get("trade_status")
return {"pay_id": pay["pay_id"], "trade_no": str(r.get("trade_no") or ""),
"amount": float(r.get("total_amount") or 0), "paid": st in ("TRADE_SUCCESS", "TRADE_FINISHED"),
"raw": json.dumps(r, ensure_ascii=False)}
def close(self, pay):
r = self.call("alipay.trade.close", {"out_trade_no": pay["pay_id"]})
return str(r.get("code")) == "10000" or r.get("sub_code") == "ACQ.TRADE_NOT_EXIST"
def refund(self, pay, amount):
r = self.call("alipay.trade.refund", {"out_trade_no": pay["pay_id"], "refund_amount": "%.2f" % amount,
"out_request_no": "%sR%d" % (pay["pay_id"], int(time.time()))})
if str(r.get("code")) != "10000":
raise RuntimeError("退款失败:%s %s" % (r.get("sub_code"), r.get("sub_msg")))
return r
def verify_notify(self, body, ctype):
form = dict(urllib.parse.parse_qsl((body or b"").decode("utf-8"), keep_blank_values=True))
sign = form.pop("sign", "")
form.pop("sign_type", None)
content = "&".join("%s=%s" % (k, form[k]) for k in sorted(form) if form[k] != "")
if not rsa_verify(self.pub, content, sign):
return None, "验签失败", "fail"
if form.get("app_id") != self.cfg["app_id"]:
return None, "app_id 不符", "fail"
f = {"pay_id": form.get("out_trade_no", ""), "trade_no": form.get("trade_no", ""),
"amount": float(form.get("total_amount") or 0),
"paid": form.get("trade_status") in ("TRADE_SUCCESS", "TRADE_FINISHED"),
"raw": json.dumps(form, ensure_ascii=False)}
if not f["paid"]:
return None, "状态 %s,不是到账" % form.get("trade_status"), "success"
return f, "ok", "success"
def extract_json_node(text, key):
"""取出响应里某个节点的**原始 JSON 文本**(支付宝对原文签名,不能先解析再序列化)。"""
m = re.search(r'"%s"\s*:\s*' % re.escape(key), text)
if not m:
return None
i = m.end()
if i >= len(text) or text[i] != "{":
return None
depth, in_str, esc = 0, False, False
for j in range(i, len(text)):
ch = text[j]
if in_str:
if esc:
esc = False
elif ch == "\\":
esc = True
elif ch == '"':
in_str = False
elif ch == '"':
in_str = True
elif ch == "{":
depth += 1
elif ch == "}":
depth -= 1
if depth == 0:
return text[i:j + 1]
return None
# ---------------------------------------------------------------- 注册表
_CH = {}
def init():
_CH["afdian"] = Afdian()
_CH["alipay"] = AlipayF2F()
def get(name):
return _CH[name]
def all_channels():
return [_CH["afdian"], _CH["alipay"]]
def safe_close(pay):
try:
get(pay["channel"]).close(pay)
core.event(pay["channel"], "close", pay["pay_id"], pay["oid"], "ok")
except Exception as e:
core.event(pay["channel"], "close", pay["pay_id"], pay["oid"], "error", repr(e))
+65
View File
@@ -0,0 +1,65 @@
# -*- coding: utf-8 -*-
"""支付原型的配置。
所有账号 / 密钥都是 <占位符>。值是占位符的渠道自动接到原型内置的「模拟网关」
(mockgw.py:模拟爱发电收银台 + 查单接口、模拟支付宝网关 + 扫码页),
签名、验签、HTTP 调用走的都是真实代码,只是对面换成了模拟器。
填上真实值(环境变量或直接改这里)就切到真渠道。
"""
import os
def env(k, d=""):
return os.environ.get(k, d)
def is_placeholder(v):
return isinstance(v, str) and v.startswith("<") and v.endswith(">")
HERE = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = env("PAY_DATA_DIR", os.path.join(HERE, "data"))
PORT = int(env("PAY_PORT", "18100"))
# 对外地址:拼回调地址、专链、二维码页用(原型挂在预览站 /pay-proto/ 下)
BASE_URL = env("PAY_BASE_URL", "http://127.0.0.1:%d" % PORT).rstrip("/")
# 服务器自己调自己(模拟网关)用的内网地址
INTERNAL_URL = "http://127.0.0.1:%d" % PORT
ADMIN_TOKEN = env("PAY_ADMIN_TOKEN", "<PAY_ADMIN_TOKEN>")
# ---------------- 爱发电(主通道) ----------------
AFDIAN = {
"user_id": env("AFDIAN_USER_ID", "<AFDIAN_USER_ID>"),
"token": env("AFDIAN_TOKEN", "<AFDIAN_TOKEN>"),
# 爱发电开发者后台给的 Webhook 验签公钥(PEM 文件路径)
"pubkey_file": env("AFDIAN_PUBKEY_FILE", "<AFDIAN_PUBKEY_FILE>"),
# 承载 custom_price 的「自选金额」方案
"plan_id": env("AFDIAN_PLAN_ID", "<AFDIAN_PLAN_ID>"),
"api": "https://afdian.com/api/open",
"checkout": "https://afdian.com/order/create",
}
# ---------------- 支付宝当面付(辅助通道) ----------------
ALIPAY = {
"app_id": env("ALIPAY_APP_ID", "<ALIPAY_APP_ID>"),
"app_private_key_file": env("ALIPAY_APP_PRIVATE_KEY_FILE", "<ALIPAY_APP_PRIVATE_KEY_FILE>"),
"alipay_public_key_file": env("ALIPAY_PUBLIC_KEY_FILE", "<ALIPAY_PUBLIC_KEY_FILE>"),
"gateway": "https://openapi.alipay.com/gateway.do",
"subject": "金钻工坊 渲染服务", # 商品名:中性、真实
}
PRICE_UNIT = 6 # 每张图 ¥
# ---------------- 时间参数(秒) ----------------
QR_TTL = 15 * 60 # 当面付二维码有效期
AFD_TTL = 2 * 3600 # 爱发电支付单本地有效期(过期后付款仍能被对账收回)
ORDER_TTL = 24 * 3600 # 订单待付款保留
LATE_GRACE = 72 * 3600 # 订单关闭后,迟到付款自动恢复的宽限
QUERY_MIN_GAP = 5 # 同一张当面付支付单两次查单的最小间隔
JOB_TICK = 60 # 定时任务一轮的间隔
# ---------------- 当面付降风险 ----------------
ALI_MAX_AMOUNT = 500 # 单笔上限,超过只给爱发电
ALI_PER_ORDER_10MIN = 3 # 同一订单 10 分钟内最多生成几个二维码
ALI_GLOBAL_PENDING = 20 # 全站同时未付的当面付二维码上限
BREAKER_FAILS = 3 # 连续失败几次熔断
BREAKER_COOL = 6 * 3600 # 熔断多久
+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()
+283
View File
@@ -0,0 +1,283 @@
# -*- coding: utf-8 -*-
"""模拟网关:配置还是占位符时,渠道代码连的是这里。
模拟爱发电:收银台页面(金额可改、可模拟回调丢失)+ query-order 接口(校验 md5 签名)+ Webhook 推送(RSA 签名)。
模拟支付宝:gateway.do(校验应用签名,响应用「支付宝」私钥签名)+ 手机扫码付款页 + 异步通知。
密钥首次启动时生成在 data/mock_keys/,只用于模拟,和真实渠道无关。
"""
import hashlib, html, json, os, secrets, threading, time, urllib.parse
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
import config as C
import core
KEY_DIR = os.path.join(C.DATA_DIR, "mock_keys")
def key_path(name, public=False):
os.makedirs(KEY_DIR, exist_ok=True)
priv = os.path.join(KEY_DIR, name + ".pem")
pub = os.path.join(KEY_DIR, name + ".pub.pem")
if not os.path.exists(priv):
k = rsa.generate_private_key(public_exponent=65537, key_size=2048)
with open(priv, "wb") as f:
f.write(k.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption()))
os.chmod(priv, 0o600)
with open(pub, "wb") as f:
f.write(k.public_key().public_bytes(serialization.Encoding.PEM,
serialization.PublicFormat.SubjectPublicKeyInfo))
return pub if public else priv
def init():
core.db().executescript("""
CREATE TABLE IF NOT EXISTS mock_afd(out_trade_no TEXT PRIMARY KEY, custom_order_id TEXT, user_id TEXT,
plan_id TEXT, total_amount TEXT, status INTEGER, remark TEXT, create_time INTEGER);
CREATE TABLE IF NOT EXISTS mock_ali(out_trade_no TEXT PRIMARY KEY, trade_no TEXT, total_amount TEXT, subject TEXT,
status TEXT, notify_url TEXT, expire_ts REAL, qr TEXT, created REAL, paid_at REAL, refunded TEXT DEFAULT '0');
""")
for n in ("afdian_platform", "alipay_platform", "alipay_app"):
key_path(n)
def _priv(name):
from channels import load_priv
return load_priv(key_path(name))
def _pub(name):
from channels import load_pub
return load_pub(key_path(name, public=True))
def _later(fn, delay=0.6):
threading.Timer(delay, fn).start()
def _post(url, body, ctype):
from channels import http_post
try:
return http_post(url, body, ctype)
except Exception as e:
return "ERR %r" % e
def _trade_no():
return time.strftime("%Y%m%d%H%M%S") + "".join(secrets.choice("0123456789") for _ in range(10))
# ---------------------------------------------------------------- 页面外壳
def page(title, body):
return ("""<!doctype html><html lang="zh-CN"><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1"><title>%s</title>
<style>
body{margin:0;font:15px/1.7 system-ui,"PingFang SC","Microsoft YaHei",sans-serif;background:#f3f4f6;color:#1f2329}
.top{padding:12px 16px;color:#fff;font-weight:600}
.box{max-width:420px;margin:18px auto;background:#fff;border-radius:12px;padding:20px 18px;box-shadow:0 8px 24px -16px rgba(0,0,0,.3)}
.amt{font-size:34px;font-weight:700;margin:6px 0}
.mute{color:#6b7280;font-size:13px}
label{display:flex;gap:8px;align-items:center;margin:10px 0;font-size:14px}
input[type=number]{font-size:20px;width:120px;padding:6px 8px;border:1px solid #d1d5db;border-radius:8px}
button{width:100%%;margin-top:12px;padding:12px;border:0;border-radius:10px;font-size:16px;font-weight:600;color:#fff;cursor:pointer}
.warn{background:#fff7e6;border-radius:8px;padding:8px 10px;font-size:13px;color:#8a5a00;margin-top:10px}
code{background:#f3f4f6;padding:1px 5px;border-radius:4px;font-size:12.5px}
</style></head><body>%s</body></html>""" % (html.escape(title), body)).encode("utf-8")
# ================================================================ 模拟爱发电
def afd_checkout(qs):
g = lambda k: (qs.get(k) or [""])[0]
price = g("custom_price") or "0"
body = """<div class="top" style="background:#946ce6">爱发电(模拟收银台)</div>
<div class="box"><div class="mute">自选金额发电 · 方案 <code>%s</code></div>
<div class="amt">¥<span id="a">%s</span></div>
<div class="mute">订单留言:%s<br>custom_order_id:<code>%s</code></div>
<form method="post" action="pay">
<input type="hidden" name="custom_order_id" value="%s"><input type="hidden" name="remark" value="%s">
<label>实付金额(可改,模拟买家改价)<input type="number" step="0.01" min="0" name="amount" value="%s"></label>
<label><input type="checkbox" name="drop"> 模拟 Webhook 丢失(靠对账补)</label>
<button style="background:#946ce6">确认付款</button></form>
<div class="warn">这是原型里的模拟页面,不会真的扣钱。</div></div>""" % tuple(html.escape(x) for x in (
g("plan_id"), price, g("remark") or "(无)", g("custom_order_id") or "(无)",
g("custom_order_id"), g("remark"), price))
return 200, "text/html; charset=utf-8", page("爱发电 · 模拟收银台", body)
def afd_create_order(custom_order_id, amount, remark, drop=False):
otn = _trade_no()
o = {"out_trade_no": otn, "custom_order_id": custom_order_id, "user_id": "buyer" + secrets.token_hex(4),
"plan_id": "mock-plan", "total_amount": "%.2f" % float(amount or 0), "status": 2, "remark": remark,
"create_time": int(core.now())}
core.x("INSERT INTO mock_afd VALUES(?,?,?,?,?,?,?,?)", tuple(o[k] for k in (
"out_trade_no", "custom_order_id", "user_id", "plan_id", "total_amount", "status", "remark", "create_time")))
core.event("mock-afdian", "mock_paid", custom_order_id, "", "drop_webhook" if drop else "webhook_soon", o)
if not drop:
_later(lambda: afd_push(o))
return o
def afd_push(o, forge=False):
from channels import rsa_sign
content = "%s%s%s%s" % (o["out_trade_no"], o["user_id"], o["plan_id"], o["total_amount"])
sign = rsa_sign(_priv("afdian_platform"), content)
if forge:
sign = sign[::-1]
body = json.dumps({"ec": 200, "em": "ok", "data": {"type": "order", "order": o, "sign": sign}}).encode()
return _post(C.INTERNAL_URL + "/api/notify/afdian", body, "application/json")
def afd_pay(form):
g = lambda k: (form.get(k) or [""])[0]
o = afd_create_order(g("custom_order_id"), g("amount"), g("remark"), drop=bool(g("drop")))
back = C.BASE_URL + "/"
body = """<div class="top" style="background:#946ce6">爱发电(模拟)</div><div class="box">
<div class="amt">付款成功</div><div class="mute">爱发电订单号 <code>%s</code><br>实付 ¥%s%s</div>
<p><a href="%s">回到订单页</a>(订单页会自动发现到账)</p></div>""" % (
o["out_trade_no"], o["total_amount"], "<br><b>已模拟 Webhook 丢失</b>,等对账补上" if g("drop") else "", back)
return 200, "text/html; charset=utf-8", page("付款成功", body)
def afd_api(path, raw):
try:
req = json.loads(raw or b"{}")
except ValueError:
return _json({"ec": 400, "em": "bad json"})
want = hashlib.md5(("mock-tokenparams%sts%suser_id%s" % (req.get("params"), req.get("ts"), req.get("user_id")))
.encode()).hexdigest()
if req.get("user_id") != "mock-user" or req.get("sign") != want:
return _json({"ec": 400005, "em": "sign error"})
if not path.endswith("query-order"):
return _json({"ec": 404, "em": "unknown api"})
p = json.loads(req.get("params") or "{}")
cols = ("out_trade_no", "custom_order_id", "user_id", "plan_id", "total_amount", "status", "remark", "create_time")
if p.get("out_trade_no"):
ids = [s for s in str(p["out_trade_no"]).split(",") if s]
rows = core.q("SELECT * FROM mock_afd WHERE out_trade_no IN (%s)" % ",".join("?" * len(ids)), ids)
return _json({"ec": 200, "data": {"list": [{k: r[k] for k in cols} for r in rows], "total_page": 1}})
page_no = max(1, int(p.get("page") or 1))
total = core.q1("SELECT COUNT(*) AS c FROM mock_afd")["c"]
rows = core.q("SELECT * FROM mock_afd ORDER BY create_time DESC LIMIT 50 OFFSET ?", ((page_no - 1) * 50,))
return _json({"ec": 200, "data": {"list": [{k: r[k] for k in cols} for r in rows],
"total_count": total, "total_page": max(1, (total + 49) // 50)}})
# ================================================================ 模拟支付宝
def _ali_resp(method, node):
from channels import rsa_sign
key = method.replace(".", "_") + "_response"
raw = json.dumps(node, ensure_ascii=False, separators=(",", ":"))
sign = rsa_sign(_priv("alipay_platform"), raw)
return 200, "application/json; charset=utf-8", ('{"%s":%s,"sign":"%s"}' % (key, raw, sign)).encode()
def ali_gateway(raw):
from channels import rsa_verify
form = dict(urllib.parse.parse_qsl(raw.decode("utf-8"), keep_blank_values=True))
sign = form.pop("sign", "")
content = "&".join("%s=%s" % (k, form[k]) for k in sorted(form))
method = form.get("method", "")
if not rsa_verify(_pub("alipay_app"), content, sign):
return _ali_resp(method, {"code": "40002", "msg": "Invalid Arguments", "sub_code": "isv.invalid-signature"})
biz = json.loads(form.get("biz_content") or "{}")
otn = biz.get("out_trade_no", "")
t = core.q1("SELECT * FROM mock_ali WHERE out_trade_no=?", (otn,))
if t and t["status"] in ("NEW", "WAIT_BUYER_PAY") and core.now() > t["expire_ts"]:
core.x("UPDATE mock_ali SET status='TRADE_CLOSED' WHERE out_trade_no=?", (otn,))
t["status"] = "TRADE_CLOSED"
if method == "alipay.trade.precreate":
if core.kv_get("mock_alipay_risk"):
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.ACCESS_FORBIDDEN",
"sub_msg": "(模拟)商户收款功能被限制"})
if t:
return _ali_resp(method, {"code": "10000", "msg": "Success", "out_trade_no": otn,
"qr_code": C.BASE_URL + "/mock/alipay/scan/" + t["qr"]})
from datetime import datetime
from channels import CST
exp = datetime.strptime(biz["time_expire"], "%Y-%m-%d %H:%M:%S").replace(tzinfo=CST).timestamp()
qr = secrets.token_urlsafe(10)
core.x("INSERT INTO mock_ali(out_trade_no,total_amount,subject,status,notify_url,expire_ts,qr,created) "
"VALUES(?,?,?,?,?,?,?,?)", (otn, biz["total_amount"], biz.get("subject", ""), "NEW",
form.get("notify_url", ""), exp, qr, core.now()))
return _ali_resp(method, {"code": "10000", "msg": "Success", "out_trade_no": otn,
"qr_code": C.BASE_URL + "/mock/alipay/scan/" + qr})
if method == "alipay.trade.query":
if not t or t["status"] == "NEW":
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.TRADE_NOT_EXIST",
"sub_msg": "交易不存在"})
return _ali_resp(method, {"code": "10000", "msg": "Success", "out_trade_no": otn,
"trade_no": t["trade_no"] or "", "trade_status": t["status"],
"total_amount": t["total_amount"]})
if method == "alipay.trade.close":
if not t or t["status"] == "NEW":
if t:
core.x("UPDATE mock_ali SET status='TRADE_CLOSED' WHERE out_trade_no=?", (otn,))
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.TRADE_NOT_EXIST"})
if t["status"] == "WAIT_BUYER_PAY":
core.x("UPDATE mock_ali SET status='TRADE_CLOSED' WHERE out_trade_no=?", (otn,))
return _ali_resp(method, {"code": "10000", "msg": "Success", "out_trade_no": otn})
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.TRADE_STATUS_ERROR"})
if method == "alipay.trade.refund":
if not t or t["status"] not in ("TRADE_SUCCESS",):
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.TRADE_STATUS_ERROR"})
core.x("UPDATE mock_ali SET refunded=? WHERE out_trade_no=?", (biz.get("refund_amount"), otn))
return _ali_resp(method, {"code": "10000", "msg": "Success", "out_trade_no": otn, "trade_no": t["trade_no"],
"refund_fee": biz.get("refund_amount"), "fund_change": "Y"})
return _ali_resp(method, {"code": "40004", "msg": "Business Failed", "sub_code": "ACQ.METHOD_NOT_SUPPORTED"})
def ali_scan(qr):
t = core.q1("SELECT * FROM mock_ali WHERE qr=?", (qr,))
if not t:
return 404, "text/plain; charset=utf-8", "二维码无效".encode()
if t["status"] in ("NEW", "WAIT_BUYER_PAY") and core.now() > t["expire_ts"]:
core.x("UPDATE mock_ali SET status='TRADE_CLOSED' WHERE qr=?", (qr,))
t["status"] = "TRADE_CLOSED"
if t["status"] == "NEW":
core.x("UPDATE mock_ali SET status='WAIT_BUYER_PAY' WHERE qr=?", (qr,))
t["status"] = "WAIT_BUYER_PAY"
if t["status"] != "WAIT_BUYER_PAY":
msg = {"TRADE_SUCCESS": "这笔已经付过了", "TRADE_CLOSED": "二维码已失效,请回到订单页重新生成"}.get(t["status"], t["status"])
body = '<div class="top" style="background:#1677ff">支付宝(模拟)</div><div class="box"><div class="amt" style="font-size:22px">%s</div></div>' % msg
return 200, "text/html; charset=utf-8", page("支付宝", body)
body = """<div class="top" style="background:#1677ff">支付宝(模拟扫码付款)</div>
<div class="box"><div class="mute">%s</div><div class="amt">¥%s</div>
<form method="post" action="../scanpay"><input type="hidden" name="qr" value="%s">
<label><input type="checkbox" name="drop"> 模拟异步通知丢失(靠页面轮询 / 补查发现)</label>
<button style="background:#1677ff">确认付款</button></form>
<div class="warn">这是原型里的模拟页面,不会真的扣钱。</div></div>""" % (
html.escape(t["subject"]), html.escape(t["total_amount"]), html.escape(qr))
return 200, "text/html; charset=utf-8", page("支付宝 · 模拟扫码", body)
def ali_scanpay(form):
from channels import rsa_sign, fmt_cst
g = lambda k: (form.get(k) or [""])[0]
t = core.q1("SELECT * FROM mock_ali WHERE qr=?", (g("qr"),))
if not t or t["status"] != "WAIT_BUYER_PAY" or core.now() > t["expire_ts"]:
return 200, "text/html; charset=utf-8", page("支付宝", '<div class="box">二维码已失效</div>')
tn = _trade_no()
core.x("UPDATE mock_ali SET status='TRADE_SUCCESS',trade_no=?,paid_at=? WHERE qr=?", (tn, core.now(), g("qr")))
core.event("mock-alipay", "mock_paid", t["out_trade_no"], "", "drop_notify" if g("drop") else "notify_soon",
{"trade_no": tn, "amount": t["total_amount"]})
if not g("drop") and t["notify_url"]:
p = {"notify_time": fmt_cst(core.now()), "notify_type": "trade_status_sync", "notify_id": secrets.token_hex(8),
"app_id": "mock-app", "charset": "utf-8", "version": "1.0", "trade_no": tn,
"out_trade_no": t["out_trade_no"], "trade_status": "TRADE_SUCCESS", "total_amount": t["total_amount"],
"receipt_amount": t["total_amount"], "buyer_pay_amount": t["total_amount"], "subject": t["subject"],
"gmt_payment": fmt_cst(core.now())}
p["sign"] = rsa_sign(_priv("alipay_platform"), "&".join("%s=%s" % (k, p[k]) for k in sorted(p)))
p["sign_type"] = "RSA2"
url = C.INTERNAL_URL + "/api/notify/alipay"
_later(lambda: _post(url, urllib.parse.urlencode(p).encode(), "application/x-www-form-urlencoded"))
body = """<div class="top" style="background:#1677ff">支付宝(模拟)</div><div class="box">
<div class="amt">支付成功</div><div class="mute">¥%s · 交易号 <code>%s</code>%s</div>
<p class="mute">回到电脑上的订单页,它会自动变成「已到账」。</p></div>""" % (
t["total_amount"], tn, "<br><b>已模拟异步通知丢失</b>" if g("drop") else "")
return 200, "text/html; charset=utf-8", page("支付成功", body)
def _json(obj):
return 200, "application/json; charset=utf-8", json.dumps(obj, ensure_ascii=False).encode()
+138
View File
@@ -0,0 +1,138 @@
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
<meta name="robots" content="noindex,nofollow">
<title>收款原型后台</title>
<style>
:root{--bg:#F4F6F2;--paper:#fff;--ink:#1D2620;--ink2:#46524B;--mute:#77837C;--line:#DFE5DC;--soft:#EEF2EC;
--acc:#3C8527;--acc-s:#E5F1E0;--afd:#7A55D8;--afd-s:#EFE9FC;--ali:#1677FF;--ali-s:#E5F0FF;--warn:#9A6A00;--warn-s:#FFF4D9;--bad:#B4412F;--bad-s:#FBE8E4;
--font:system-ui,-apple-system,"PingFang SC","Microsoft YaHei","Noto Sans SC",sans-serif;--mono:ui-monospace,Menlo,Consolas,monospace}
@media (prefers-color-scheme:dark){:root{color-scheme:dark;--bg:#121613;--paper:#19201B;--ink:#E3EAE4;--ink2:#BAC5BD;--mute:#8B978F;--line:#2B342D;--soft:#202922;
--acc:#6CC052;--acc-s:#1E321F;--afd:#A88BF0;--afd-s:#2A2240;--ali:#5EA0FF;--ali-s:#162A47;--warn:#E0B44A;--warn-s:#33291A;--bad:#E58572;--bad-s:#3A211C}}
*{box-sizing:border-box}
body{margin:0;background:var(--bg);color:var(--ink);font:14.5px/1.6 var(--font);padding:16px}
.in{max-width:1180px;margin:0 auto}
h1{font-size:20px;margin:4px 0 2px}
h2{font-size:15.5px;margin:0 0 8px;display:flex;gap:8px;align-items:baseline}
.mute{color:var(--mute);font-size:13px}
.card{background:var(--paper);border:1px solid var(--line);border-radius:12px;padding:14px 16px;margin-top:14px}
.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:14px}
.tw{overflow-x:auto}
table{border-collapse:collapse;width:100%;font-size:13px;min-width:560px}
th,td{text-align:left;padding:6px 8px;border-bottom:1px solid var(--soft);vertical-align:top}
th{color:var(--mute);font-weight:600;white-space:nowrap}
td{font-variant-numeric:tabular-nums}
code{font-family:var(--mono);font-size:12px;background:var(--soft);padding:1px 4px;border-radius:4px;word-break:break-all}
button{font:inherit;font-size:13px;cursor:pointer;border-radius:8px;border:1px solid var(--line);background:var(--paper);color:var(--ink);padding:5px 10px}
button:hover{border-color:var(--acc)}
button.pri{background:var(--acc);border-color:var(--acc);color:#fff}
input{font:inherit;padding:6px 9px;border:1px solid var(--line);border-radius:8px;background:var(--paper);color:var(--ink)}
.pill{display:inline-block;font-size:12px;padding:1px 8px;border-radius:999px;background:var(--soft);white-space:nowrap}
.k-short,.k-late{background:var(--warn-s);color:var(--warn)}
.k-duplicate,.k-unknown{background:var(--bad-s);color:var(--bad)}
.s-paid,.s-waiting{background:var(--acc-s);color:var(--acc)}
.s-closed,.s-mismatch,.s-void{background:var(--bad-s);color:var(--bad)}
.s-unpaid,.s-created{background:var(--warn-s);color:var(--warn)}
.ch-afdian{color:var(--afd)} .ch-alipay{color:var(--ali)}
.done td{opacity:.55}
.row{display:flex;gap:8px;flex-wrap:wrap;align-items:center}
.msg{margin-top:8px;font-size:13px;padding:6px 10px;border-radius:8px;background:var(--soft)}
[hidden]{display:none!important}
</style>
</head>
<body><div class="in">
<div class="row" style="justify-content:space-between">
<div><h1>收款原型 · 后台</h1><div class="mute">原型 · 全部为模拟渠道。演示时钟 <code id="clock">—</code></div></div>
<a href="./">← 回付款页</a>
</div>
<div class="card" id="login">
<h2>后台口令</h2>
<div class="row"><input id="tok" type="password" placeholder="服务器 data/admin_token 里的口令" size="34" autocomplete="off">
<button class="pri" id="btnTok">进入</button></div>
<div class="msg" id="loginMsg" hidden></div>
</div>
<div id="main" hidden>
<div class="card">
<h2>支付待办 <span class="mute">系统判断不了的,才会出现在这里</span></h2>
<div class="tw"><table id="todo"></table></div>
<div class="msg" id="todoMsg" hidden></div>
</div>
<div class="grid">
<div class="card">
<h2>按爱发电订单号认领</h2>
<p class="mute">买家没走专链、或者回调里没带订单号时,把那笔爱发电成交指定到某张订单。系统会先向爱发电反查确认已付款。</p>
<div class="row"><input id="cOid" placeholder="订单号 YSXXXXXX" size="12">
<input id="cTn" placeholder="爱发电订单号" size="26"><button class="pri" id="btnClaim">认领</button></div>
<div class="msg" id="claimMsg" hidden></div>
</div>
<div class="card">
<h2>渠道状态</h2>
<div id="chs"></div>
</div>
</div>
<div class="card"><h2>订单</h2><div class="tw"><table id="orders"></table></div></div>
<div class="card"><h2>支付单</h2><div class="tw"><table id="pays"></table></div></div>
<div class="card"><h2>流水 <span class="mute">最近 80 条</span></h2><div class="tw"><table id="evs"></table></div></div>
</div>
</div>
<script>
(function(){
'use strict';
var $=function(i){return document.getElementById(i);};
var TOK=''; try{ TOK=localStorage.getItem('payproto_admin')||''; }catch(e){}
var KIND={short:'金额不足',duplicate:'重复付款',late:'迟到付款',unknown:'对不上'};
var ACTS={short:[['confirm','确认补齐'],['refund','退款'],['ignore','忽略']],
duplicate:[['refund','退款'],['ignore','忽略']],late:[['activate','手动激活'],['refund','退款'],['ignore','忽略']],
unknown:[['ignore','忽略']]};
var ST={unpaid:'待付款',waiting:'已到账',closed:'已关闭',void:'已注销',created:'等待付款',paid:'已到账',mismatch:'金额不足',refunded:'已退款'};
function esc(s){return String(s==null?'':s).replace(/[&<>"']/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c];});}
function t(ts){return ts?new Date(ts*1000).toLocaleString('zh-CN',{hour12:false,timeZone:'Asia/Shanghai'}):'—';}
function api(m,p,b){return fetch(p,{method:m,headers:Object.assign({'X-Admin-Token':TOK},b?{'Content-Type':'application/json'}:{}),
body:b?JSON.stringify(b):undefined,cache:'no-store'}).then(function(r){return r.json();});}
function pill(s,cls){return '<span class="pill '+cls+'">'+esc(ST[s]||KIND[s]||s)+'</span>';}
function load(){
return api('GET','api/admin/overview').then(function(j){
if(!j.ok){ $('main').hidden=true; $('login').hidden=false; if(TOK){ $('loginMsg').hidden=false; $('loginMsg').textContent=j.error; } return; }
$('login').hidden=true; $('main').hidden=false; $('clock').textContent=t(j.now);
$('todo').innerHTML='<tr><th>时间</th><th>类型</th><th>订单 / 支付单</th><th>渠道流水</th><th>应付 / 实付</th><th>说明</th><th>处理</th></tr>'
+ (j.todo.map(function(x){
var acts = x.state==='done' ? esc(x.resolution) : (ACTS[x.kind]||[['ignore','忽略']]).map(function(a){
return '<button data-id="'+x.id+'" data-a="'+a[0]+'">'+a[1]+'</button>'; }).join(' ');
return '<tr class="'+(x.state==='done'?'done':'')+'"><td>'+t(x.ts)+'</td><td>'+pill(x.kind,'k-'+x.kind)+'</td><td><code>'+esc(x.oid)+'</code><br><code>'+esc(x.pay_id)
+'</code></td><td><span class="ch-'+esc(x.channel)+'">'+esc(x.channel)+'</span><br><code>'+esc(x.trade_no)+'</code></td><td>¥'+esc(x.amount_due)+' / ¥'+esc(x.amount_paid)
+'</td><td>'+esc(x.detail)+'</td><td>'+acts+'</td></tr>'; }).join('') || '<tr><td colspan="7" class="mute">没有待办 —— 全都自动处理了</td></tr>');
[].forEach.call($('todo').querySelectorAll('button[data-id]'),function(b){
b.onclick=function(){ api('POST','api/admin/todo',{id:+b.dataset.id,action:b.dataset.a}).then(function(r){
$('todoMsg').hidden=false; $('todoMsg').textContent=r.ok?r.msg:('没成功:'+r.error); load(); }); };
});
var b=j.breaker, open=b.open_until>j.now;
$('chs').innerHTML=j.channels.map(function(c){ return '<div><b class="ch-'+c.name+'">'+esc(c.label)+'</b> · '+(c.mock?'模拟网关':'真实渠道')
+(c.name==='alipay'?(' · '+(open?'<span class="pill s-closed">熔断中,至 '+t(b.open_until)+'</span>':'<span class="pill s-paid">正常</span>')
+(b.reason?'<div class="mute">最近一次问题:'+esc(b.reason)+'</div>':'')):'')+'</div>'; }).join('');
$('orders').innerHTML='<tr><th>订单</th><th>状态</th><th>金额</th><th>创建</th><th>到账</th><th>关闭</th><th>买家点过「没反应」</th></tr>'
+j.orders.map(function(o){ return '<tr><td><code>'+esc(o.oid)+'</code></td><td>'+pill(o.state,'s-'+o.state)+'</td><td>¥'+o.amount+'</td><td>'+t(o.created_at)
+'</td><td>'+t(o.paid_at)+'</td><td>'+t(o.closed_at)+'</td><td>'+t(o.buyer_claim_at)+'</td></tr>'; }).join('');
$('pays').innerHTML='<tr><th>支付单</th><th>渠道</th><th>状态</th><th>应付 / 实付</th><th>渠道流水</th><th>创建</th><th>过期</th><th>备注</th></tr>'
+j.payments.map(function(p){ return '<tr><td><code>'+esc(p.pay_id)+'</code></td><td class="ch-'+p.channel+'">'+esc(p.channel)+'</td><td>'+pill(p.state,'s-'+p.state)
+'</td><td>¥'+p.amount_due+' / '+(p.amount_paid!=null?'¥'+p.amount_paid:'—')+'</td><td><code>'+esc(p.trade_no||'')+'</code></td><td>'+t(p.created_at)
+'</td><td>'+t(p.expire_at)+'</td><td>'+esc(p.note)+'</td></tr>'; }).join('');
$('evs').innerHTML='<tr><th>时间</th><th>渠道</th><th>事件</th><th>支付单 / 订单</th><th>结果</th></tr>'
+j.events.map(function(e){ return '<tr><td>'+t(e.ts)+'</td><td class="ch-'+esc(e.channel)+'">'+esc(e.channel)+'</td><td>'+esc(e.kind)+'</td><td><code>'+esc(e.pay_id||e.oid)
+'</code></td><td>'+esc(e.result)+'</td></tr>'; }).join('');
});
}
$('btnTok').onclick=function(){ TOK=$('tok').value.trim(); try{ localStorage.setItem('payproto_admin',TOK); }catch(e){} load(); };
$('btnClaim').onclick=function(){ api('POST','api/admin/claim',{oid:$('cOid').value.trim(),trade_no:$('cTn').value.trim()}).then(function(r){
$('claimMsg').hidden=false; $('claimMsg').textContent=r.ok?r.msg:('没成功:'+r.error); load(); }); };
load(); setInterval(function(){ if(!document.hidden && TOK) load(); }, 5000);
})();
</script>
</body>
</html>
+337
View File
@@ -0,0 +1,337 @@
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
<meta name="robots" content="noindex,nofollow">
<title>金钻收款原型</title>
<style>
:root{
--bg:#F4F6F2;--paper:#fff;--ink:#1D2620;--ink2:#46524B;--mute:#77837C;--line:#DFE5DC;--soft:#EEF2EC;
--acc:#3C8527;--acc-d:#2E6A1D;--acc-s:#E5F1E0;--afd:#7A55D8;--afd-s:#EFE9FC;--ali:#1677FF;--ali-s:#E5F0FF;
--warn:#9A6A00;--warn-s:#FFF4D9;--bad:#B4412F;--bad-s:#FBE8E4;
--font:system-ui,-apple-system,"PingFang SC","Microsoft YaHei","Noto Sans SC",sans-serif;
--mono:ui-monospace,"SF Mono",Menlo,Consolas,monospace;
}
@media (prefers-color-scheme:dark){:root{color-scheme:dark;--bg:#121613;--paper:#19201B;--ink:#E3EAE4;--ink2:#BAC5BD;--mute:#8B978F;
--line:#2B342D;--soft:#202922;--acc:#6CC052;--acc-d:#5AAE41;--acc-s:#1E321F;--afd:#A88BF0;--afd-s:#2A2240;--ali:#5EA0FF;--ali-s:#162A47;
--warn:#E0B44A;--warn-s:#33291A;--bad:#E58572;--bad-s:#3A211C}}
*{box-sizing:border-box}
body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.65 var(--font)}
.bar{position:sticky;top:0;z-index:5;background:var(--paper);border-bottom:1px solid var(--line);padding:10px 16px;padding-top:calc(10px + env(safe-area-inset-top,0px))}
.bar-in{max-width:1180px;margin:0 auto;display:flex;align-items:center;gap:12px;flex-wrap:wrap}
.brand{font-weight:700;letter-spacing:.02em}
.proto{font-size:12px;color:var(--warn);background:var(--warn-s);padding:2px 9px;border-radius:999px}
.bar a{margin-left:auto;color:var(--mute);font-size:13.5px}
.wrap{max-width:1180px;margin:0 auto;padding:20px 16px 60px;display:grid;grid-template-columns:minmax(0,1fr) 380px;gap:22px;align-items:start}
@media (max-width:900px){.wrap{grid-template-columns:1fr}}
.card{background:var(--paper);border:1px solid var(--line);border-radius:12px;padding:18px 18px}
.card+.card{margin-top:16px}
h1{font-size:20px;margin:0 0 4px}
h2{font-size:16px;margin:0 0 10px}
.mute{color:var(--mute);font-size:13px}
.row{display:flex;gap:10px;flex-wrap:wrap;align-items:center}
.seg{display:flex;gap:6px;flex-wrap:wrap}
.seg button{min-width:44px}
button{font:inherit;cursor:pointer;border-radius:9px;border:1px solid var(--line);background:var(--paper);color:var(--ink);padding:8px 14px}
button:hover{border-color:var(--acc)}
button:focus-visible,a:focus-visible{outline:2px solid var(--acc);outline-offset:2px}
button.on{border-color:var(--acc);background:var(--acc-s);color:var(--acc-d);font-weight:600}
button.pri{background:var(--acc);border-color:var(--acc);color:#fff;font-weight:600;padding:10px 18px;box-shadow:0 2px 0 var(--acc-d)}
button.pri:active{transform:translateY(1px);box-shadow:none}
button:disabled{opacity:.45;cursor:not-allowed}
button.small{padding:5px 10px;font-size:13px}
.amt{font-size:28px;font-weight:700;font-variant-numeric:tabular-nums}
.pill{display:inline-block;font-size:12.5px;padding:2px 10px;border-radius:999px;background:var(--soft);color:var(--ink2);white-space:nowrap}
.pill.unpaid{background:var(--warn-s);color:var(--warn)}
.pill.waiting,.pill.paid{background:var(--acc-s);color:var(--acc-d)}
.pill.closed,.pill.void,.pill.mismatch{background:var(--bad-s);color:var(--bad)}
.kv{display:grid;grid-template-columns:auto 1fr;gap:4px 14px;font-size:14px;margin:10px 0}
.kv span:nth-child(odd){color:var(--mute)}
code{font-family:var(--mono);font-size:12.5px;background:var(--soft);padding:1px 5px;border-radius:4px;word-break:break-all}
.chs{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px;margin-top:6px}
.ch{text-align:left;padding:14px 14px;border-radius:11px;display:flex;flex-direction:column;gap:4px}
.ch b{font-size:15.5px}
.ch.afd b{color:var(--afd)}
.ch.ali b{color:var(--ali)}
.ch .why{font-size:12.5px;color:var(--bad)}
.ch .tagr{font-size:11.5px;color:var(--acc-d);background:var(--acc-s);padding:1px 7px;border-radius:999px;align-self:flex-start}
.paybox{display:grid;grid-template-columns:200px 1fr;gap:18px;align-items:start;margin-top:14px;padding-top:14px;border-top:1px dashed var(--line)}
@media (max-width:520px){.paybox{grid-template-columns:1fr}}
.qr{width:200px;height:200px;background:#fff;border-radius:10px;padding:10px;border:1px solid var(--line)}
.qr svg{width:100%;height:100%;display:block}
.count{font:600 22px/1 var(--mono);font-variant-numeric:tabular-nums}
.done{display:flex;gap:14px;align-items:center;padding:6px 0}
.tick{width:48px;height:48px;border-radius:50%;background:var(--acc);color:#fff;display:grid;place-items:center;font-size:26px;flex:none}
.msg{font-size:13.5px;margin-top:10px;padding:8px 11px;border-radius:8px;background:var(--soft)}
.msg.bad{background:var(--bad-s);color:var(--bad)}
.side h2{display:flex;justify-content:space-between;align-items:baseline}
.side .grp{display:flex;flex-wrap:wrap;gap:6px;margin:8px 0 14px}
.clock{font:600 15px var(--mono)}
.ev{list-style:none;margin:0;padding:0;font-size:13px;max-height:420px;overflow:auto}
.ev li{display:grid;grid-template-columns:62px 1fr;gap:8px;padding:6px 0;border-bottom:1px solid var(--soft)}
.ev time{font-family:var(--mono);color:var(--mute);font-size:12px}
.ev .c{font-size:11px;padding:0 6px;border-radius:999px;margin-right:4px}
.ev .c.afdian,.ev .c.mock-afdian{background:var(--afd-s);color:var(--afd)}
.ev .c.alipay,.ev .c.mock-alipay{background:var(--ali-s);color:var(--ali)}
.hist{font-size:13px;width:100%;border-collapse:collapse;margin-top:6px}
.hist td{padding:5px 4px;border-top:1px solid var(--soft)}
[hidden]{display:none!important}
</style>
</head>
<body>
<div class="bar"><div class="bar-in">
<span class="brand">金钻工坊 · 收款原型</span>
<span class="proto">原型 · 全部为模拟渠道,不会扣钱</span>
<a href="admin">后台 →</a>
</div></div>
<div class="wrap">
<main>
<section class="card" id="newCard">
<h1>网页下单</h1>
<p class="mute">原型里省略了传皮肤、选模板,只选张数。每张 ¥6。</p>
<div class="row" style="margin-top:10px">
<div class="seg" id="nSeg"></div>
<span class="amt" id="newAmt">¥12</span>
</div>
<div class="row" style="margin-top:14px"><button class="pri" id="btnNew">提交订单</button></div>
</section>
<section class="card" id="orderCard" hidden>
<div class="row" style="justify-content:space-between">
<h1>订单 <code id="oOid"></code></h1><span class="pill" id="oState"></span>
</div>
<div class="kv">
<span>应付</span><span><b id="oAmt"></b>(<span id="oN"></span> 张)</span>
<span>订单保留</span><span id="oKeep"></span>
</div>
<div id="payArea">
<h2 style="margin-top:12px">选择付款方式</h2>
<div class="chs" id="chs"></div>
<div class="paybox" id="payBox" hidden>
<div><div class="qr" id="qr"></div></div>
<div id="payInfo"></div>
</div>
<div class="row" style="margin-top:14px">
<button id="btnCheck">付好了没反应?</button>
<span class="mute">刚付完一般几秒内自动到账,不用点。</span>
</div>
<div class="msg" id="checkMsg" hidden></div>
</div>
<div id="paidArea" hidden>
<div class="done"><div class="tick">✓</div>
<div><b style="font-size:18px">已到账 · 正在排队出图</b><div class="mute">不用再做任何操作,进度在这一页看。</div></div></div>
</div>
<div id="closedArea" hidden>
<div class="msg bad">这张订单超过 24 小时没付款,已自动关闭。如果其实已经付了,系统会在 72 小时内自动认回来;
也可以点「付好了没反应?」立即查一次。</div>
<div class="row" style="margin-top:12px"><button class="pri" id="btnRenew">重新下单</button>
<button id="btnCheck2">付好了没反应?</button></div>
</div>
<h2 style="margin-top:22px">这张单的支付记录</h2>
<table class="hist" id="hist"></table>
</section>
</main>
<aside class="side">
<section class="card">
<h2>原型模拟器 <span class="mute">只在原型里有</span></h2>
<div class="mute">演示时钟(可快进,用来看超时关单)</div>
<div class="clock" id="clock">—</div>
<div class="grp">
<button class="small" data-ff="900">快进 15 分钟</button>
<button class="small" data-ff="7200">快进 2 小时</button>
<button class="small" data-ff="86400">快进 1 天</button>
<button class="small" id="btnJobs">立即跑一轮定时任务</button>
</div>
<div class="mute">场景</div>
<div class="grp">
<button class="small" id="btnRisk">模拟支付宝被风控</button>
<button class="small" id="btnBreaker">恢复支付宝</button>
<button class="small" id="btnDirect">有人直接在爱发电店铺下单</button>
<button class="small" id="btnForge">伪造一条爱发电回调</button>
</div>
<div class="msg" id="simMsg" hidden></div>
</section>
<section class="card">
<h2>流水 <span class="mute">这张单,最新在上</span></h2>
<ul class="ev" id="ev"><li><span></span><span class="mute">还没有订单</span></li></ul>
</section>
</aside>
</div>
<script src="static/qrcode.min.js"></script>
<script>
(function(){
'use strict';
var $ = function(id){ return document.getElementById(id); };
var S = {oid:'', t:'', view:null, n:2, pay:null, timer:0};
var KIND = {order_created:'下单', payment_created:'建支付单', notify:'收到回调', settle:'到账处理', close:'关单',
payment_expired:'支付单过期', order_closed:'订单超时关闭', buyer_check:'买家点「付好了没反应」', todo:'进入待办',
mock_paid:'(模拟)买家付款', card_purchase:'按买卡密处理', breaker_open:'支付宝熔断', create_failed:'生成付款失败',
query_failed:'查单失败', todo_resolved:'待办已处理', job_error:'定时任务出错'};
var RES = {activated:'激活订单', reopened:'恢复并激活', dup_trade:'重复,已忽略', short:'金额不足', duplicate:'重复付款',
late:'迟到付款', unknown:'对不上', ok:'验证通过', webhook_soon:'稍后推送回调', drop_webhook:'回调丢失(模拟)',
notify_soon:'稍后推送通知', drop_notify:'通知丢失(模拟)', '验签失败':'验签失败,丢弃', created:'', unpaid:'', closed:''};
var CH = {afdian:'爱发电', alipay:'支付宝', 'mock-afdian':'爱发电', 'mock-alipay':'支付宝'};
function api(method, path, body){
return fetch(path, {method:method, headers:body?{'Content-Type':'application/json'}:{}, body:body?JSON.stringify(body):undefined,
cache:'no-store'}).then(function(r){ return r.json(); });
}
function esc(s){ return String(s==null?'':s).replace(/[&<>"']/g,function(c){return {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c];}); }
function hm(ts){ return new Date(ts*1000).toLocaleTimeString('zh-CN',{hour12:false,timeZone:'Asia/Shanghai'}); }
function full(ts){ return new Date(ts*1000).toLocaleString('zh-CN',{hour12:false,timeZone:'Asia/Shanghai'}); }
function left(sec){ sec=Math.max(0,Math.round(sec)); var h=Math.floor(sec/3600),m=Math.floor(sec%3600/60),s=sec%60;
return h? (h+' 小时 '+m+' 分') : (m+':'+(s<10?'0':'')+s); }
function save(){ try{ localStorage.setItem('payproto_order', JSON.stringify({oid:S.oid,t:S.t})); }catch(e){} }
function qrSvg(text){ try{ var q=qrcode(0,'M'); q.addData(text); q.make(); return q.createSvgTag({cellSize:4,margin:0,scalable:true}); }
catch(e){ return '<div class="mute">二维码生成失败</div>'; } }
/* ---------- 下单 ---------- */
var seg=$('nSeg');
[1,2,3,4,5,6].forEach(function(n){ var b=document.createElement('button'); b.textContent=n+' 张';
b.onclick=function(){ S.n=n; paintSeg(); }; b.dataset.n=n; seg.appendChild(b); });
function paintSeg(){ [].forEach.call(seg.children,function(b){ b.classList.toggle('on', +b.dataset.n===S.n); });
$('newAmt').textContent='¥'+(S.n*6); }
paintSeg();
$('btnNew').onclick=function(){
this.disabled=true;
api('POST','api/order',{n_img:S.n}).then(function(j){
$('btnNew').disabled=false;
if(!j.ok){ return; }
S.oid=j.order.oid; S.t=j.token; S.pay=null; save(); render(j);
});
};
$('btnRenew').onclick=function(){ S.oid=''; S.t=''; S.pay=null; save(); $('orderCard').hidden=true; $('newCard').hidden=false;
$('ev').innerHTML='<li><span></span><span class="mute">还没有订单</span></li>'; };
/* ---------- 渲染 ---------- */
function render(v){
S.view=v; var o=v.order;
$('newCard').hidden=true; $('orderCard').hidden=false;
$('oOid').textContent=o.oid; $('oAmt').textContent='¥'+o.amount; $('oN').textContent=o.n_img;
var st=$('oState'); st.textContent=o.state_text; st.className='pill '+o.state;
$('oKeep').textContent = o.state==='unpaid' ? ('还剩 '+left(o.expire_at-v.now)+',超时自动关闭') : (o.state==='closed'?'已关闭':'—');
$('payArea').hidden = o.state!=='unpaid';
$('paidArea').hidden = o.state!=='waiting';
$('closedArea').hidden = o.state!=='closed';
$('clock').textContent=full(v.now);
// 渠道
var box=$('chs'); box.innerHTML='';
v.channels.forEach(function(c){
var b=document.createElement('button'); b.className='ch '+(c.name==='afdian'?'afd':'ali');
b.disabled=!c.ok;
b.innerHTML=(c.name==='afdian'?'<span class="tagr">推荐</span>':'')+'<b>'+esc(c.label)+'</b>'
+'<span class="mute">'+(c.name==='afdian'?'跳到爱发电付款,手续费由平台收':'页面里扫码,支付宝付款')+'</span>'
+(c.ok?'':'<span class="why">'+esc(c.reason)+'</span>');
b.onclick=function(){ choose(c.name); };
if(S.pay && S.pay.channel===c.name) b.classList.add('on');
box.appendChild(b);
});
// 当前支付单
var cur=null; v.payments.forEach(function(p){ if(p.state==='created' && (!S.pay || p.pay_id===S.pay.pay_id)) cur=p; });
S.pay=cur; paintPay(v);
// 记录
$('hist').innerHTML = v.payments.length ? v.payments.map(function(p){
return '<tr><td><code>'+esc(p.pay_id)+'</code></td><td>'+esc(CH[p.channel])+'</td><td>¥'+p.amount_due
+(p.amount_paid!=null?' / 实付 ¥'+p.amount_paid:'')+'</td><td><span class="pill '+p.state+'">'+esc(p.state_text)+'</span></td></tr>';
}).join('') : '<tr><td class="mute">还没有</td></tr>';
// 流水
$('ev').innerHTML = v.events.map(function(e){
var r=RES.hasOwnProperty(e.result)?RES[e.result]:e.result;
return '<li><time>'+hm(e.ts)+'</time><span>'+(e.channel?'<span class="c '+esc(e.channel)+'">'+esc(CH[e.channel]||e.channel)+'</span>':'')
+esc(KIND[e.kind]||e.kind)+(r?' · <span class="mute">'+esc(r)+'</span>':'')+'</span></li>';
}).join('') || '<li><span></span><span class="mute">暂无</span></li>';
}
function paintPay(v){
var p=S.pay, pb=$('payBox');
if(!p || v.order.state!=='unpaid'){ pb.hidden=true; return; }
pb.hidden=false;
var d=p.display||{};
if(p.channel==='afdian'){
$('qr').innerHTML=qrSvg(d.qr||d.url||'');
$('payInfo').innerHTML='<b style="color:var(--afd)">爱发电付款 ¥'+p.amount_due+'</b>'
+'<p class="mute">手机扫左边的码打开爱发电付款;用这台设备付就点下面的按钮。付完回到这页,会自动显示到账。</p>'
+'<a href="'+esc(d.url)+'" target="_blank" rel="noopener"><button class="pri" style="background:var(--afd);border-color:var(--afd);box-shadow:none">在这台设备打开爱发电</button></a>'
+'<p class="mute" style="margin-top:8px">支付单 <code>'+esc(p.pay_id)+'</code></p>';
}else{
$('qr').innerHTML=qrSvg(d.qr||'');
var remain=p.expire_at-v.now;
$('payInfo').innerHTML='<b style="color:var(--ali)">支付宝扫码 ¥'+p.amount_due+'</b>'
+'<p class="mute">用手机支付宝扫左边的码。原型里扫出来是模拟的支付宝付款页,不会扣钱。</p>'
+'<div class="mute">二维码有效期</div><div class="count" id="cnt">'+left(remain)+'</div>'
+'<p><a href="'+esc(d.qr)+'" target="_blank" rel="noopener">在这台设备打开(模拟扫码)</a></p>'
+'<p class="mute">支付单 <code>'+esc(p.pay_id)+'</code></p>';
}
}
function choose(ch){
$('checkMsg').hidden=true;
api('POST','api/pay',{oid:S.oid,t:S.t,channel:ch}).then(function(j){
if(!j.ok){ $('checkMsg').hidden=false; $('checkMsg').className='msg bad'; $('checkMsg').textContent=j.error; return refresh(); }
S.pay=j.payment; refresh();
});
}
function check(){
var m=$('checkMsg'); m.hidden=false; m.className='msg'; m.textContent='正在向渠道查询…';
api('POST','api/check',{oid:S.oid,t:S.t}).then(function(j){ m.textContent=j.msg||j.error||''; m.className='msg'+(j.found?'':' bad'); refresh(); });
}
$('btnCheck').onclick=check; $('btnCheck2').onclick=check;
/* ---------- 轮询(页面可见时) ---------- */
function refresh(){
if(!S.oid) return Promise.resolve();
var url = (S.pay && S.view && S.view.order.state==='unpaid')
? 'api/pay?pay_id='+encodeURIComponent(S.pay.pay_id)+'&t='+encodeURIComponent(S.t)
: 'api/order?oid='+encodeURIComponent(S.oid)+'&t='+encodeURIComponent(S.t);
return api('GET',url).then(function(j){ if(j.ok) render(j); else if(j.error){ S.oid=''; save(); } });
}
function loop(){
clearTimeout(S.timer);
if(document.visibilityState==='visible'){ refresh().finally(function(){ S.timer=setTimeout(loop, 3000); }); }
}
document.addEventListener('visibilitychange', function(){ if(document.visibilityState==='visible') loop(); });
/* ---------- 模拟器 ---------- */
function sim(body, msg){
var m=$('simMsg'); m.hidden=false; m.className='msg'; m.textContent='执行中…';
return api('POST','api/demo',body).then(function(j){
var jobs = j.jobs ? (' 定时任务:'+Object.keys(j.jobs).map(function(k){ return k+' '+j.jobs[k]; }).join(',')) : '';
m.textContent=(j.ok?(msg||'完成'):'失败:'+(j.error||''))+jobs; return refresh();
});
}
[].forEach.call(document.querySelectorAll('[data-ff]'),function(b){
b.onclick=function(){ sim({kind:'clock',seconds:+b.dataset.ff}, '时钟已快进,并跑了一轮定时任务。'); };
});
$('btnJobs').onclick=function(){ sim({kind:'jobs'}, '已跑一轮。'); };
$('btnRisk').onclick=function(){ sim({kind:'alipay_risk',on:true}, '支付宝网关会返回风控错误码。现在去点「支付宝扫码」,会触发熔断,选项变灰。'); };
$('btnBreaker').onclick=function(){ sim({kind:'alipay_risk',on:false}).then(function(){ return sim({kind:'breaker_reset'}, '风控已解除,熔断已恢复。'); }); };
$('btnDirect').onclick=function(){ sim({kind:'afdian_direct',amount:12}, '模拟了一笔没带订单号的爱发电成交:系统按「买卡密」处理,不去猜是哪张单。去后台可以按爱发电订单号认领。'); };
$('btnForge').onclick=function(){
var pid = (S.pay && S.pay.channel==='afdian') ? S.pay.pay_id : '';
if(!pid){ var m=$('simMsg'); m.hidden=false; m.className='msg bad'; m.textContent='先选「爱发电」生成一张支付单,再伪造它的回调。'; return; }
sim({kind:'afdian_forge',pay_id:pid}, '已发出一条签名不对的回调(金额 ¥999)。看流水:验签失败,被丢弃。');
};
/* ---------- 启动 ---------- */
(function boot(){
var m=/[#&]o=([A-Z0-9]+)&t=([\w-]+)/.exec(location.hash||'');
var saved=null; try{ saved=JSON.parse(localStorage.getItem('payproto_order')||'null'); }catch(e){}
if(m){ S.oid=m[1]; S.t=m[2]; } else if(saved && saved.oid){ S.oid=saved.oid; S.t=saved.t; }
if(S.oid){ save(); }
loop();
// 倒计时每秒走(不等轮询)
setInterval(function(){ var c=$('cnt'); if(!c||!S.pay||!S.view) return; S.view.now+=1; c.textContent=left(S.pay.expire_at-S.view.now); }, 1000);
})();
})();
</script>
</body>
</html>
File diff suppressed because one or more lines are too long
+260
View File
@@ -0,0 +1,260 @@
# -*- coding: utf-8 -*-
"""支付原型场景测试:临时目录起一份服务(全模拟渠道),从 HTTP 层打。
用法:python3 tests/test_proto.py
"""
import base64, json, os, re, shutil, socket, subprocess, sys, tempfile, time, urllib.parse, urllib.request
HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = []
def check(name, ok, detail=""):
RESULTS.append((name, bool(ok)))
print(("PASS " if ok else "FAIL ") + name + ((" —— " + str(detail)[:200]) if detail != "" else ""))
def free_port():
s = socket.socket()
s.bind(("127.0.0.1", 0))
p = s.getsockname()[1]
s.close()
return p
PORT = free_port()
BASE = "http://127.0.0.1:%d" % PORT
DATA = tempfile.mkdtemp(prefix="payproto_")
env = dict(os.environ, PAY_PORT=str(PORT), PAY_DATA_DIR=DATA, PAY_BASE_URL=BASE)
srv = subprocess.Popen([sys.executable, os.path.join(HERE, "app.py")], env=env,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
def req(method, path, obj=None, form=None, headers=None, raw=False):
data, h = None, dict(headers or {})
if obj is not None:
data = json.dumps(obj).encode()
h["Content-Type"] = "application/json"
if form is not None:
data = urllib.parse.urlencode(form).encode()
h["Content-Type"] = "application/x-www-form-urlencoded"
r = urllib.request.Request(BASE + path, data=data, method=method, headers=h)
try:
with urllib.request.urlopen(r, timeout=20) as resp:
body = resp.read().decode()
return resp.status, (body if raw else json.loads(body))
except urllib.error.HTTPError as e:
body = e.read().decode()
return e.code, (body if raw else json.loads(body or "{}"))
for _ in range(300):
try:
urllib.request.urlopen(BASE + "/", timeout=1)
break
except Exception:
time.sleep(0.2)
def new_order(n=2):
st, j = req("POST", "/api/order", {"n_img": n})
return j["order"]["oid"], j["token"], j
def view(oid, tok):
return req("GET", "/api/order?oid=%s&t=%s" % (oid, tok))[1]
def pay(oid, tok, ch):
return req("POST", "/api/pay", {"oid": oid, "t": tok, "channel": ch})[1]
def afd_pay_link(url, amount=None, drop=False):
qs = dict(urllib.parse.parse_qsl(urllib.parse.urlparse(url).query))
form = {"custom_order_id": qs["custom_order_id"], "remark": qs["remark"],
"amount": amount if amount is not None else qs["custom_price"]}
if drop:
form["drop"] = "on"
req("POST", "/mock/afdian/order/pay", form=form, raw=True)
return qs
def ali_scan_pay(qr_url, drop=False):
path = urllib.parse.urlparse(qr_url).path
req("GET", path, raw=True) # 扫码 → WAIT_BUYER_PAY
form = {"qr": path.rsplit("/", 1)[-1]}
if drop:
form["drop"] = "on"
return req("POST", "/mock/alipay/scanpay", form=form, raw=True)[1]
def demo(**kw):
return req("POST", "/api/demo", kw)[1]
def todos():
tok = open(os.path.join(DATA, "admin_token")).read().strip()
return req("GET", "/api/admin/overview", headers={"X-Admin-Token": tok})[1]["todo"]
def admin(path, obj):
tok = open(os.path.join(DATA, "admin_token")).read().strip()
return req("POST", path, obj, headers={"X-Admin-Token": tok})[1]
try:
# 1. 爱发电正常到账(Webhook)
oid, tok, j = new_order(2)
check("下单:应付 ¥12、状态 unpaid、两个渠道可选", j["order"]["amount"] == 12 and j["order"]["state"] == "unpaid"
and [c["name"] for c in j["channels"] if c["ok"]] == ["afdian", "alipay"])
r = pay(oid, tok, "afdian")
url = r["payment"]["display"]["url"]
check("爱发电专链带 custom_order_id=支付单号、custom_price=应付", "custom_order_id=%sP1" % oid in url
and "custom_price=12" in url, url)
afd_pay_link(url)
time.sleep(3)
v = view(oid, tok)
check("爱发电付款 → Webhook 验签 + 精确反查 → 订单 waiting", v["order"]["state"] == "waiting",
[e["kind"] + ":" + e["result"] for e in v["events"][:4]])
# 2. 同一笔 Webhook 重复推送 → 幂等
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
import sqlite3
con = sqlite3.connect(os.path.join(DATA, "pay.db"))
con.row_factory = sqlite3.Row
mo = dict(con.execute("SELECT * FROM mock_afd ORDER BY create_time DESC LIMIT 1").fetchone())
pk = serialization.load_pem_private_key(open(os.path.join(DATA, "mock_keys", "afdian_platform.pem"), "rb").read(), None)
content = "%s%s%s%s" % (mo["out_trade_no"], mo["user_id"], mo["plan_id"], mo["total_amount"])
sig = base64.b64encode(pk.sign(content.encode(), padding.PKCS1v15(), hashes.SHA256())).decode()
body = {"ec": 200, "data": {"type": "order", "order": mo, "sign": sig}}
st, resp = req("POST", "/api/notify/afdian", body)
n_settle = con.execute("SELECT COUNT(*) FROM pay_events WHERE kind='settle' AND pay_id=? AND result='activated'",
(oid + "P1",)).fetchone()[0]
dup = con.execute("SELECT COUNT(*) FROM pay_events WHERE kind='settle' AND pay_id=? AND result='dup_trade'",
(oid + "P1",)).fetchone()[0]
check("同一笔 Webhook 再推一次 → 只激活一次(dup_trade),仍回 ec=200", n_settle == 1 and dup >= 1 and resp.get("ec") == 200,
(n_settle, dup, resp))
# 3. 伪造回调(签名不对)→ 丢弃
oid3, tok3, _ = new_order(1)
p3 = pay(oid3, tok3, "afdian")["payment"]["pay_id"]
demo(kind="afdian_forge", pay_id=p3)
time.sleep(0.3)
check("伪造 Webhook(签名不对)→ 不激活", view(oid3, tok3)["order"]["state"] == "unpaid")
# 4. Webhook 丢失 → 对账补上
oid4, tok4, _ = new_order(1)
afd_pay_link(pay(oid4, tok4, "afdian")["payment"]["display"]["url"], drop=True)
time.sleep(2)
before = view(oid4, tok4)["order"]["state"]
demo(kind="jobs")
check("Webhook 丢了 → 定时对账发现并激活", before == "unpaid" and view(oid4, tok4)["order"]["state"] == "waiting", before)
# 5. 买家把金额改小 → 不激活,进待办
oid5, tok5, _ = new_order(3)
afd_pay_link(pay(oid5, tok5, "afdian")["payment"]["display"]["url"], amount="0.10")
time.sleep(3)
td = [t for t in todos() if t["oid"] == oid5]
check("实付 ¥0.10 < 应付 ¥18 → 不激活,待办「金额不足」", view(oid5, tok5)["order"]["state"] == "unpaid"
and td and td[0]["kind"] == "short", td[:1])
r = admin("/api/admin/todo", {"id": td[0]["id"], "action": "confirm", "note": "买家补了差价"})
check("后台「确认补齐」→ 订单激活", r.get("ok") and view(oid5, tok5)["order"]["state"] == "waiting", r)
# 6. 当面付正常:预下单 → 扫码 → 异步通知
oid6, tok6, _ = new_order(2)
r = pay(oid6, tok6, "alipay")
qr = r["payment"]["display"]["qr"]
check("当面付预下单 → 返回二维码内容和过期时间", r["ok"] and "/mock/alipay/scan/" in qr
and r["payment"]["expire_at"] > 0, r)
ali_scan_pay(qr)
time.sleep(3)
check("当面付付款 → 异步通知验签 → 订单 waiting", view(oid6, tok6)["order"]["state"] == "waiting")
# 7. 当面付异步通知丢失 → 页面轮询查单发现
oid7, tok7, _ = new_order(1)
r = pay(oid7, tok7, "alipay")
ali_scan_pay(r["payment"]["display"]["qr"], drop=True)
time.sleep(2)
st, v = req("GET", "/api/pay?pay_id=%s&t=%s" % (r["payment"]["pay_id"], tok7))
check("当面付通知丢了 → 页面轮询 trade.query 发现到账", v["order"]["state"] == "waiting")
# 8. 二维码过期 → 关单;订单超时 → closed;宽限内迟到付款 → 恢复
oid8, tok8, _ = new_order(1)
p8 = pay(oid8, tok8, "alipay")["payment"]
a8 = pay(oid8, tok8, "afdian")["payment"]
demo(kind="clock", seconds=16 * 60)
pays = {p["pay_id"]: p["state"] for p in view(oid8, tok8)["payments"]}
check("二维码 15 分钟没付 → 支付单关闭;爱发电支付单还在", pays[p8["pay_id"]] == "closed"
and pays[a8["pay_id"]] == "created", pays)
demo(kind="clock", seconds=25 * 3600)
check("超过 24 小时没付 → 订单 closed", view(oid8, tok8)["order"]["state"] == "closed")
afd_pay_link(a8["display"]["url"])
time.sleep(3)
check("关闭后宽限期内付了爱发电 → 订单自动恢复为 waiting", view(oid8, tok8)["order"]["state"] == "waiting",
[e["kind"] + ":" + e["result"] for e in view(oid8, tok8)["events"][:3]])
# 9. 两个渠道都付了 → 只激活一次,第二笔进待办
oid9, tok9, _ = new_order(1)
a9 = pay(oid9, tok9, "afdian")["payment"]
q9 = pay(oid9, tok9, "alipay")["payment"]
ali_scan_pay(q9["display"]["qr"])
time.sleep(3)
afd_pay_link(a9["display"]["url"])
time.sleep(3)
td = [t for t in todos() if t["oid"] == oid9]
check("先付支付宝、又付爱发电 → 订单只激活一次,爱发电那笔进待办「重复付款」",
view(oid9, tok9)["order"]["state"] == "waiting" and td and td[0]["kind"] == "duplicate", td[:1])
r = admin("/api/admin/todo", {"id": td[0]["id"], "action": "refund"})
check("爱发电重复付款点退款 → 提示去爱发电后台(没有退款接口)", not r.get("ok") and "爱发电" in r.get("error", ""), r)
# 10. 风控熔断
demo(kind="alipay_risk", on=True)
oid10, tok10, _ = new_order(1)
r = pay(oid10, tok10, "alipay")
v = view(oid10, tok10)
ali = [c for c in v["channels"] if c["name"] == "alipay"][0]
check("当面付返回风控错误码 → 熔断,页面不再提供支付宝,只剩爱发电", not r["ok"] and not ali["ok"], (r, ali))
demo(kind="alipay_risk", on=False)
demo(kind="breaker_reset")
check("后台恢复熔断后 → 支付宝重新可用",
[c for c in view(oid10, tok10)["channels"] if c["name"] == "alipay"][0]["ok"])
# 11. 买家直接在爱发电店铺下单(没带订单号)→ 按买卡密处理;后台按爱发电订单号认领
r = demo(kind="afdian_direct", amount=6)
time.sleep(3)
ev = con.execute("SELECT COUNT(*) FROM pay_events WHERE kind='card_purchase'").fetchone()[0]
check("没带订单号的爱发电成交 → 走「按实付发卡密」,不去猜是哪张单", ev >= 1)
oid11, tok11, _ = new_order(1)
r2 = admin("/api/admin/claim", {"oid": oid11, "trade_no": r["trade_no"]})
check("后台按爱发电订单号认领 → 订单激活", r2.get("ok") and view(oid11, tok11)["order"]["state"] == "waiting", r2)
# 12. 「付好了没反应?」→ 立即对账
oid12, tok12, _ = new_order(1)
afd_pay_link(pay(oid12, tok12, "afdian")["payment"]["display"]["url"], drop=True)
time.sleep(1.5)
st, r = req("POST", "/api/check", {"oid": oid12, "t": tok12})
check("买家点「付好了没反应?」→ 当场查到并激活", r.get("found") and view(oid12, tok12)["order"]["state"] == "waiting", r)
# 13. 鉴权
st, _ = req("GET", "/api/admin/overview")
check("后台接口没口令 → 403", st == 403)
st, _ = req("GET", "/api/order?oid=%s&t=wrong" % oid)
check("取件码不对 → 查不到订单", st == 404)
st, r = req("POST", "/api/pay", {"oid": oid, "t": tok, "channel": "afdian"})
check("已到账的订单不能再建支付单", not r.get("ok"), r)
finally:
srv.terminate()
try:
out = srv.communicate(timeout=5)[0].decode()
except Exception:
out = ""
shutil.rmtree(DATA, ignore_errors=True)
bad = [n for n, ok in RESULTS if not ok]
print("\n%d 条,失败 %d 条" % (len(RESULTS), len(bad)))
for n in bad:
print(" ✗ " + n)
if bad and out:
print(out[-2000:])
sys.exit(1 if bad else 0)