- 撕凭证:按住存根往外拉,拉够才撕下(没拉够弹回);撕下那一刻才发确认收货, 关弹窗 / 先不收货 = 没发生。留「直接撕下」按钮和回车键兜底。 - 重渲弹窗:把应出未出的模板列成「没出图」项(miss_tpls),失败单不再卡在「至少勾一张」; 什么信息都没有的老失败单直接整单重渲。服务器只认本单模板。 - 确认收货后:前端不再给免费重渲按钮,/api/redo 同样拒(直发单不受影响)。 - 状态接口给 files[].tpl、direct、accepted_by_buyer。 - 测试 +4(回执复现 33 条全过;数据库 38、内容后台 86 全过);浏览器实测 24 项全过。 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
3582 lines
180 KiB
Python
3582 lines
180 KiB
Python
#!/usr/bin/env python3
|
||
# -*- coding: utf-8 -*-
|
||
"""
|
||
金钻工坊 · 渲染下单 —— 服务器端(订单登记 / 队列 / 兑换码 / 状态)
|
||
|
||
设计要点
|
||
* 纯标准库(http.server),零依赖、内存小 —— 这台机器只有 1.6G 内存
|
||
* 数据在 SQLite(<DATA_DIR>/ys.db,见 store.py):卡密 / 订单 / 爱发电账本 / 呼叫记录 / 小块状态;
|
||
订单的 state 字段 = 队列状态。皮肤和成品**文件**还在 orders/<订单号>/ 目录里
|
||
* 渲染机主动出站拉单(宿主只能出站),服务器不主动连宿主
|
||
* 管理操作全走本地 CLI(admin.py),**不开任何公网管理入口**
|
||
|
||
监听 localhost:8080,由 nginx 反代 /order/api/ → 这里
|
||
"""
|
||
import base64, subprocess, hashlib, hmac, json, os, random, re, secrets, shutil, struct, sys, tempfile, threading, time, zipfile
|
||
import urllib.request, urllib.error
|
||
from datetime import datetime, timedelta, timezone
|
||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||
from urllib.parse import urlparse, parse_qs, unquote, quote
|
||
|
||
ROOT = os.environ.get("YS_ROOT", "<DATA_DIR>")
|
||
ORDERS = os.path.join(ROOT, "orders")
|
||
CODES_FILE = os.path.join(ROOT, "codes.json")
|
||
# 付款方式信息(爱发电链接 / 收款码图):金钻 2026-10-01
|
||
PAYINFO_FILE = os.path.join(ROOT, "payinfo.json")
|
||
# ----------------------------------------------------------------- 爱发电
|
||
# 金钻 2026-10-01:爱发电「自动发货 / 订单推送」对接。
|
||
# 凭据放 <DATA_DIR>/payplatform.json(640,www-data)—— 和 admin_token/worker_token 一个路子。
|
||
# 为什么不验它的 RSA 签名:手头没有爱发电公钥,而**用开放接口反查这笔单**更硬
|
||
# (查得到、状态=已付款、金额对得上,才发码)。社区 SDK 也是这么干的。
|
||
PAYPLATFORM_CONF = os.path.join(ROOT, "payplatform.json")
|
||
PAYPLATFORM_MAP = os.path.join(ROOT, "payplatform-map.json")
|
||
PAYPLATFORM_LEDGER = os.path.join(ROOT, "payplatform-orders.json") # out_trade_no -> 记录(幂等:同一单重推不会重复发码)
|
||
PAYPLATFORM_LOG = os.path.join(ROOT, "payplatform-hook.log")
|
||
|
||
|
||
def payplatform_creds():
|
||
try:
|
||
d = jload(PAYPLATFORM_CONF, {})
|
||
return (d.get("user_id") or "").strip(), (d.get("token") or "").strip()
|
||
except Exception:
|
||
return "", ""
|
||
|
||
|
||
def payplatform_api(path, params=None):
|
||
"""调爱发电开放接口。签名算法:md5(token + 'params' + params + 'ts' + ts + 'user_id' + user_id)。"""
|
||
uid, tok = payplatform_creds()
|
||
if not uid or not tok:
|
||
return {"ec": -1, "em": "没配爱发电凭据(<DATA_DIR>/payplatform.json)"}
|
||
ps = json.dumps(params or {"page": 1}, ensure_ascii=False, separators=(",", ":"))
|
||
ts = str(int(time.time()))
|
||
sign = hashlib.md5(("%sparams%sts%suser_id%s" % (tok, ps, ts, uid)).encode("utf-8")).hexdigest()
|
||
body = json.dumps({"user_id": uid, "params": ps, "ts": int(ts), "sign": sign}).encode("utf-8")
|
||
req = urllib.request.Request("http<WIN-PATH>" % path, data=body,
|
||
headers={"Content-Type": "application/json"})
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=20) as r:
|
||
return json.loads(r.read())
|
||
except Exception as e:
|
||
return {"ec": -1, "em": "调用失败:%r" % e}
|
||
|
||
|
||
def _hook_unverified(oid_af, order, why, ip):
|
||
"""没验证过的爱发电回调:只留最近 50 条在 kv「hook_unverified」里,给金钻人工核对用(2026-10-06 安全加固)。
|
||
字段全部截断,不进账本 pay_orders —— 伪造的报文刷再多也只占这 50 格。"""
|
||
try:
|
||
lst = STORE.kv_get("hook_unverified", []) or []
|
||
lst.append({"ts": now().isoformat(timespec="seconds"), "out_trade_no": str(oid_af)[:64], "why": why[:60],
|
||
"amount": str(order.get("show_amount") or order.get("total_amount") or "")[:16],
|
||
"title": ("%s %s" % (order.get("plan_title") or "", order.get("title") or "")).strip()[:60], "ip": str(ip)[:45]})
|
||
STORE.kv_put("hook_unverified", lst[-50:])
|
||
except Exception as e:
|
||
log("记待核对回调失败:%s" % e)
|
||
|
||
|
||
def payplatform_find_order(out_trade_no, pages=3):
|
||
"""按订单号反查(确认这笔真的存在、真的付款了)。返回订单 dict 或 None。"""
|
||
for pg in range(1, pages + 1):
|
||
r = payplatform_api("query-order", {"page": pg})
|
||
if r.get("ec") != 200:
|
||
return None
|
||
for o in ((r.get("data") or {}).get("list") or []):
|
||
if str(o.get("out_trade_no")) == str(out_trade_no):
|
||
return o
|
||
if pg >= int((r.get("data") or {}).get("total_page") or 1):
|
||
break
|
||
return None
|
||
|
||
|
||
def payplatform_img_count(order):
|
||
"""这笔订单该发几张的码:先看规格名,再看金额,最后按 ÷单价 兜底。"""
|
||
m = jload(PAYPLATFORM_MAP, {}) or {}
|
||
sku_map = m.get("sku") or {}
|
||
amt_map = m.get("amount") or {}
|
||
for d in (order.get("sku_detail") or []):
|
||
nm = (d.get("name") or "").strip()
|
||
cnt = int(d.get("count") or 1)
|
||
if nm and nm in sku_map:
|
||
return max(1, int(sku_map[nm]) * cnt)
|
||
amt = str(order.get("show_amount") or order.get("total_amount") or "").strip()
|
||
try:
|
||
amt_f = float(amt)
|
||
except (TypeError, ValueError):
|
||
amt_f = 0.0
|
||
if amt in amt_map:
|
||
return max(1, int(amt_map[amt]))
|
||
return max(1, int(round(amt_f / PRICE_UNIT)) or 1)
|
||
|
||
HB_FILE = os.path.join(ROOT, "heartbeat.json")
|
||
|
||
|
||
def payplatform_paid(order):
|
||
"""这笔爱发电订单**实际到手多少钱**(元)。金钻 2026-10-03 加的金额闸门用它。"""
|
||
try:
|
||
return float(str(order.get("show_amount") or order.get("total_amount") or "0").strip())
|
||
except (TypeError, ValueError):
|
||
return 0.0
|
||
|
||
|
||
def _yuan(x):
|
||
"""把金额显示得像人话:20.0 → "20"、18.5 → "18.5"、0.1 → "0.1"。"""
|
||
try:
|
||
return "%g" % float(x)
|
||
except (TypeError, ValueError):
|
||
return str(x)
|
||
|
||
|
||
|
||
CALLS_FILE = os.path.join(ROOT, "calls.jsonl")
|
||
# 每个模板「渲一张要多久」的历史样本(金钻 2026-10-04:给买家一个预计完成时间)
|
||
TPL_TIMES_FILE = os.path.join(ROOT, "tpl_times.json")
|
||
TOKEN_FILE = os.path.join(ROOT, "worker_token")
|
||
ADMIN_FILE = os.path.join(ROOT, "admin_token") # 管理后台令牌(金钻电脑上的面板用)
|
||
HB_IPS_FILE = os.path.join(ROOT, "home_ips.json") # 金钻家网络的出口 IP(渲染机心跳认出来的)
|
||
TMP_DIR = os.path.join(ROOT, "tmp") # 打包 zip 的临时目录(打完就删)
|
||
LOG_FILE = os.path.join(ROOT, "server.log")
|
||
|
||
os.makedirs(ROOT, exist_ok=True) # 模块导入时就要保证目录存在(token 文件要写进去)
|
||
|
||
# 数据库(2026-10-05):第一次启动自动建库,并把旧版 JSON(codes.json / meta.json / 账本 …)导进来,
|
||
# 旧文件原样留着。回退:python3 store.py export。详见 store.py 开头和交接说明「数据库」一节。
|
||
import store # noqa: E402 同目录,零依赖
|
||
STORE = store.Store(ROOT)
|
||
|
||
HOST, PORT = "localhost", 8080
|
||
KEEP_HOURS = 72 # 成品在服务器保留时长
|
||
OFFLINE_AFTER = 1500 # 心跳超过这么多秒 = 离线
|
||
# ⚠️ 必须 > 心跳间隔。渲染机 hb_every=600(10 分钟);1500 = 容许漏掉一次心跳,
|
||
# 否则网络抖一下就被误判离线。改 hb_every 必须一起改这里。
|
||
# ⚠️ base64 会涨约 33%:10MB 的皮肤 → JSON 里约 13.4MB,所以请求体要留够
|
||
MAX_BODY = 15 * 1024 * 1024 # 前台提交(含 base64 皮肤)
|
||
MAX_BODY_WK = 16 * 1024 * 1024 # 渲染机回传(一张成品一次)
|
||
MAX_SKIN = 10 * 1024 * 1024 # 单个皮肤文件上限(金钻 2026-10-02:4MB → 10MB)
|
||
MIN_SIDE, MAX_SIDE = 16, 4096 # 皮肤分辨率不是固定的:64 是基准,128/256/512/1024 都是 64 网格的整倍数放大
|
||
|
||
# 出图分辨率(金钻 2026-09-30):默认 1000 = 网易我的世界头图标准分辨率。
|
||
# 4096 一张要渲约 10 分钟,所以高峰期让它**让路给后面的小单**,免得一张大图堵住一整队。
|
||
ALLOWED_RES = (1000, 1024, 2048, 4096)
|
||
DEFAULT_RES = 1000
|
||
HEAVY_RES = 4096 # 视为"重单"的分辨率
|
||
HEAVY_WAIT_MIN = 30 # 重单最多让路这么久,超过就按到达顺序正常排(防饿死)
|
||
MAX_IMAGES = 10 # 一单最多几张
|
||
STALE_MIN = 45 # 渲染机领单后超过这么久没交回 → 自动退回队列
|
||
# 打包下载(金钻 2026-09-30「文件下载允许打包下载…挨个下太慢了」):
|
||
# zip 先落临时文件再边读边发,**不进内存**(这台机器只有 1.6G,MemoryMax=256M)。
|
||
MAX_ZIP_BYTES = 600 * 1024 * 1024 # 一单成品合计超过这个数就拒绝打包,让他分开下
|
||
ZIP_CHUNK = 64 * 1024
|
||
ZIP_SEM = threading.BoundedSemaphore(1) # 同一时间只打一个包(2026-10-05 外部复查)
|
||
|
||
CST = timezone(timedelta(hours=8))
|
||
|
||
|
||
class _DataLock(object):
|
||
"""线程锁 + 跨进程文件锁(2026-10-05 外部复查加)。
|
||
|
||
⚠️ 原来的 LOCK 只是 threading.Lock —— 只管得住**本进程**里的线程。
|
||
admin.py(发码 / 核销 / sweep)是**另一个进程**,跟服务器同时改 codes.json 时会互相覆盖:
|
||
比如 CLI 发码那一刻刚好有买家提交,CLI 存回去的旧快照会把买家刚绑上的码改回「可用」。
|
||
所以在线程锁之外再加一把 flock(<DATA_DIR>/.lock)。用法不变:`with LOCK:`。
|
||
拿不到文件锁(非 Linux / 没权限)就只用线程锁,并且记一笔日志 —— 不让它把服务拖死。
|
||
"""
|
||
|
||
def __init__(self, path):
|
||
self._t = threading.Lock()
|
||
self._path = path
|
||
self._fh = None
|
||
self._warned = False
|
||
|
||
def __enter__(self):
|
||
self._t.acquire()
|
||
try:
|
||
import fcntl
|
||
if self._fh is None:
|
||
self._fh = open(self._path, "a+")
|
||
fcntl.flock(self._fh.fileno(), fcntl.LOCK_EX)
|
||
except Exception as e: # noqa: BLE001 —— 文件锁拿不到不能影响主流程
|
||
if self._fh is not None:
|
||
try:
|
||
self._fh.close()
|
||
except Exception:
|
||
pass
|
||
self._fh = None
|
||
if not self._warned:
|
||
self._warned = True
|
||
try:
|
||
print("⚠️ 跨进程文件锁不可用,只用线程锁:%r" % (e,), flush=True)
|
||
except Exception:
|
||
pass
|
||
return self
|
||
|
||
def __exit__(self, *exc):
|
||
try:
|
||
if self._fh is not None:
|
||
import fcntl
|
||
fcntl.flock(self._fh.fileno(), fcntl.LOCK_UN)
|
||
except Exception:
|
||
pass
|
||
finally:
|
||
self._t.release()
|
||
return False
|
||
|
||
|
||
LOCK = _DataLock(os.path.join(ROOT, ".lock"))
|
||
HOOK_LOCK = threading.Lock() # 爱发电回调 + 账本读写串行(回调很少,串行没有代价)
|
||
# 臂型中文名(小票/页面文案用,和前端 ARMTXT 保持一致)
|
||
ARMTXT = {"classic": "粗臂", "slim": "细臂", "auto": "自动判定"}
|
||
|
||
# ---- 防滥用(金钻 2026-09-30 提出"会不会被暴力破解")----
|
||
# 结论:码空间 31^12≈7.9e17,盲猜命中率 ~1e-15,**暴破本身打不进来**;
|
||
# 真正的风险是「刷接口 / 灌图占盘 / 拿订单号试探」。所以守这几条:
|
||
IP_FAILS = {} # ip -> [失败时间戳] 兑换码连续输错 → 冷却
|
||
IP_SUBS = {} # ip -> [提交时间戳] 同一 IP 提交频率
|
||
IP_SKINS = {} # ip -> [追补皮肤时间戳] 追补单独一档(买家可能一次补好几张皮肤)
|
||
FAIL_WIN = 600 # 失败统计窗口(秒)
|
||
FAIL_MAX = 15 # 窗口内失败上限 → 冷却
|
||
FAIL_COOL = 900 # 冷却时长(秒)
|
||
SUB_WIN = 600 # 提交统计窗口
|
||
SUB_MAX = 6 # 窗口内最多提交几单(正常买家够用)
|
||
DISK_FLOOR = 1024**3 # 剩余空间低于 1G 不再收新单
|
||
|
||
# 服务条款版本(2026-09-30 金钻定)。⚠️ 条款文案一改,这里必须跟着改 ——
|
||
# 订单里记下版本号,日后争议时才能证明"买家当时同意的是哪一版"。
|
||
# 合法模板 key(与下单页 / 渲染机三方一致;airship 不是 air!)
|
||
TPL_KEYS = ("stand", "standb", "wheat", "beach", "boom", "sakura", "airship")
|
||
PRICE_UNIT = 6 # 一张图 ¥(金钻定,用于网页单计额)
|
||
# ----------------------------------------------------------------- 价格档位
|
||
# 金钻 2026-10-01:「我想根据张数和优惠来设置针对的专属购买价格链接」
|
||
# → 每档 = 张数 → {价格, 对应的爱发电商品链接}。买 3 张想给优惠价/专属链接,就写这一档。
|
||
# 页面上「应付」和「去爱发电付款」按钮会**按买家选的张数自动切到对应档**。
|
||
# 没配的档 = 按 PRICE_UNIT × 张数 算。
|
||
PRICES_FILE = os.path.join(ROOT, "prices.json")
|
||
FEEDBACK_DIR = os.path.join(ROOT, "feedback") # 买家反馈(可带图)
|
||
# ----------------------------------------------------------------- 福利券(赛博鸡蛋)
|
||
# 金钻 2026-10-01:「偶尔搞点福利,发点渲染券 —— 不定期投送兑换码,**待激活**的,不需要付费
|
||
# 就能领取,只限制张数、自由拿取;或者我开新模板,他们可以领来渲(限张数和次数)。」
|
||
# → 券池 = 一批已激活、免付费的码;买家在福利页**自取**(先到先得),领到的码拿去「卡密下单」。
|
||
GIFTS_FILE = os.path.join(ROOT, "gifts.json")
|
||
|
||
|
||
def gift_batches():
|
||
"""福利券批次(列表)。每条:
|
||
id/name/note/total/each/expire/enabled/created
|
||
n_fix(可出几张)/ tpl(锁定的模板 key,逗号分隔)/ lock_tpl(是否锁死模板)
|
||
kind(券的种类:render=渲染图 / standee=立牌 / keychain=钥匙扣 / …未来扩展)
|
||
shape(版式:square/横版 portrait…留字段,先不用)
|
||
"""
|
||
d = STORE.kv_get("gifts", {})
|
||
if not isinstance(d, dict) or not isinstance(d.get("batches"), list):
|
||
d = {"batches": []}
|
||
return d
|
||
|
||
|
||
GIFT_KINDS = {"render": "渲染图", "standee": "立牌", "keychain": "钥匙扣", "poster": "海报"}
|
||
|
||
|
||
def gift_stat(bid):
|
||
"""一批券的领取情况:总数 / 已领 / 还剩"""
|
||
cs = load_codes()
|
||
total = used = 0
|
||
for c, r in cs.items():
|
||
if r.get("gift") == bid:
|
||
total += 1
|
||
if r.get("claim_token"):
|
||
used += 1
|
||
return {"total": total, "claimed": used, "left": max(0, total - used)}
|
||
|
||
|
||
def gift_view():
|
||
"""给买家看的券池。**分三段**(金钻 2026-10-02:「没有了就变灰,点进去说已领完/暂无发放;
|
||
有就显示剩余张数」):
|
||
open = 还能领的(带剩余张数)
|
||
gone = 领完了的
|
||
closed = 收摊/过期的
|
||
"""
|
||
today = now().strftime("%Y-%m-%d")
|
||
out = {"open": [], "gone": [], "closed": []}
|
||
for b in gift_batches()["batches"]:
|
||
st = gift_stat(b["id"])
|
||
kind = b.get("kind") or "render"
|
||
item = {"id": b["id"], "name": b.get("name") or "福利券", "note": b.get("note") or "",
|
||
"each": 1, # 金钻定死:每设备 + 每 IP 各一张
|
||
"n_max": int(b.get("n_fix") or 1), # 福利券口径:**最多**这么多张(可以少)
|
||
"n_fix": int(b.get("n_fix") or 1), # 兼容旧字段名
|
||
"n_free": bool(b.get("n_free")),
|
||
"tpl": b.get("tpl") or "", "lock_tpl": bool(b.get("lock_tpl")),
|
||
"kind": kind, "kind_name": GIFT_KINDS.get(kind, kind),
|
||
"shape": b.get("shape") or "square",
|
||
"leave": st["left"], "total": st["total"], "expire": b.get("expire") or ""}
|
||
if not b.get("enabled", True):
|
||
item["why"] = "已收摊"
|
||
out["closed"].append(item)
|
||
elif b.get("expire") and str(b["expire"]) < today:
|
||
item["why"] = "已过期"
|
||
out["closed"].append(item)
|
||
elif st["left"] <= 0:
|
||
item["why"] = "已领完"
|
||
out["gone"].append(item)
|
||
else:
|
||
out["open"].append(item)
|
||
return out
|
||
|
||
|
||
def gift_public():
|
||
"""兼容老调用:只要"还能领的"那些"""
|
||
return gift_view()["open"]
|
||
|
||
|
||
|
||
def gift_claim_days():
|
||
"""福利券领到后**多久必须用掉**(金钻 2026-10-02:领了不用要逾期)"""
|
||
try:
|
||
return max(1, int((STORE.kv_get("gifts", {}) or {}).get("claim_days") or 7))
|
||
except (TypeError, ValueError):
|
||
return 7
|
||
|
||
|
||
def gift_expire_text(iso_ts):
|
||
"""把过期时间说成人话:还有 3 天 5 小时 / 已过期。"""
|
||
if not iso_ts:
|
||
return ""
|
||
try:
|
||
left = datetime.fromisoformat(iso_ts) - now()
|
||
except (TypeError, ValueError):
|
||
return ""
|
||
sec = int(left.total_seconds())
|
||
if sec <= 0:
|
||
return "已过期"
|
||
d, h, m = sec // 86400, (sec % 86400) // 3600, (sec % 3600) // 60
|
||
if d:
|
||
return "还有 %d 天 %d 小时" % (d, h)
|
||
if h:
|
||
return "还有 %d 小时 %d 分" % (h, m)
|
||
return "还有 %d 分钟" % max(1, m)
|
||
|
||
|
||
def coupon_status(c, cs=None):
|
||
"""一张券现在什么状态(给"我的卡券"用)。返回 dict。
|
||
|
||
cs:调用方已经读好的 codes(批量查时只读一次文件,2026-10-05 外部复查)。"""
|
||
if cs is None:
|
||
cs = load_codes()
|
||
rec = cs.get(c)
|
||
if not rec:
|
||
return {"code": c, "status": "unknown", "text": "查不到这张券"}
|
||
st = code_state(rec)
|
||
exp = rec.get("claim_expire") or ""
|
||
# 老券(领的时间早于"逾期"功能上线)也要有到期时间:按 claim_ts + 默认天数补算
|
||
if not exp and rec.get("claim_ts"):
|
||
try:
|
||
exp = (datetime.fromisoformat(rec["claim_ts"])
|
||
+ timedelta(days=gift_claim_days())).isoformat(timespec="seconds")
|
||
except (TypeError, ValueError):
|
||
exp = ""
|
||
left = gift_expire_text(exp) if exp else ""
|
||
if st == "used":
|
||
return {"code": c, "status": "used", "text": "已核销(成品也过期了)"}
|
||
if st == "bound":
|
||
return {"code": c, "status": "used", "text": "已用" + ("(订单 %s)" % rec.get("order") if rec.get("order") else "")}
|
||
if st == "inactive":
|
||
return {"code": c, "status": "unpaid", "text": "未激活(等付款)"}
|
||
if exp and left == "已过期":
|
||
return {"code": c, "status": "expired", "text": "已过期(领了没用掉)"}
|
||
kind = GIFT_KINDS.get(rec.get("gift_kind") or "", "")
|
||
# 到期时间要**写出来**(金钻 2026-10-02:「没标记过期时间」)——
|
||
# 光说"还有 6 天"不够,得让他知道到底哪天几点到期
|
||
exp_h = exp.replace("T", " ")[:16] if exp else ""
|
||
return {"code": c, "status": "ok",
|
||
"text": ("可以用" + (",%s 到期(%s)" % (exp_h, left) if exp_h else "")),
|
||
"expire_h": exp_h,
|
||
"n_max": int(rec.get("n_max") or rec.get("n_fix") or 1),
|
||
"n_free": bool(rec.get("n_free")), "tpl": rec.get("tpl") or "",
|
||
"lock_tpl": bool(rec.get("lock_tpl")), "kind_name": kind,
|
||
"expire": exp, "left": left}
|
||
|
||
|
||
def gift_claim(bid, token, ip):
|
||
"""领一张:返回 (ok, 结果或错误信息)。
|
||
|
||
⚠️ 规则(金钻 2026-10-01 定死:**每个设备 + 每个 IP 各只能领一张**,都是防刷的,别改):
|
||
· 同一批次:**每台设备 1 张**(设备标识存 localStorage,叫 GIFT_KEY)
|
||
· 同一批次:**每个 IP 1 张**(换了浏览器/清了缓存也一样拦得住)
|
||
· 先到先得 —— 剩 0 就没了,不补
|
||
换一批(比如新模板试玩)就是新的一轮,还能再领一张 ✔
|
||
"""
|
||
tok = re.sub(r"[^0-9A-Za-z_-]", "", str(token or ""))[:40]
|
||
if not tok:
|
||
return False, "领不了:页面标识丢了,刷新一下再试"
|
||
bs = gift_batches()["batches"]
|
||
b = next((x for x in bs if x.get("id") == bid), None)
|
||
if not b or not b.get("enabled", True):
|
||
return False, "这一批福利已经收摊了"
|
||
today = now().strftime("%Y-%m-%d")
|
||
if b.get("expire") and str(b["expire"]) < today:
|
||
return False, "这批券过期了"
|
||
with LOCK:
|
||
cs = load_codes()
|
||
mine = [c for c, r in cs.items() if r.get("gift") == bid and isinstance(tok, str) and tok
|
||
and hmac.compare_digest(str(r.get("claim_token") or ""), tok)] # 定长比较(2026-10-06 安全加固)
|
||
if mine:
|
||
return False, "你已经领过啦 —— 这批每人限一张 😉 想多要就等下一波福利"
|
||
ip_n = len([c for c, r in cs.items()
|
||
if r.get("gift") == bid and r.get("claim_ip") == ip])
|
||
if ip_n:
|
||
return False, "这台设备/这个网络已经领过了 —— 这批每人限一张"
|
||
pool = [c for c, r in cs.items()
|
||
if r.get("gift") == bid and not r.get("claim_token") and code_state(r) == "active"]
|
||
if not pool:
|
||
return False, "手慢了 —— 这批已经被领完啦"
|
||
pick = secrets.choice(pool)
|
||
cs[pick]["claim_token"] = tok
|
||
cs[pick]["claim_ip"] = ip
|
||
cs[pick]["claim_ts"] = now().isoformat(timespec="seconds")
|
||
# 领了要**用掉**:X 天内有效(金钻 2026-10-02:领了不用要逾期,逾期要提示还剩多久)
|
||
_days = gift_claim_days()
|
||
cs[pick]["claim_expire"] = (now() + timedelta(days=_days)).isoformat(timespec="seconds")
|
||
cs[pick]["gift_kind"] = b.get("kind") or "render"
|
||
save_codes(cs)
|
||
log("福利券 %s 被领走:%s(%s)" % (bid, pick, ip))
|
||
rec = load_codes().get(pick) or {}
|
||
mx = int(rec.get("n_max") or rec.get("n_fix") or 1)
|
||
_exp = (load_codes().get(pick) or {}).get("claim_expire") or ""
|
||
return True, {"code": pick, "n_max": mx, "n_fix": mx,
|
||
"free": bool(rec.get("n_free")),
|
||
"tpl": rec.get("tpl") or "", "lock_tpl": bool(rec.get("lock_tpl")),
|
||
"expire": _exp, "expire_text": gift_expire_text(_exp),
|
||
"left": gift_stat(bid)["left"]}
|
||
|
||
|
||
# ---------------------------------------------------- 福利券批次的 建/补/收
|
||
# 金钻 2026-10-02:面板(金钻日常用的那块)也要能开/管免费码 —— 原来是 admin.py CLI 独有。
|
||
# ⚠️ 逻辑只写这一处:admin.py 的 `gift new/add/off` 和面板的 /api/admin/gift/* 都调这里。
|
||
# 两边各写一遍必然漂移(这库里的血泪教训)。
|
||
GIFT_ID_ALPH = "abcdefghijkmnpqrstuvwxyz23456789"
|
||
|
||
|
||
def gift_batch_new(name, count=20, n_fix=1, n_free=False, tpl="", lock_tpl=False,
|
||
days=0, note="", kind="render", direct=True, each=1):
|
||
"""建一批福利券(顺带把券一起生成了)。返回 (批次id, 新码列表);参数不对 raise ValueError。
|
||
|
||
金钻 2026-10-01「赛博鸡蛋」:一批**免费、免付费、只限张数**的码,买家在福利页自取。
|
||
* n_fix > 0 → **最多**出 n_fix 张(可以少,见 gift_batch_add 的注释)
|
||
* n_free → 不限张数
|
||
* tpl + lock_tpl → 锁死模板(试玩券)
|
||
* days → N 天后自动收摊
|
||
* kind → 券的种类:render=渲染图 / standee=立牌 / …
|
||
"""
|
||
name = (name or "").strip()[:40]
|
||
if not name:
|
||
raise ValueError("批次得有个名字")
|
||
try:
|
||
count = int(count)
|
||
except (TypeError, ValueError):
|
||
raise ValueError("张数不合法")
|
||
if not (1 <= count <= 500):
|
||
raise ValueError("一批 1~500 张")
|
||
try:
|
||
n_fix = int(n_fix or 0)
|
||
except (TypeError, ValueError):
|
||
raise ValueError("张数不合法")
|
||
if n_fix < 0 or n_fix > MAX_IMAGES:
|
||
raise ValueError("最多张数要在 0~%d 之间" % MAX_IMAGES)
|
||
if n_free and n_fix:
|
||
raise ValueError("「不限张数」和「最多 N 张」只能选一个")
|
||
tpls = [x.strip() for x in str(tpl or "").split(",") if x.strip()]
|
||
bad = [x for x in tpls if x not in TPL_KEYS]
|
||
if bad:
|
||
raise ValueError("模板不认识:%s" % "、".join(bad))
|
||
if lock_tpl and not tpls:
|
||
raise ValueError("要锁模板,得先选模板")
|
||
kind = (kind or "render").strip()[:20] or "render"
|
||
try:
|
||
days = max(0, int(days or 0))
|
||
except (TypeError, ValueError):
|
||
days = 0
|
||
# ⚠️ 只按秒取 id 会撞车(同一秒建两批 → 同一个 id,券和批次全串了,2026-10-02 实踩)→ 补 3 个随机位
|
||
bid = "g" + time.strftime("%m%d%H%M%S") + "".join(
|
||
secrets.choice(GIFT_ID_ALPH) for _ in range(3))
|
||
with LOCK:
|
||
d = gift_batches()
|
||
d["batches"].append({
|
||
"id": bid, "name": name, "note": (note or "").strip()[:200],
|
||
"n_fix": n_fix, "n_free": bool(n_free), "kind": kind,
|
||
"each": max(1, int(each or 1)), "tpl": ",".join(tpls),
|
||
"lock_tpl": bool(lock_tpl) and bool(tpls),
|
||
"expire": (time.strftime("%Y-%m-%d", time.localtime(time.time() + days * 86400))
|
||
if days else ""),
|
||
"enabled": True, "direct": bool(direct),
|
||
"created": now().isoformat(timespec="seconds"),
|
||
})
|
||
STORE.kv_put("gifts", d)
|
||
codes = gift_batch_add(bid, count, direct=direct)
|
||
log("福利券批次建好 %s「%s」%d 张(%s)" % (
|
||
bid, name, len(codes), "不限张数" if n_free else "最多 %d 张" % n_fix))
|
||
return bid, codes
|
||
|
||
|
||
def gift_batch_add(bid, count=20, direct=None):
|
||
"""给现有批次补货(再生成 N 张)。返回新码列表;批次不存在/张数不对 raise ValueError。
|
||
|
||
direct=None → 沿用建批次时的直发设置(老批次没这个字段 → 默认直发)。
|
||
"""
|
||
d = gift_batches()
|
||
b = next((x for x in d["batches"] if x.get("id") == bid), None)
|
||
if not b:
|
||
raise ValueError("没有这个批次:%s" % bid)
|
||
try:
|
||
count = int(count)
|
||
except (TypeError, ValueError):
|
||
raise ValueError("张数不合法")
|
||
if not (1 <= count <= 500):
|
||
raise ValueError("一次补 1~500 张")
|
||
if direct is None:
|
||
direct = bool(b.get("direct", True))
|
||
# ⚠️ 福利券用 **n_max(最多 N 张、可以少)**,不用 n_fix(必须正好)——
|
||
# 金钻 2026-10-02:「限可选数量的…指定张数内的,可以多张皮肤凑」。
|
||
# 用 n_fix 的话,提交时(只有 1 张皮肤)就会被"必须正好 3 张"拦住,永远用不了。
|
||
got = gen_codes(count, batch="福利-%s" % (b.get("name") or bid), value=0,
|
||
platform="福利", tpl=b.get("tpl") or "",
|
||
n_max=0 if b.get("n_free") else int(b.get("n_fix") or 1),
|
||
n_free=bool(b.get("n_free")), direct=bool(direct),
|
||
lock_tpl=bool(b.get("lock_tpl")))
|
||
# ⚠️ 2026-10-05(外部复查):原来这段在锁外读写 codes.json —— 恰好有人在下单 / 领券的话,
|
||
# 存回去的旧快照会把别人刚改的码冲掉。
|
||
with LOCK:
|
||
cs = load_codes()
|
||
for c in got:
|
||
if c in cs:
|
||
cs[c]["gift"] = bid
|
||
save_codes(cs)
|
||
log("福利券批次 %s 补货 %d 张" % (bid, len(got)))
|
||
return got
|
||
|
||
|
||
def gift_batch_off(bid):
|
||
"""收摊(已领到手的券不受影响)。批次不存在 raise ValueError。"""
|
||
with LOCK:
|
||
d = gift_batches()
|
||
b = next((x for x in d["batches"] if x.get("id") == bid), None)
|
||
if not b:
|
||
raise ValueError("没有这个批次:%s" % bid)
|
||
b["enabled"] = False
|
||
STORE.kv_put("gifts", d)
|
||
log("福利券批次 %s 已收摊" % bid)
|
||
return b
|
||
|
||
|
||
def gift_admin_view(claims_limit=300, pool_limit=500):
|
||
"""面板用:批次全貌 + 领取情况(谁在什么时候、哪个 IP 领了哪张)+ 剩余券池。
|
||
|
||
统计一律复用 gift_stat(),不另写一套(会和买家看到的数不一致)。
|
||
pool = 还没被领走的券 —— 面板每张卡上的「复制发卡文本」用它。
|
||
"""
|
||
today = now().strftime("%Y-%m-%d")
|
||
cs = load_codes()
|
||
out = []
|
||
for b in gift_batches()["batches"]:
|
||
st = gift_stat(b["id"])
|
||
claims, pool = [], []
|
||
for c, r in cs.items():
|
||
if r.get("gift") != b["id"]:
|
||
continue
|
||
if r.get("claim_token"):
|
||
claims.append({"code": c, "ts": r.get("claim_ts") or "",
|
||
"ip": r.get("claim_ip") or "",
|
||
"state": code_state(r), "order": r.get("order") or ""})
|
||
elif code_state(r) == "active":
|
||
pool.append(c)
|
||
claims.sort(key=lambda x: x["ts"] or "", reverse=True)
|
||
pool.sort()
|
||
kind = b.get("kind") or "render"
|
||
out.append({
|
||
"id": b["id"], "name": b.get("name") or "福利券", "note": b.get("note") or "",
|
||
"each": int(b.get("each") or 1), "n_fix": int(b.get("n_fix") or 1),
|
||
"n_free": bool(b.get("n_free")), "tpl": b.get("tpl") or "",
|
||
"lock_tpl": bool(b.get("lock_tpl")), "kind": kind,
|
||
"kind_name": GIFT_KINDS.get(kind, kind),
|
||
"expire": b.get("expire") or "", "enabled": bool(b.get("enabled", True)),
|
||
"created": b.get("created") or "",
|
||
"expired": bool(b.get("expire") and str(b["expire"]) < today),
|
||
"total": st["total"], "claimed": st["claimed"], "left": st["left"],
|
||
"n_claims": len(claims), "claims": claims[:claims_limit],
|
||
"n_pool": len(pool), "pool": pool[:pool_limit],
|
||
})
|
||
out.sort(key=lambda x: x.get("created") or "", reverse=True)
|
||
return {"ok": True, "batches": out, "tpl_keys": list(TPL_KEYS),
|
||
"kinds": GIFT_KINDS, "claim_days": gift_claim_days()}
|
||
|
||
|
||
def price_tiers():
|
||
"""读价格档位表。结构:{"per": 6, "tiers": {"1": {"price": 6, "payplatform": "..."}, ...}}"""
|
||
d = jload(PRICES_FILE, {}) or {}
|
||
if not isinstance(d.get("tiers"), dict):
|
||
d["tiers"] = {}
|
||
try:
|
||
d["per"] = float(d.get("per") or PRICE_UNIT)
|
||
except (TypeError, ValueError):
|
||
d["per"] = float(PRICE_UNIT)
|
||
return d
|
||
|
||
|
||
def price_for(n_img, tiers=None):
|
||
"""n 张图该收多少(有档位用档位价,没有就按单价×张数)。"""
|
||
n = max(1, int(n_img or 1))
|
||
t = (tiers or price_tiers()).get("tiers") or {}
|
||
rec = t.get(str(n))
|
||
if isinstance(rec, dict) and rec.get("price") not in (None, ""):
|
||
try:
|
||
return int(round(float(rec["price"])))
|
||
except (TypeError, ValueError):
|
||
pass
|
||
per = (tiers or price_tiers()).get("per") or PRICE_UNIT
|
||
return int(round(float(per) * n))
|
||
|
||
|
||
def payplatform_link_for(n_img):
|
||
"""n 张图该跳哪个爱发电商品;这档没配就回落到总链接。"""
|
||
t = (price_tiers().get("tiers") or {}).get(str(max(1, int(n_img or 1))))
|
||
if isinstance(t, dict) and (t.get("payplatform") or "").strip():
|
||
return t["payplatform"].strip()
|
||
d = jload(PAYINFO_FILE, {}) or {}
|
||
return (d.get("payplatform") or "").strip()
|
||
TERMS_VERSION = "2026-10-04.1"
|
||
|
||
|
||
def _recent(bucket, ip, win):
|
||
now_t = time.time()
|
||
lst = [t for t in bucket.get(ip, []) if now_t - t < win]
|
||
if lst:
|
||
bucket[ip] = lst
|
||
else:
|
||
bucket.pop(ip, None)
|
||
return lst
|
||
|
||
|
||
def ip_of(handler):
|
||
return (handler.headers.get("X-Real-IP") or handler.client_address[0] or "?").strip()
|
||
|
||
|
||
def too_many_fails(ip):
|
||
return len(_recent(IP_FAILS, ip, FAIL_WIN)) >= FAIL_MAX
|
||
|
||
|
||
def note_fail(ip):
|
||
IP_FAILS.setdefault(ip, []).append(time.time())
|
||
|
||
|
||
def submit_allowed(ip):
|
||
return len(_recent(IP_SUBS, ip, SUB_WIN)) < SUB_MAX
|
||
|
||
|
||
def note_submit(ip):
|
||
IP_SUBS.setdefault(ip, []).append(time.time())
|
||
|
||
|
||
IP_FEEDBACK = {} # ip -> [反馈时间戳]
|
||
|
||
|
||
def feedback_allowed(ip):
|
||
"""反馈限流:10 分钟 5 条(正常买家够用;刷不爆盘、刷不爆通知)。"""
|
||
return len(_recent(IP_FEEDBACK, ip, SUB_WIN)) < 5
|
||
|
||
|
||
def note_feedback(ip):
|
||
IP_FEEDBACK.setdefault(ip, []).append(time.time())
|
||
|
||
|
||
def _img_ext(b):
|
||
"""看文件头认图片格式(png/jpg/webp/gif);认不出返回 None。"""
|
||
if not b:
|
||
return None
|
||
if b[:8] == b"\x89PNG\r\n\x1a\n":
|
||
return "png"
|
||
if b[:3] == b"\xff\xd8\xff":
|
||
return "jpg"
|
||
if b[:4] == b"RIFF" and b[8:12] == b"WEBP":
|
||
return "webp"
|
||
if b[:6] in (b"GIF87a", b"GIF89a"):
|
||
return "gif"
|
||
return None
|
||
|
||
|
||
def skin_allowed(ip):
|
||
"""追补皮肤单独限流:10 分钟 20 次(一个买家补十张皮肤也够用)。"""
|
||
return len(_recent(IP_SKINS, ip, SUB_WIN)) < 20
|
||
|
||
|
||
def note_skin(ip):
|
||
IP_SKINS.setdefault(ip, []).append(time.time())
|
||
|
||
|
||
def order_rank(m):
|
||
"""派单顺序(金钻 2026-09-30:「高峰阶段 4096 版本可能要延后排队」)。
|
||
|
||
返回 (优先级, 到达时间),小的先派。
|
||
* 普通单 → (0, created):按到达顺序,先来先渲
|
||
* 重单(4096) → (1, created):先让路给后面的小单
|
||
* 但重单等够 HEAVY_WAIT_MIN 之后恢复 (0, created) —— 它是队列里最早的,
|
||
所以立刻会被派走。**任何情况下都不会被饿死**,这条必须有。
|
||
"""
|
||
try:
|
||
created = datetime.fromisoformat(m.get("created"))
|
||
except (TypeError, ValueError):
|
||
created = now() - timedelta(days=365) # 时间坏了就当最老的,别把它卡死
|
||
try:
|
||
heavy = int(m.get("res") or DEFAULT_RES) >= HEAVY_RES
|
||
except (TypeError, ValueError):
|
||
heavy = False
|
||
if heavy and (now() - created) < timedelta(minutes=HEAVY_WAIT_MIN):
|
||
return (1, created)
|
||
return (0, created)
|
||
|
||
|
||
def disk_ok():
|
||
try:
|
||
return shutil.disk_usage(ROOT).free > DISK_FLOOR
|
||
except OSError:
|
||
return True
|
||
CODE_RE = re.compile(r"^YS-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$")
|
||
OID_ALPH = "23456789ABCDEFGHJKMNPQRSTUVWXYZ" # 去掉 0O1IL 等易混字符
|
||
|
||
|
||
# ----------------------------------------------------------------- 小工具
|
||
def now():
|
||
return datetime.now(CST)
|
||
|
||
|
||
def add_call(rec):
|
||
"""记一条「呼叫金钻」/ 反馈 / 部分失败。
|
||
|
||
数据库 calls 表是正本(后台和限频都查它);**同时照旧追加一行到 calls.jsonl** ——
|
||
手机通知那边是盯着这个文件的(那段不在这份代码里),不能让它断。
|
||
"""
|
||
# ⚠️ 这条也会在渲染机回传(finish_upload)里调:库写失败只记日志,绝不能让异常把回传打断
|
||
try:
|
||
STORE.call_add(rec)
|
||
except Exception as e: # noqa: BLE001
|
||
log("⚠️ 呼叫记录写库失败(只写了 calls.jsonl):%r" % (e,))
|
||
try:
|
||
with open(CALLS_FILE, "a", encoding="utf-8") as f:
|
||
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
|
||
except OSError:
|
||
pass
|
||
|
||
|
||
def log(*a):
|
||
line = "[%s] %s" % (now().strftime("%Y-%m-%d %H:%M:%S"), " ".join(str(x) for x in a))
|
||
try:
|
||
with open(LOG_FILE, "a", encoding="utf-8") as f:
|
||
f.write(line + "\n")
|
||
except OSError:
|
||
pass
|
||
print(line, flush=True)
|
||
|
||
|
||
def jload(path, default):
|
||
try:
|
||
with open(path, encoding="utf-8") as f:
|
||
return json.load(f)
|
||
except (OSError, ValueError):
|
||
return default
|
||
|
||
|
||
_UMASK = os.umask(0)
|
||
os.umask(_UMASK)
|
||
|
||
|
||
def jsave(path, obj):
|
||
"""原子写 JSON。
|
||
|
||
⚠️ 2026-10-05(外部复查)两处加固,读写格式不变:
|
||
* 临时文件名**每次唯一**(原来固定是 path+".tmp":两个线程/进程同时写同一个文件时
|
||
会写进同一个 tmp,互相截断,replace 出一个半截文件);
|
||
* 写完 **fsync** 再 replace:只 replace 不 fsync,断电后可能留下一个 0 字节的 codes.json。
|
||
* 新文件的权限沿用原文件(没有原文件就按进程 umask),不会因为换了写法悄悄变成 600。
|
||
"""
|
||
d = os.path.dirname(path) or "."
|
||
try:
|
||
mode = os.stat(path).st_mode & 0o777
|
||
except OSError:
|
||
mode = 0o666 & ~_UMASK
|
||
fd, tmp = tempfile.mkstemp(prefix=os.path.basename(path) + ".", suffix=".tmp", dir=d)
|
||
try:
|
||
with os.fdopen(fd, "w", encoding="utf-8") as f:
|
||
json.dump(obj, f, ensure_ascii=False, indent=1)
|
||
f.flush()
|
||
os.fsync(f.fileno())
|
||
os.chmod(tmp, mode)
|
||
os.replace(tmp, path)
|
||
except BaseException:
|
||
try:
|
||
os.unlink(tmp)
|
||
except OSError:
|
||
pass
|
||
raise
|
||
|
||
|
||
def worker_token():
|
||
try:
|
||
t = open(TOKEN_FILE, encoding="utf-8").read().strip()
|
||
if t:
|
||
return t
|
||
except OSError:
|
||
pass
|
||
t = secrets.token_hex(24)
|
||
with open(TOKEN_FILE, "w", encoding="utf-8") as f:
|
||
f.write(t)
|
||
os.chmod(TOKEN_FILE, 0o600)
|
||
return t
|
||
|
||
|
||
WT = worker_token()
|
||
|
||
|
||
def admin_token():
|
||
"""管理令牌(金钻电脑上那块后台面板用)。和 worker_token 一个路子:
|
||
文件在 <DATA_DIR>/admin_token,600 权限,不在代码里、不进 git。"""
|
||
try:
|
||
t = open(ADMIN_FILE, encoding="utf-8").read().strip()
|
||
if t:
|
||
return t
|
||
except OSError:
|
||
pass
|
||
t = secrets.token_hex(24)
|
||
with open(ADMIN_FILE, "w", encoding="utf-8") as f:
|
||
f.write(t)
|
||
os.chmod(ADMIN_FILE, 0o600)
|
||
return t
|
||
|
||
|
||
AT = admin_token()
|
||
|
||
HOME_IPS = (STORE.kv_get("home_ips", {}) or {}).get("ips") or [] # 重启后还记得上次认出的出口 IP
|
||
|
||
|
||
def note_home_ip(ip):
|
||
"""记下渲染机的出口 IP。管理接口靠它把门 —— 公网别处扫到也是 403。"""
|
||
global HOME_IPS
|
||
if not ip or ip in ("?", "localhost"):
|
||
return
|
||
HOME_IPS = ([ip] + [x for x in HOME_IPS if x != ip])[:6]
|
||
|
||
|
||
def admin_ip_ok(ip):
|
||
"""后门:本机回环永远放行(等于原来的 admin.py 本地 CLI)。"""
|
||
# ⚠️ 2026-10-05(外部复查):去掉了 "?"。ip_of() 取不到来源时返回 "?",
|
||
# 原来这样也算「本机」直接放行 —— 门是靠令牌 + IP 两道,不能让「不知道是谁」过 IP 这道。
|
||
# (另见回执:反代哪条 location 漏配 X-Real-IP,来源就会变成回环、被当成本机。)
|
||
return ip in ("localhost", "::1", "localhost") or ip in HOME_IPS
|
||
|
||
|
||
# ⚠️ 2026-10-05(外部复查):订单号 / 取件码 / 卡密必须用 secrets(操作系统级随机),不能用 random。
|
||
# random 是梅森旋转,看够它吐出来的值(比如反复领福利券、反复下网页单拿到的码和取件码)
|
||
# 就能反推内部状态,**预测之后要生成的卡密和别人的取件码**。字符表、长度、格式都没变。
|
||
def new_oid():
|
||
return "YS" + "".join(secrets.choice(OID_ALPH) for _ in range(6))
|
||
|
||
|
||
def new_owner_token():
|
||
return "".join(secrets.choice(OID_ALPH) for _ in range(14))
|
||
|
||
|
||
# ----------------------------------------------------------------- 兑换码
|
||
def load_codes():
|
||
return STORE.codes_all()
|
||
|
||
|
||
def save_codes(codes):
|
||
"""整份写回卡密(一个事务里只改有变化的行)。调用方照旧要在 `with LOCK:` 里 load → 改 → save。"""
|
||
STORE.codes_save(codes)
|
||
|
||
|
||
def gen_codes(n, batch="", value=6, platform="", tpl="", state="active", is_set=False, direct=False,
|
||
n_fix=0, n_max=0, lock_tpl=False, n_free=False):
|
||
"""批量生成兑换码,返回新码列表
|
||
|
||
n_fix / n_max / lock_tpl = 金钻 2026-09-30 晚要的「张数卡密」:
|
||
* n_fix>0 → 这张码**只能出这么多张**(多一张少一张都不行),模板随便改
|
||
* n_max>0 → 最多这么多张(通常「不限张数」再封个顶)
|
||
* n_free → **不限张数**(买家想出几张出几张,最多到单张上限 MAX_IMAGES)
|
||
* lock_tpl → 码里带的模板**锁死**,买家不能改(只出这套)
|
||
⚠️ n_free 必须显式给:老规矩「一张码 = 一张图」还在,不能靠 n_fix=0 推。
|
||
"""
|
||
with LOCK:
|
||
codes = load_codes()
|
||
made = []
|
||
while len(made) < n:
|
||
c = "YS-" + "-".join(
|
||
"".join(secrets.choice(OID_ALPH) for _ in range(4)) for _ in range(3))
|
||
if c in codes:
|
||
continue
|
||
# platform/tpl = 第三方平台的标记(闲鱼/B站工坊…)+ 预选模板;金钻 2026-09-30
|
||
# state: active=能直接用 / inactive=等付款激活 / used=已核销
|
||
codes[c] = {"used": False, "order": None, "ts": None,
|
||
"batch": batch, "value": value,
|
||
"platform": platform, "tpl": tpl, "state": state,
|
||
# 套装卡密(金钻 2026-09-30):一张码管**一整套**(全部皮肤 × 全部模板),
|
||
# 不是「一码一张图」。code_info 会把它带出去给前端。
|
||
"set": bool(is_set),
|
||
# direct = 金钻自己发的码(不是平台单):**不用等确认收货**,
|
||
# 看完 512 预览就能直接下原图(2026-09-30 金钻定)
|
||
"direct": bool(direct),
|
||
# 张数 / 模板锁定(金钻 2026-09-30 晚)
|
||
"n_fix": int(n_fix or 0), "n_max": int(n_max or 0),
|
||
"lock_tpl": bool(lock_tpl), "n_free": bool(n_free)}
|
||
made.append(c)
|
||
save_codes(codes)
|
||
return made
|
||
|
||
|
||
def code_state(rec):
|
||
"""码的状态。兼容老记录(只有 used 布尔)。
|
||
|
||
金钻 2026-09-30 晚把生命周期拆成三段:
|
||
active 可用
|
||
bound **已激活** —— 提交订单那一刻(卡密的张数已被这一单占用,不能再用)
|
||
used **已核销** —— 终态:成品「开放下载」之后满 72 小时(见 settle_due)
|
||
inactive 停用(等付款)
|
||
⚠️ 别把 bound 说成「已核销」:买家刚提交完就看到「已核销」会以为货已经交完了。
|
||
"""
|
||
st = rec.get("state")
|
||
if st in ("active", "inactive", "used", "bound"):
|
||
return st
|
||
return "used" if rec.get("used") else "active"
|
||
|
||
|
||
def code_info(raw):
|
||
"""查一个码 —— 给前端做「预填模板」。返回 dict 或 None。
|
||
|
||
⚠️ 会回传 oid/token(已核销的码 = 买家的取件凭证)。码本身是 31^12 的随机串,
|
||
暴力猜不中,所以可以这么用;但**不返回别的订单信息**。
|
||
"""
|
||
c = (raw or "").strip().upper()
|
||
if not CODE_RE.match(c):
|
||
return None
|
||
rec = STORE.code_get(c)
|
||
if not rec:
|
||
return None
|
||
st = code_state(rec)
|
||
# tpl 可能是多个(套装:逗号分隔),统一回成列表给前端预选
|
||
raw_tpl = (rec.get("tpl") or "")
|
||
tpls = [x.strip() for x in raw_tpl.split(",") if x.strip()]
|
||
out = {"ok": True, "code": c, "state": st, "set": bool(rec.get("set")),
|
||
"tpls": tpls, "direct": bool(rec.get("direct")),
|
||
"platform": rec.get("platform") or "", "tpl": rec.get("tpl") or "",
|
||
"batch": rec.get("batch") or "", "used": st == "used",
|
||
# 张数 / 模板锁定(金钻 2026-09-30 晚:「生成一个只能标记渲染多少个的卡密,
|
||
# 他可以自由修改,但是不能超过也不能少于这个数量」)
|
||
"n_fix": int(rec.get("n_fix") or 0), # >0 = 必须正好这么多张;0 = 不限
|
||
"n_max": int(rec.get("n_max") or 0), # >0 = 最多这么多张(不限张数的码也可封顶)
|
||
"lock_tpl": bool(rec.get("lock_tpl")), # True = 模板锁定,买家不能改
|
||
"n_free": bool(rec.get("n_free"))} # True = 不限张数(买家想出几张出几张)
|
||
# 已激活 / 已核销都回 oid+token —— 卡密本身就是取件凭证,点一下就带去订单页
|
||
if st in ("used", "bound") and rec.get("order"):
|
||
m = read_meta(rec["order"])
|
||
if m:
|
||
out["oid"] = rec["order"]
|
||
out["token"] = m.get("token") or ""
|
||
out["bound_at"] = rec.get("bound_at")
|
||
out["settled_at"] = rec.get("ts")
|
||
return out
|
||
|
||
|
||
def note_tpl_time(tpl, sec):
|
||
"""记一张图的渲染耗时(按模板存最近 50 条)。渲染机在 /finish 里带上来的。"""
|
||
try:
|
||
sec = float(sec)
|
||
except (TypeError, ValueError):
|
||
return
|
||
if not tpl or sec <= 0 or sec > 3600:
|
||
return
|
||
with LOCK:
|
||
d = STORE.kv_get("tpl_times", {})
|
||
if not isinstance(d, dict):
|
||
d = {}
|
||
arr = list(d.get(tpl) or [])
|
||
arr.append(round(sec, 1))
|
||
d[tpl] = arr[-50:]
|
||
STORE.kv_put("tpl_times", d)
|
||
|
||
|
||
def tpl_eta_sec(templates, n_img=1):
|
||
"""这单大概要渲多久:按模板历史耗时求和;没样本的模板按每张 60 秒兜底,再加 20 秒收尾。"""
|
||
d = STORE.kv_get("tpl_times", {})
|
||
if not isinstance(d, dict):
|
||
d = {}
|
||
per = []
|
||
for t in (templates or []):
|
||
a = sorted(x for x in (d.get(t) or []) if isinstance(x, (int, float)))
|
||
per.append(float(a[len(a) // 2]) if a else 60.0) # 中位数
|
||
if not per:
|
||
per = [60.0] * max(1, int(n_img or 1))
|
||
# 金钻 2026-10-04:「预计时间可以稍微夸大」—— 宁可信里说久一点。
|
||
# 买家提前看到图是惊喜,等超了才是投诉。
|
||
return int(sum(per) * 1.25) + 45
|
||
|
||
|
||
def codes_rules(codes_list):
|
||
"""汇总一单里几张卡密对「张数 / 模板」的限制(金钻 2026-09-30 晚)。
|
||
|
||
张数口径 = **出图张数 = 皮肤数 × 模板数**(和金额、img_total 同一套算)。
|
||
* n_fix:带固定张数的卡密,张数**必须正好等于它们的和**(不能多也不能少)
|
||
* n_max:带封顶的卡密,张数不能超过它们的和
|
||
* lock_tpl:任一卡密锁了模板 → 提交的模板必须**正好是那一组**(不能增删)
|
||
"""
|
||
cs = load_codes() or {}
|
||
n_fix = n_max = 0
|
||
any_fix = any_max = any_free = False
|
||
locks = []
|
||
for c in codes_list or []:
|
||
r = cs.get((c or "").strip().upper()) or {}
|
||
if r.get("n_free"):
|
||
any_free = True
|
||
try:
|
||
f = int(r.get("n_fix") or 0)
|
||
x = int(r.get("n_max") or 0)
|
||
except (TypeError, ValueError):
|
||
f = x = 0
|
||
if f > 0:
|
||
any_fix = True
|
||
n_fix += f
|
||
if x > 0:
|
||
any_max = True
|
||
n_max += x
|
||
if r.get("lock_tpl") and (r.get("tpl") or "").strip():
|
||
locks.append([y for y in str(r["tpl"]).split(",") if y])
|
||
return {"n_fix": (n_fix if any_fix else None),
|
||
"n_max": (n_max if any_max else None),
|
||
"n_free": any_free,
|
||
"lock_tpl": (locks[0] if locks else None)}
|
||
|
||
|
||
def check_rules(rl, n_img, templates):
|
||
"""按规则校验张数与模板。返回错误文案或 None。"""
|
||
if rl.get("lock_tpl"):
|
||
want = set(rl["lock_tpl"])
|
||
got = set(templates or [])
|
||
if rl.get("n_fix"):
|
||
# 带固定张数时可以只用锁定组里的**一部分**:金钻 2026-10-01 ——
|
||
# 两张皮肤都出「麦田萤火」= 2 张,也是合理用法(只要模板都在锁定组里)
|
||
if not got or not got.issubset(want):
|
||
return ("这张卡密锁定了模板,只能从 %s 里挑(现在选了 %s)"
|
||
% ("、".join(rl["lock_tpl"]), "、".join(templates or []) or "空"))
|
||
elif got != want:
|
||
return ("这张卡密锁定了模板,不能改:只能出 %s(现在选的是 %s)"
|
||
% ("、".join(rl["lock_tpl"]), "、".join(templates or []) or "空"))
|
||
if rl.get("n_fix") and int(n_img) != int(rl["n_fix"]):
|
||
return ("这张卡密固定出 %d 张,现在算下来是 %d 张 —— 出图张数 = 皮肤数 × 模板数,"
|
||
"要正好等于 %d 张" % (rl["n_fix"], n_img, rl["n_fix"]))
|
||
if rl.get("n_max") and int(n_img) > int(rl["n_max"]):
|
||
return "这张卡密最多出 %d 张,现在算下来是 %d 张" % (rl["n_max"], n_img)
|
||
return None
|
||
|
||
|
||
def activate_order_paid(oid, code=None, source=""):
|
||
"""**付款确认后激活这一单**(金钻 2026-10-01 定的状态机)。
|
||
|
||
网页提交 → 发一张兑换码,状态 = `inactive`(**未激活**)
|
||
付款确认 → 激活:订单进队列 + 那张码转 `bound`(**已激活**)
|
||
开放下载满 72h → 转 `used`(**已核销**)
|
||
|
||
⚠️ 只有"钱到了"才能调这里 —— 别让买家点一下就把未激活的码变成能渲的单。
|
||
返回 (ok, msg)。
|
||
"""
|
||
m = read_meta(oid)
|
||
if not m:
|
||
return False, "没有这个订单"
|
||
if m.get("state") not in ("unpaid", "paid"):
|
||
return False, "订单现在是「%s」,不用再激活" % m.get("state")
|
||
if code and code not in (m.get("codes") or []):
|
||
m["codes"] = (m.get("codes") or []) + [code]
|
||
m["state"] = "waiting"
|
||
m["paid_at"] = now().isoformat(timespec="seconds")
|
||
m["activated_by"] = source or "付款确认"
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
burn_codes(m.get("codes") or [], oid) # 未激活 → 已激活
|
||
log("订单 %s 付款确认 → 激活进队列(%s)" % (oid, m["activated_by"]))
|
||
return True, "ok"
|
||
|
||
|
||
def redeem(codes_in):
|
||
"""校验一批码;全部可用才通过。返回 (ok, err, codes_out)
|
||
|
||
⚠️ 只是「查」,不占码 —— 真正占码用 redeem_bind()(查 + 绑在同一把锁里)。
|
||
"""
|
||
with LOCK:
|
||
return _redeem_check(load_codes(), codes_in)
|
||
|
||
|
||
def _redeem_check(codes, codes_in):
|
||
"""redeem / redeem_bind 共用的判断(不加锁,调用方负责)。"""
|
||
seen, good = set(), []
|
||
for raw in codes_in:
|
||
c = (raw or "").strip().upper()
|
||
if not CODE_RE.match(c):
|
||
return False, "卡密格式不对:%s" % c, None
|
||
if c in seen:
|
||
return False, "同一张卡密重复提交:%s" % c, None
|
||
seen.add(c)
|
||
rec = codes.get(c)
|
||
if rec is None:
|
||
return False, "卡密不存在:%s" % c, None
|
||
st = code_state(rec)
|
||
if st == "used":
|
||
return False, "这张卡密已经核销了(用过了):%s" % c, None
|
||
if st == "bound":
|
||
return False, ("这张卡密已经用来下过单了:%s —— 去「凭票取图」填卡密就能回到那一单"
|
||
% c), None
|
||
if st == "inactive":
|
||
return False, "这张卡密还没激活(网页下单的要等付款后激活):%s" % c, None
|
||
_exp = rec.get("claim_expire") or ""
|
||
if _exp and st == "active":
|
||
try:
|
||
overdue = datetime.fromisoformat(_exp) < now()
|
||
except (TypeError, ValueError):
|
||
overdue = False
|
||
if overdue:
|
||
return False, ("这张福利券过期了(领了没用掉)—— 找金钻要一张新的吧:%s" % c), None
|
||
good.append(c)
|
||
return True, None, good
|
||
|
||
|
||
def redeem_bind(codes_in, oid):
|
||
"""**校验 + 绑定**在同一把锁里做完(2026-10-05 外部复查加)。返回 (ok, err, codes_out)。
|
||
|
||
⚠️ 原来是 redeem()(锁里查)→ 落皮肤、做 PNG 核验、写订单 → burn_codes()(锁里绑),
|
||
中间有好几秒的空档:同一张码**同时提交两次**(连点、脚本、两个标签页),两次都查到「可用」,
|
||
就开出两单 —— 一码两用。现在绑定前在锁里**再查一遍**,查到不是 active 就整单不收。
|
||
校验规则和 redeem() 完全一样(直接复用它的判断,免得两份漂移)。
|
||
"""
|
||
with LOCK:
|
||
codes = load_codes()
|
||
ok, err, good = _redeem_check(codes, codes_in)
|
||
if not ok:
|
||
return False, err, None
|
||
ts = now().isoformat(timespec="seconds")
|
||
for c in good:
|
||
codes[c]["state"] = "bound"
|
||
codes[c]["used"] = False
|
||
codes[c]["order"] = oid
|
||
codes[c]["bound_at"] = ts
|
||
save_codes(codes)
|
||
return True, None, good
|
||
|
||
|
||
def unbind_codes(codes_list, oid):
|
||
"""redeem_bind 之后订单没建成(写盘失败等)→ 把码放回 active,别让码白白占住。"""
|
||
with LOCK:
|
||
codes = load_codes()
|
||
hit = False
|
||
for c in codes_list or []:
|
||
r = codes.get(c)
|
||
if r and r.get("order") == oid and code_state(r) == "bound":
|
||
r["state"] = "active"
|
||
r["used"] = False
|
||
r["order"] = None
|
||
r.pop("bound_at", None)
|
||
hit = True
|
||
if hit:
|
||
save_codes(codes)
|
||
|
||
|
||
def burn_codes(codes_list, oid):
|
||
"""把卡密绑到订单上 —— ⚠️ 这只算**激活**,不是核销(金钻 2026-09-30 晚:
|
||
「点击最后的提交才算激活;核销要等开放下载后 72 小时」)。
|
||
|
||
激活后这张码不能再用于别的单,但状态还是 bound;等成品开放下载满 72 小时
|
||
(或订单文件到期被清)才由 settle_codes() 转成 used(真·核销)。
|
||
"""
|
||
with LOCK:
|
||
codes = load_codes()
|
||
for c in codes_list:
|
||
if c in codes:
|
||
codes[c]["state"] = "bound"
|
||
codes[c]["used"] = False
|
||
codes[c]["order"] = oid
|
||
codes[c]["bound_at"] = now().isoformat(timespec="seconds")
|
||
save_codes(codes)
|
||
|
||
|
||
def settle_codes(oid, why=""):
|
||
"""把这一单绑定的卡密**核销**(终态)。返回核销了几张。
|
||
|
||
触发点(见 expire_at / settle_due / admin.py sweep):
|
||
* 成品「开放下载」之后满 72 小时
|
||
* 订单文件到期被清(一直没确认收货的情况)
|
||
"""
|
||
n = 0
|
||
with LOCK:
|
||
codes = load_codes()
|
||
for c, r in codes.items():
|
||
if r.get("order") == oid and code_state(r) == "bound":
|
||
r["state"] = "used"
|
||
r["used"] = True
|
||
r["ts"] = now().isoformat(timespec="seconds")
|
||
if why:
|
||
r["settled"] = why
|
||
n += 1
|
||
if n:
|
||
save_codes(codes)
|
||
return n
|
||
|
||
|
||
def open_at(m):
|
||
"""这单「开放下载」的时刻 —— 核销/保留期都从这儿起算(金钻 2026-09-30 晚)。
|
||
|
||
确认收货单 = accepted_at(买家点了「确认收货」);直发单 = 渲完就能下,取 finished。
|
||
还没开放下载 → None。
|
||
"""
|
||
if m.get("accepted_at"):
|
||
return m["accepted_at"]
|
||
if m.get("direct"):
|
||
return m.get("finished") or m.get("created")
|
||
return None
|
||
|
||
|
||
def expire_at(m):
|
||
"""成品在服务器的到期时刻 = **开放下载之后 72 小时**;还没开放下载的先用创建时间兜底。
|
||
|
||
⚠️ 老口径是「创建后 72 小时」:买家第 70 小时才点确认收货的话,文件两小时后就被清了,
|
||
跟金钻说的「开放下载后 72 小时」对不上 —— 所以改成按开放下载顺延。
|
||
"""
|
||
base = open_at(m) or m.get("created")
|
||
try:
|
||
return datetime.fromisoformat(base) + timedelta(hours=KEEP_HOURS)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def settle_due(talk=False):
|
||
"""扫一遍:已经「开放下载满 72 小时」的订单,把它的卡密核销掉。返回 [(oid, 张数)]。
|
||
|
||
只核销**文件还在**的单 —— 文件被清时由 sweep 顺手核销(命令在 admin.py)。
|
||
"""
|
||
out = []
|
||
for m in list_orders(("done",)):
|
||
exp = expire_at(m)
|
||
if exp and exp <= now():
|
||
n = settle_codes(m["oid"], "开放下载满 %d 小时" % KEEP_HOURS)
|
||
if n:
|
||
out.append((m["oid"], n))
|
||
if talk:
|
||
log("核销卡密 %s:%d 张(%s)" % (m["oid"], n, "开放下载满 72h"))
|
||
return out
|
||
|
||
|
||
# ----------------------------------------------------------------- 订单
|
||
def order_dir(oid):
|
||
return os.path.join(ORDERS, oid)
|
||
|
||
|
||
def read_meta(oid):
|
||
"""订单信息(数据库 orders 表)。没有这单 / 已清理 → None。"""
|
||
if not oid or not isinstance(oid, str):
|
||
return None
|
||
return STORE.order_get(oid)
|
||
|
||
|
||
def write_meta(oid, meta):
|
||
STORE.order_put(oid, meta)
|
||
|
||
|
||
def list_orders(states=None):
|
||
"""按单号排序的订单列表;states 给了就只要这几种状态(走索引,不再一单一单读文件)。"""
|
||
return STORE.orders(states)
|
||
|
||
|
||
def drop_order(oid):
|
||
"""单没建成(提交中途失败):删目录 + 删行。"""
|
||
shutil.rmtree(order_dir(oid), ignore_errors=True)
|
||
STORE.order_drop(oid)
|
||
|
||
|
||
def purge_order(oid):
|
||
"""到期清理:删文件,行留着记账(之后 read_meta 当它不存在)。"""
|
||
shutil.rmtree(order_dir(oid), ignore_errors=True)
|
||
STORE.order_purge(oid)
|
||
|
||
|
||
import pngcheck # PNG 结构核验(防夹带)—— 同目录,零依赖
|
||
|
||
# 内容后台(2026-10-05):网站展示内容在网页后台里改。账号 / 会话 / 草稿 / 发布全在 cms.py,
|
||
# 这里只把 /api/cms/* 交给它。和卡密 / 订单完全分开(它只读写 cms_* 表、内容文件、prices.json / payinfo.json)。
|
||
import cms # noqa: E402
|
||
CMS = cms.CMS(STORE, ROOT, log=log, prices_file=PRICES_FILE, payinfo_file=PAYINFO_FILE, tpl_keys=TPL_KEYS, pngcheck=pngcheck)
|
||
|
||
|
||
def png_size(data):
|
||
"""从 PNG 头读宽高,零依赖"""
|
||
if len(data) < 24 or data[:8] != b"\x89PNG\r\n\x1a\n":
|
||
return None
|
||
w, h = struct.unpack(">II", data[16:24])
|
||
return w, h
|
||
|
||
|
||
def skins_of(m):
|
||
"""取订单的皮肤列表。**兼容老订单**:以前只有一张 skin.png + 订单级 arm。
|
||
|
||
多皮肤(金钻 2026-09-30):一张单可以有多张皮肤,每张**各自一个臂型**
|
||
(A 可能是 Steve 粗臂、B 可能是 Alex 细臂),出图 = 皮肤 × 模板 的组合。
|
||
"""
|
||
sk = m.get("skins")
|
||
if sk:
|
||
return sk
|
||
# 老订单:没有 skins 字段,用旧的单皮肤字段凑一个
|
||
return [{
|
||
"id": "s1",
|
||
"fileName": m.get("fileName") or "skin.png",
|
||
"arm": m.get("arm") or "classic",
|
||
"arm_auto": m.get("arm_auto"),
|
||
"arm_certain": bool(m.get("arm_certain")),
|
||
"skin_size": m.get("skin_size") or [],
|
||
"path": "skin.png",
|
||
"added": m.get("created"),
|
||
}]
|
||
|
||
|
||
def skin_tpls(m, sk=None):
|
||
"""某张皮肤要出的模板。**金钻 2026-10-01 纠正的口径**:
|
||
「我可能这个皮肤用了这个模板,另一个皮肤用那个模板…怎么做乘法」
|
||
→ 每张皮肤各自带一份模板清单(skins[i].tpls)。
|
||
老单/没写 tpls 的,退回订单级 templates(单皮肤时结果一样)。"""
|
||
t = (sk or {}).get("tpls")
|
||
if t:
|
||
return list(t)
|
||
return list(m.get("templates") or [])
|
||
|
||
|
||
def sync_voucher_nfix(m):
|
||
"""把「网页下单」那张取件凭证码的张数,同步成订单当前的实际张数(金钻 2026-10-01)。"""
|
||
cds = [c for c in (m.get("codes") or [])]
|
||
if not cds:
|
||
return
|
||
with LOCK:
|
||
cs = load_codes()
|
||
hit = False
|
||
for c in cds:
|
||
rec = cs.get(c)
|
||
if rec and rec.get("batch") == "网页下单":
|
||
rec["n_fix"] = img_total(m)
|
||
hit = True
|
||
if hit:
|
||
save_codes(cs)
|
||
|
||
|
||
def img_total(m):
|
||
"""这张单一共要出几张图 = **各皮肤自己挑的模板加起来**(不是皮肤数 × 模板数)"""
|
||
n = sum(len(skin_tpls(m, sk)) for sk in skins_of(m))
|
||
return max(1, n)
|
||
|
||
|
||
def tpl_union(m):
|
||
"""订单用到的模板并集(去重、保持顺序)—— 卡密锁定校验、页面展示用"""
|
||
out = []
|
||
for sk in skins_of(m):
|
||
for k in skin_tpls(m, sk):
|
||
if k not in out:
|
||
out.append(k)
|
||
return out or list(m.get("templates") or [])
|
||
|
||
|
||
def queue_pos(oid):
|
||
"""排队位置(前面还有几单)"""
|
||
waiting = [m["oid"] for m in list_orders(("waiting", "working"))]
|
||
try:
|
||
return waiting.index(oid) + 1
|
||
except ValueError:
|
||
return 0
|
||
|
||
|
||
# ⚠️ 金钻 2026-09-30:状态查询要冷却,别被刷爆。
|
||
# 页面正常 10 分钟查一次;有人来了(打开页面 / 点刷新)可以马上查一次,
|
||
# 但服务器**每分钟最多真算一次** —— 再多的请求也就是读个缓存,几乎零成本。
|
||
# ===== 预览闸门(金钻 2026-09-30)=====
|
||
# 渲染完先给 **512 水印预览**;买家点「确认收货」才放原图。
|
||
# 预览由**服务器**生成(不是渲染机)—— 渲染机那边不用多装任何东西。
|
||
PREVIEW_MAX = 512
|
||
WM_FONT = "/usr/share/fonts/opentype/noto/NotoSerifCJK-Bold.ttc"
|
||
WM_TEXT = "预览图" # 金钻:简单加个水印,表示是预览展示图
|
||
|
||
STATUS_TTL = 60 # 冷却:同一结果 60 秒内复用
|
||
_status_cache = {"t": 0.0, "v": None}
|
||
|
||
|
||
def status_cache_clear():
|
||
"""渲染机刚上报心跳 → 让状态立刻变准,别让买家看到过期的"离线"。"""
|
||
_status_cache["v"] = None
|
||
|
||
|
||
def make_preview(oid, png_path, out_name, idx=0):
|
||
"""把交付图缩成 512 的水印预览(JPEG),返回相对路径;失败返回 None。
|
||
|
||
⚠️ 用 ffmpeg 单线程处理**单张图**是安全的 —— 服务器禁的是视频转码(会爆内存)。
|
||
这里 512×512、-threads 1,实测 2 秒、内存无变化。
|
||
"""
|
||
if not os.path.exists(WM_FONT):
|
||
log("⚠️ 找不到水印字体,跳过预览生成")
|
||
return None
|
||
# ⚠️ 中文名会被替换成下划线 → 「麦田萤火.png」和「海边自拍.png」都变 prev_____.jpg 撞名!
|
||
# 所以**必须带上序号**(2026-09-30 实踩:同单两个模板的预览会互相覆盖)
|
||
dst_rel = "out/prev_%02d.jpg" % int(idx)
|
||
dst = os.path.join(order_dir(oid), dst_rel)
|
||
parts = ["scale=%d:%d" % (PREVIEW_MAX, PREVIEW_MAX)]
|
||
for gy in (26, 188, 350): # 3×3 平铺,肉眼一眼看出是预览
|
||
for gx in (12, 174, 336):
|
||
parts.append("drawtext=fontfile=%s:text='%s':fontsize=30:fontcolor=white@0.30:x=%d:y=%d"
|
||
% (WM_FONT, WM_TEXT, gx, gy))
|
||
parts.append("drawtext=fontfile=%s:text='shop.example.com':fontsize=15:fontcolor=white@0.45:"
|
||
"x=w-text_w-10:y=h-text_h-8" % WM_FONT)
|
||
try:
|
||
r = subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-threads", "1",
|
||
"-i", png_path, "-vf", ",".join(parts), "-q:v", "4", dst],
|
||
capture_output=True, timeout=120)
|
||
if r.returncode != 0 or not os.path.exists(dst):
|
||
log("⚠️ 预览生成失败:%s" % (r.stderr or b"")[-200:].decode("utf-8", "replace"))
|
||
return None
|
||
except Exception as e:
|
||
log("⚠️ 预览生成异常 %r" % e)
|
||
return None
|
||
return dst_rel
|
||
|
||
|
||
def heartbeat(force=False):
|
||
"""渲染机在线状态。结果缓存 STATUS_TTL 秒。
|
||
|
||
这个结果对所有人**完全一样**(全局状态),所以缓存不会串味。
|
||
"""
|
||
c = _status_cache
|
||
if (not force) and c["v"] is not None and (time.monotonic() - c["t"]) < STATUS_TTL:
|
||
return c["v"]
|
||
hb = STORE.kv_get("heartbeat", {}) or {}
|
||
last = hb.get("ts")
|
||
online = False
|
||
if last:
|
||
try:
|
||
online = (now() - datetime.fromisoformat(last)).total_seconds() < OFFLINE_AFTER
|
||
except ValueError:
|
||
online = False
|
||
v = {"online": online, "last_seen": last, "host": hb.get("host"),
|
||
"queue": len(list_orders(("waiting",))),
|
||
"working": len(list_orders(("working",)))}
|
||
c["t"], c["v"] = time.monotonic(), v
|
||
return v
|
||
|
||
|
||
def edit_code(c, patch):
|
||
"""改一张还没用掉的卡密。返回 (ok, 错误文案, info)。
|
||
|
||
⚠️ 逻辑只写这一份:HTTP 的管理接口(面板)和本机 admin.py CLI 都调它 ——
|
||
两边各写一遍迟早漂移(这是本项目的头号 bug 来源)。
|
||
"""
|
||
c = (c or "").strip().upper()
|
||
# ⚠️ 2026-10-05(外部复查):读 → 改 → 写 必须在**同一把锁**里。原来锁外读、锁里写:
|
||
# 读完到写之间要是有买家把另一张码绑上了,这里存回去的旧快照会把那张码改回 active(一码两用)。
|
||
with LOCK:
|
||
rec, err = _edit_code_locked(c, patch)
|
||
if not rec:
|
||
return False, err, None
|
||
log("改卡密 %s → %s" % (c, json.dumps({k: rec.get(k) for k in
|
||
("tpl", "set", "direct", "lock_tpl", "n_fix", "n_max", "state", "platform")},
|
||
ensure_ascii=False)))
|
||
return True, None, code_info(c)
|
||
|
||
|
||
def _edit_code_locked(c, patch):
|
||
"""edit_code 的主体(调用方持锁)。返回 (改后的记录 或 False, 错误文案)。"""
|
||
cs = load_codes()
|
||
if c not in cs:
|
||
return False, "没有这张卡密:%s" % c
|
||
if code_state(cs[c]) == "used":
|
||
return False, ("这张卡密已经用掉了(订单 %s),改不了 —— 要改请用 admin.py 直接动订单"
|
||
% (cs[c].get("order") or ""))
|
||
r = cs[c]
|
||
p = patch or {}
|
||
if "tpls" in p:
|
||
bad = [t for t in (p.get("tpls") or []) if t not in TPL_KEYS]
|
||
if bad:
|
||
return False, "模板不认识:%s" % "、".join(bad)
|
||
r["tpl"] = ",".join(p["tpls"])
|
||
for k in ("set", "direct", "lock_tpl"):
|
||
if k in p:
|
||
r[k] = bool(p[k])
|
||
if ("n_fix" in p) or ("n_max" in p) or p.get("unlimited"):
|
||
# ⚠️ 只改其中一个时,另一个要**沿用原值** —— 否则「只改封顶」会把固定张数抹成 0
|
||
# (自测实测:n_fix=3 的码 + patch{n_max:2} 被静默改成不限张数)
|
||
cur_fix, cur_max = int(r.get("n_fix") or 0), int(r.get("n_max") or 0)
|
||
try:
|
||
if p.get("unlimited"):
|
||
n_fix, n_max = 0, 0
|
||
else:
|
||
n_fix = int(p["n_fix"]) if "n_fix" in p else (0 if p.get("free") else cur_fix)
|
||
n_max = int(p["n_max"]) if "n_max" in p else cur_max
|
||
except (TypeError, ValueError):
|
||
return False, "张数不合法"
|
||
if n_fix > MAX_IMAGES or n_max > 100:
|
||
return False, "张数不合法(固定张数最多 %d 张)" % MAX_IMAGES
|
||
if n_fix and n_max and n_max < n_fix:
|
||
return False, "封顶不能小于固定张数"
|
||
r["n_fix"], r["n_max"] = n_fix, n_max
|
||
if p.get("unlimited"):
|
||
r["n_free"] = True # 不限张数(老规矩「一张码一张图」也一并解除)
|
||
if "free" in p:
|
||
r["n_free"] = bool(p["free"])
|
||
if p["free"]:
|
||
r["n_fix"] = 0
|
||
if p.get("state") in ("active", "inactive"):
|
||
r["state"] = p["state"]
|
||
for k in ("platform", "batch"):
|
||
if k in p:
|
||
r[k] = str(p[k] or "")[:20]
|
||
if r.get("lock_tpl") and not (r.get("tpl") or "").strip():
|
||
return False, "要锁定模板,得先给这张码带模板"
|
||
save_codes(cs)
|
||
return r, None
|
||
|
||
|
||
# ----------------------------------------------------------------- HTTP
|
||
def receipt_lines(oid, m):
|
||
"""整单**收货凭证(小票)** —— 金钻 2026-10-01 P3。
|
||
|
||
两个用处:① 成品 zip 里随包那份 ② 订单页「看小票 / 复制」(闲鱼对账、留证都用得上)。
|
||
⚠️ 排版是给**手机窄屏**看的:整宽 W=42 个半角位(≈21 个汉字),一行超了就会横向滚动
|
||
(2026-10-01 实测「保存期限」那行被截断)。加字段前先数一下宽度。
|
||
"""
|
||
W = 42
|
||
sk = skins_of(m)
|
||
lines = ["=" * W,
|
||
" 金钻工坊 · 自助模板渲染",
|
||
" 收 货 凭 证",
|
||
"=" * W,
|
||
"订单号 %s" % oid]
|
||
cds = m.get("codes") or []
|
||
if cds:
|
||
lines.append("卡密 %s" % "、".join(cds))
|
||
for i, x in enumerate(sk):
|
||
sz = x.get("skin_size") or []
|
||
bits = [ARMTXT.get(x.get("arm"), x.get("arm") or "")]
|
||
if sz:
|
||
bits.append("×".join(str(v) for v in sz))
|
||
lines.append("%s%s" % ("皮肤 " if i == 0 else " ",
|
||
"%s(%s)" % (x.get("fileName") or "皮肤%s" % (i + 1),
|
||
" ".join(b for b in bits if b))))
|
||
lines.append("出图 %d 张" % img_total(m))
|
||
lines.append(" 每张两版:标准 + 无压缩")
|
||
files = m.get("files") or []
|
||
for i, f in enumerate(files):
|
||
try:
|
||
fsz = os.path.getsize(os.path.join(order_dir(oid), f.get("path") or ""))
|
||
except OSError:
|
||
fsz = 0
|
||
who = ""
|
||
for x in sk:
|
||
if x.get("id") == f.get("skin"):
|
||
who = (x.get("fileName") or "").replace(".png", "")
|
||
break
|
||
lines.append(" %02d. %-18s %6s %s" % (i + 1, (f.get("name") or "")[:18],
|
||
("%.1fMB" % (fsz / 1048576.0)) if fsz else "",
|
||
who[:8]))
|
||
lines.append("分辨率 %d px" % int(m.get("res") or DEFAULT_RES))
|
||
lines.append("提交时间 %s" % (m.get("created") or ""))
|
||
lines.append("完成时间 %s" % (m.get("finished") or ""))
|
||
seq = m.get("seq") or (m.get("seqs") or [None])[0]
|
||
if seq:
|
||
lines.append("留档序号 %03d" % int(seq))
|
||
lines.append("条款版本 %s" % TERMS_VERSION)
|
||
ex = expire_at(m)
|
||
if ex:
|
||
lines.append("保存期限 %s" % ex.astimezone(CST).strftime("%Y-%m-%d %H:%M"))
|
||
lines.append(" 下载后 72 小时自动清理")
|
||
lines.append("反馈 shop.example.com/order/ → 呼叫金钻")
|
||
lines.append("-" * W)
|
||
lines.append("本站只提供渲染服务;皮肤内容与渲染")
|
||
lines.append("结果的合规性由提供者负责、后果自担。")
|
||
lines.append("模板质量问题请联系金钻维护。")
|
||
return lines
|
||
|
||
|
||
def receipt_text(oid, m):
|
||
return "\n".join(receipt_lines(oid, m)) + "\n"
|
||
|
||
|
||
class H(BaseHTTPRequestHandler):
|
||
server_version = "ys-order"
|
||
protocol_version = "HTTP/1.1"
|
||
|
||
def log_message(self, fmt, *args): # 静音(access 由 nginx 记)
|
||
pass
|
||
|
||
# ---- 响应helper ----
|
||
def _send(self, code, body=b"", ctype="application/json; charset=utf-8", extra=None):
|
||
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()
|
||
if body and self.command != "HEAD":
|
||
self.wfile.write(body)
|
||
|
||
def _send_file(self, path, ctype, extra=None):
|
||
"""把文件**边读边发**(不整块进内存)。头和 _send 一样:Content-Length + no-store。"""
|
||
try:
|
||
size = os.path.getsize(path)
|
||
fh = open(path, "rb")
|
||
except OSError:
|
||
return self.err("文件已过期或不存在", 404)
|
||
with fh:
|
||
self.send_response(200)
|
||
self.send_header("Content-Type", ctype)
|
||
self.send_header("Content-Length", str(size))
|
||
self.send_header("Cache-Control", "no-store")
|
||
for k, v in (extra or {}).items():
|
||
self.send_header(k, v)
|
||
self.end_headers()
|
||
if self.command == "HEAD":
|
||
return
|
||
try:
|
||
shutil.copyfileobj(fh, self.wfile, ZIP_CHUNK)
|
||
except (BrokenPipeError, ConnectionResetError):
|
||
self.close_connection = True
|
||
|
||
def js(self, obj, code=200):
|
||
self._send(code, json.dumps(obj, ensure_ascii=False).encode(), "application/json; charset=utf-8")
|
||
|
||
def err(self, msg, code=400):
|
||
self.js({"ok": False, "error": msg}, code)
|
||
|
||
def body_json(self, limit=None):
|
||
n = int(self.headers.get("Content-Length") or 0)
|
||
if n <= 0 or n > (limit or MAX_BODY):
|
||
return None
|
||
try:
|
||
return json.loads(self.rfile.read(n).decode("utf-8"))
|
||
except (ValueError, UnicodeDecodeError):
|
||
return None
|
||
|
||
def is_worker(self):
|
||
return hmac.compare_digest(self.headers.get("X-Worker-Token") or "", WT)
|
||
|
||
# ---- 路由 ----
|
||
def do_GET(self):
|
||
u = urlparse(self.path)
|
||
p, q = u.path, parse_qs(u.query)
|
||
try:
|
||
if p.startswith("/api/cms/"):
|
||
return CMS.handle(self, "GET", p, q)
|
||
if p == "/api/status":
|
||
# ?fresh=1 → 跳过 60 秒缓存,现算(页面上的「刷新」按钮用这个)。
|
||
# ⚠️ 不加的话:渲染机刚上线,用户连刷几次都还是缓存的「离线」(金钻 2026-10-01 反馈)
|
||
return self.js({"ok": True, **heartbeat(force=bool(q.get("fresh")))})
|
||
|
||
# 查码:给前端预填模板用(闲鱼/B站码带平台+模板标记)
|
||
m = re.match(r"^/api/code/([A-Za-z0-9\-]+)$", p)
|
||
if m:
|
||
info = code_info(m.group(1))
|
||
if not info:
|
||
return self.js({"ok": False, "error": "没有这个兑换码"})
|
||
return self.js(info)
|
||
|
||
m = re.match(r"^/api/order/([A-Z0-9]+)$", p)
|
||
if m:
|
||
return self.order_detail(m.group(1), (q.get("t") or [""])[0])
|
||
|
||
# 轻量心跳:只回「状态 + 进度」,别的什么都不算 —— 前端敢几秒问一次
|
||
# (金钻 2026-10-04:「进度条和中间态没有即时刷新」)
|
||
m = re.match(r"^/api/tick/([A-Z0-9]+)$", p)
|
||
if m:
|
||
return self.tick(m.group(1), (q.get("t") or [""])[0])
|
||
|
||
m = re.match(r"^/api/dl/([A-Z0-9]+)/(\d+)$", p)
|
||
if m:
|
||
return self.download(m.group(1), int(m.group(2)), (q.get("t") or [""])[0], q)
|
||
|
||
# 渲染机取皮肤:/api/skin/<oid>(老,=第一张)或 /api/skin/<oid>/<sid>
|
||
m = re.match(r"^/api/skin/([A-Z0-9]+)(?:/([A-Za-z0-9_-]+))?$", p)
|
||
if m:
|
||
if not self.is_worker():
|
||
return self.err("forbidden", 403)
|
||
return self.skin(m.group(1), m.group(2) or "s1")
|
||
|
||
# 打包下载(金钻 2026-09-30):整单原图打一个 zip,买家一次拖走
|
||
m = re.match(r"^/api/zip/([A-Z0-9]+)$", p)
|
||
if m:
|
||
return self.download_zip(m.group(1), (q.get("t") or [""])[0])
|
||
|
||
# 付款方式(爱发电链接 / 收款码):页面「去付款」按钮读它
|
||
if p == "/api/payinfo":
|
||
return self.payinfo()
|
||
# 福利券池(免费领的那种,金钻 2026-10-01「赛博鸡蛋」)
|
||
if p == "/api/gift":
|
||
return self.js({"ok": True, "view": gift_view(),
|
||
"batches": gift_public()}) # batches 保留:老页面/老调用还在用
|
||
|
||
# 收货凭证 / 小票(金钻 2026-10-01 P3):页面「看小票」用纯文本,?dl=1 当附件下载
|
||
m = re.match(r"^/api/receipt/([A-Z0-9]+)$", p)
|
||
if m:
|
||
return self.receipt(m.group(1), (q.get("t") or [""])[0], bool(q.get("dl")))
|
||
|
||
# ---- 管理接口(金钻电脑上的后台面板)----
|
||
if p.startswith("/api/admin/"):
|
||
if not self.admin_gate():
|
||
return self.err("forbidden", 403)
|
||
if p == "/api/admin/ping":
|
||
return self.admin_ping()
|
||
if p == "/api/admin/orders":
|
||
return self.admin_orders(q)
|
||
if p == "/api/admin/codes":
|
||
return self.admin_codes(q)
|
||
if p == "/api/admin/gifts":
|
||
return self.admin_gifts()
|
||
if p == "/api/admin/calls":
|
||
return self.admin_calls(q)
|
||
|
||
return self.err("not found", 404)
|
||
except Exception as e:
|
||
log("GET %s 异常 %r" % (p, e))
|
||
return self.err("server error", 500)
|
||
|
||
def do_POST(self):
|
||
u = urlparse(self.path)
|
||
p = u.path
|
||
try:
|
||
if p.startswith("/api/cms/"):
|
||
return CMS.handle(self, "POST", p, parse_qs(u.query))
|
||
# 领一张福利券(免费、免付费、只限张数)
|
||
if p == "/api/gift/claim":
|
||
return self.gift_take()
|
||
# 我领过/买过的券,现在什么状态(页面负责把这些券存在浏览器里)
|
||
if p == "/api/my-coupons":
|
||
return self.my_coupons()
|
||
# 买家自助免费重渲(每单一次)
|
||
if p == "/api/redo":
|
||
return self.redo()
|
||
# 问题反馈(可带图,金钻 2026-10-02)—— 取代原来的 mailto
|
||
if p == "/api/feedback":
|
||
return self.feedback()
|
||
# 爱发电「自动发货」回调(金钻 2026-10-01)—— 地址填在爱发电开发者页
|
||
if p == "/api/payplatform-hook":
|
||
return self.payplatform_hook()
|
||
# 用平台发来的卡密激活「网页填过的那一单」(金钻 2026-10-01:
|
||
# 网页填完 → 跳爱发电付款 → 回来填码激活,**填过的内容不许白填**)
|
||
if p == "/api/activate":
|
||
return self.activate()
|
||
# 认证没下来、拿不到码时:直接用**爱发电订单号**激活(账本里已记这笔成交)
|
||
if p == "/api/activate-payplatform":
|
||
return self.activate_payplatform()
|
||
if p == "/api/submit":
|
||
return self.submit()
|
||
if p == "/api/accept":
|
||
return self.accept()
|
||
if p == "/api/paid":
|
||
return self.mark_paid()
|
||
if p == "/api/add-skin":
|
||
return self.add_skin()
|
||
if p == "/api/set-templates":
|
||
return self.set_templates()
|
||
if p == "/api/call":
|
||
return self.call()
|
||
if p == "/api/hb":
|
||
return self.hb()
|
||
if p == "/api/claim":
|
||
return self.claim()
|
||
if p == "/api/progress":
|
||
return self.progress()
|
||
if p == "/api/finish":
|
||
return self.finish_upload()
|
||
if p == "/api/fail":
|
||
return self.fail()
|
||
# ---- 管理接口(金钻电脑上的后台面板)----
|
||
if p.startswith("/api/admin/"):
|
||
if not self.admin_gate():
|
||
return self.err("forbidden", 403)
|
||
if p == "/api/admin/gen":
|
||
return self.admin_gen()
|
||
if p == "/api/admin/activate":
|
||
return self.admin_activate()
|
||
if p == "/api/admin/void":
|
||
return self.admin_void()
|
||
if p == "/api/admin/note":
|
||
return self.admin_note()
|
||
if p == "/api/admin/code-edit":
|
||
return self.admin_code_edit()
|
||
if p == "/api/admin/gift/new":
|
||
return self.admin_gift_new()
|
||
if p == "/api/admin/gift/add":
|
||
return self.admin_gift_add()
|
||
if p == "/api/admin/gift/off":
|
||
return self.admin_gift_off()
|
||
if p == "/api/admin/retry":
|
||
return self.admin_retry()
|
||
if p == "/api/admin/call-done":
|
||
return self.admin_call_done()
|
||
return self.err("not found", 404)
|
||
except Exception as e:
|
||
log("POST %s 异常 %r" % (p, e))
|
||
return self.err("server error", 500)
|
||
|
||
# ---- 业务 ----
|
||
def submit(self):
|
||
ip = ip_of(self)
|
||
if too_many_fails(ip):
|
||
log("拒绝 %s:兑换码连续输错,冷却中" % ip)
|
||
return self.err("尝试次数过多,请 15 分钟后再试", 429)
|
||
if not submit_allowed(ip):
|
||
return self.err("提交太频繁,请稍后再试", 429)
|
||
if not disk_ok():
|
||
log("拒绝 %s:磁盘不足" % ip)
|
||
return self.err("服务器空间不足,请联系金钻处理", 503)
|
||
d = self.body_json()
|
||
if not d:
|
||
return self.err("请求体不合法")
|
||
codes = d.get("codes") or []
|
||
templates = d.get("templates") or []
|
||
skin = d.get("skin") or ""
|
||
# 网页下单(待付款):不带兑换码,先登记订单,付款后由金钻激活(金钻 2026-09-30)
|
||
prepay = (d.get("pay") == "prepay")
|
||
arm = d.get("arm")
|
||
try:
|
||
res = int(d.get("res") or DEFAULT_RES)
|
||
except (TypeError, ValueError):
|
||
return self.err("分辨率不合法")
|
||
if res not in ALLOWED_RES:
|
||
return self.err("分辨率不支持(可选 %s)" % "/".join(str(x) for x in ALLOWED_RES))
|
||
if prepay:
|
||
if not templates:
|
||
return self.err("还没选模板")
|
||
elif not codes or not templates:
|
||
return self.err("缺少卡密或模板")
|
||
# 套装卡密:一张码管一整套,不做「码数 = 张数」的校验(金钻 2026-09-30)
|
||
# ⚠️ 这段必须在下面几个校验**之前** —— 之前放后了,_is_set 未定义直接 500
|
||
_cs = load_codes()
|
||
_norm = [(c or "").strip().upper() for c in codes]
|
||
_is_set = any((_cs.get(c) or {}).get("set") for c in _norm)
|
||
# 金钻直发的码:这单不用等收货,预览看完直接能下原图
|
||
_direct = any((_cs.get(c) or {}).get("direct") for c in _norm)
|
||
# 「按张数」的卡密(金钻 2026-09-30 晚):码里带了 固定张数 / 封顶 / 锁定模板,
|
||
# 就不走「一张码一张图」的老规矩,改按「皮肤数 × 模板数」核对(见 check_rules)。
|
||
_quota = any(((_cs.get(c) or {}).get("n_fix") or (_cs.get(c) or {}).get("n_max")
|
||
or (_cs.get(c) or {}).get("lock_tpl") or (_cs.get(c) or {}).get("n_free"))
|
||
for c in _norm)
|
||
_loose = _is_set or _quota
|
||
if not _loose and len(codes) > MAX_IMAGES:
|
||
return self.err("一单最多 %d 张" % MAX_IMAGES)
|
||
if len(templates) > MAX_IMAGES:
|
||
return self.err("一单最多 %d 个模板" % MAX_IMAGES)
|
||
_badt = [str(x) for x in templates if x not in TPL_KEYS]
|
||
if _badt:
|
||
return self.err("模板不认识:%s(刷新一下页面再试)" % "、".join(_badt[:3]))
|
||
if not prepay and not _loose and len(codes) != len(templates):
|
||
return self.err("卡密个数与出图张数不一致")
|
||
if arm not in ("classic", "slim"):
|
||
return self.err("手臂规格不合法")
|
||
# 条款同意(金钻 2026-09-30):必须带版本号 + 勾选同意。
|
||
# 不记入"输错计数"—— 老页面缓存会把正常买家误伤,交给通用限流兜。
|
||
terms = d.get("terms") or {}
|
||
if not terms.get("agreed") or str(terms.get("v")) != TERMS_VERSION:
|
||
return self.err("请先阅读并勾选同意《模板渲染服务条款》再提交(页面刚更新过的话,"
|
||
"刷新一下页面重试)")
|
||
|
||
if prepay:
|
||
good = [] # 网页下单不给码,付款后激活
|
||
else:
|
||
ok, e, good = redeem(codes)
|
||
if not ok:
|
||
note_fail(ip) # 码不对才计数
|
||
log("兑换码失败 %s:%s" % (ip, e))
|
||
return self.err(e)
|
||
# 张数 / 模板锁定(金钻 2026-09-30 晚)。
|
||
# ⚠️ 2026-10-04 修:第 1 次提交只带第 1 张皮肤,直接拿 len(templates) 当整单张数
|
||
# 会把多皮肤的单一律算少(实测:皮肤1 出 2 张 + 皮肤2 出 1 张 → 只算 2 张 →
|
||
# 「固定 3 张」的码被误拒)。前端现在会传 nTotal / tplUnion,优先用它。
|
||
# ⚠️ 2026-10-05(外部复查):nTotal / tplUnion 是**前端报的**,不能单独信 ——
|
||
# 原来报 nTotal=1、实际 templates 塞 7 个,「固定 1 张」的码就能出 7 张图;
|
||
# 报 tplUnion=锁定那组、实际 templates 是别的模板,锁模板就形同虚设。
|
||
# 现在:张数取「前端报的」和「这次真提交的」里**大的那个**,模板取两者的**并集**。
|
||
# 正常页面报的 nTotal 本来就 ≥ 第一张皮肤的模板数,所以对正常买家没有任何变化。
|
||
try:
|
||
_n_decl = int(d.get("nTotal") or 0)
|
||
except (TypeError, ValueError):
|
||
_n_decl = 0
|
||
_n1 = max(_n_decl, len(templates))
|
||
_u1 = list(dict.fromkeys([t for t in (d.get("tplUnion") or []) if t in TPL_KEYS]
|
||
+ [t for t in templates if t in TPL_KEYS])) or templates
|
||
e2 = check_rules(codes_rules(good), _n1, _u1)
|
||
if e2:
|
||
log("卡密规则不通过 %s:%s" % (ip, e2))
|
||
return self.err(e2)
|
||
|
||
raw = skin.split(",", 1)[-1]
|
||
try:
|
||
data = base64.b64decode(raw, validate=False)
|
||
except Exception:
|
||
return self.err("皮肤图解析失败")
|
||
if len(data) > MAX_SKIN:
|
||
return self.err("皮肤文件过大")
|
||
sz = png_size(data)
|
||
if sz is None:
|
||
return self.err("皮肤必须是 PNG 图片")
|
||
w, h = sz
|
||
if w != h:
|
||
# 分清"旧版 2:1 皮肤"和"根本不是皮肤",别把两种错说成一句
|
||
if h * 2 == w or w * 2 == h:
|
||
return self.err("皮肤尺寸 %d×%d 是旧版 2:1 皮肤(没有独立左臂/左腿纹路),模板渲染不了" % (w, h))
|
||
return self.err("皮肤尺寸 %d×%d 不是皮肤比例(应为正方形)" % (w, h))
|
||
if w < MIN_SIDE or w > MAX_SIDE:
|
||
return self.err("皮肤尺寸 %d×%d 超出范围(%d~%d)" % (w, h, MIN_SIDE, MAX_SIDE))
|
||
|
||
# 结构核验 + 清洗(金钻 2026-09-30「避免夹带私货」):
|
||
# 拒掉尾部夹带 / 未知关键块 / APNG;剥掉 tEXt 等元数据。
|
||
# ⚠️ 之后一律用 clean(洗过的字节)落盘和下发,原始 data 不再使用。
|
||
okp, why, clean, notes = pngcheck.scan(data)
|
||
if not okp:
|
||
log("皮肤结构核验不通过 %s:%s" % (ip, why))
|
||
return self.err("皮肤图片未通过安全核验:%s" % why)
|
||
if notes:
|
||
log("皮肤清洗 %s:%s" % (ip, ";".join(notes)))
|
||
data = clean
|
||
if len(data) > MAX_SKIN:
|
||
return self.err("皮肤文件过大")
|
||
|
||
oid = new_oid()
|
||
while os.path.exists(order_dir(oid)) or STORE.order_known(oid):
|
||
oid = new_oid()
|
||
tok = new_owner_token()
|
||
os.makedirs(order_dir(oid), exist_ok=True)
|
||
with open(os.path.join(order_dir(oid), "skin.png"), "wb") as f:
|
||
f.write(data)
|
||
os.chmod(os.path.join(order_dir(oid), "skin.png"), 0o640)
|
||
|
||
meta = {
|
||
"oid": oid, "token": tok, "state": ("unpaid" if prepay else "waiting"),
|
||
"created": now().isoformat(timespec="seconds"),
|
||
"arm": arm, "arm_auto": d.get("armAuto"), "arm_certain": bool(d.get("armCertain")),
|
||
"res": res,
|
||
"templates": list(templates)[:10],
|
||
"codes": good,
|
||
"fileName": (d.get("fileName") or "skin.png")[:80],
|
||
"skins": [{"id": "s1", "fileName": (d.get("fileName") or "skin.png")[:80],
|
||
"arm": arm, "arm_auto": d.get("armAuto"),
|
||
"arm_certain": bool(d.get("armCertain")),
|
||
"skin_size": list(sz), "path": "skin.png",
|
||
# 这张皮肤自己要出的模板(金钻 2026-10-01:逐张配,不是乘法)
|
||
"tpls": list(templates)[:MAX_IMAGES],
|
||
"added": now().isoformat(timespec="seconds")}],
|
||
"skin_size": list(sz),
|
||
"skin_mult64": (w % 64 == 0),
|
||
"risk_ack": bool(d.get("riskAck")),
|
||
# 留证:条款版本 + 同意时间 + 来源 IP(争议与配合调查用)
|
||
"terms_v": TERMS_VERSION,
|
||
"terms_at": now().isoformat(timespec="seconds"),
|
||
"ip": ip,
|
||
"skin_cleaned": bool(notes),
|
||
# 金额按「价格档位表」算(金钻 2026-10-01:按张数分档+优惠)
|
||
"amount": price_for(max(1, len(templates or good or [1]))),
|
||
# 张数 / 模板锁定的规则快照(金钻 2026-09-30 晚)—— 后续追补皮肤要照它核
|
||
"rules": ({} if prepay else codes_rules(good)),
|
||
"direct": bool(_direct), # True = 金钻直发码,不用等确认收货
|
||
"note": "", "files": [], "started": None, "finished": None,
|
||
"expire": (now() + timedelta(hours=KEEP_HOURS)).isoformat(timespec="seconds"),
|
||
}
|
||
if not prepay:
|
||
# ⚠️ 2026-10-05(外部复查):这里**再查一遍并当场绑定**(同一把锁里)——
|
||
# 上面 redeem() 只是查,从查到这里中间隔着解码 / PNG 核验 / 落盘好几秒,
|
||
# 同一张码并发提交两次的话两边都会查到「可用」。绑不上 = 被别的提交抢先了。
|
||
okb, eb, good = redeem_bind(good, oid)
|
||
if not okb:
|
||
drop_order(oid)
|
||
log("兑换码并发冲突 %s:%s" % (ip, eb))
|
||
return self.err(eb)
|
||
meta["codes"] = good
|
||
try:
|
||
with LOCK:
|
||
write_meta(oid, meta)
|
||
except Exception:
|
||
if not prepay:
|
||
unbind_codes(good, oid) # 单没建成,码放回去
|
||
drop_order(oid)
|
||
raise
|
||
note_submit(ip)
|
||
if prepay:
|
||
# 给网页单也发一个码:既是凭证,买家也能拿它在「凭票取图」页取件
|
||
# 网页单这张码是**取件/凭证**用的,不是"付了钱的码" ——
|
||
# 真正付钱的码是买家去爱发电付完、平台发给他的那张(激活时绑到这一单上)。
|
||
# ⚠️ 所以这里**不要**带张数:带了的话 codes_rules 会把两张码的张数加在一起
|
||
# (网页凭证 2 张 + 爱发电 2 张 = 规则变成 4 张,2026-10-01 实测踩到)。
|
||
# 模板只**预填不锁**(他还能改),符合"不限种类、只限张数"的口径。
|
||
# 金钻 2026-10-01 的状态机:「用户通过网页提起一张兑换码,没付费就是未激活状态,
|
||
# 付费后激活,就等待出图」→ 所以这里发的是 **inactive(未激活)**,**不 burn**。
|
||
# 激活由付款触发:金钻面板确认到账 / 爱发电成交推过来(见 payplatform_hook)。
|
||
newc = gen_codes(1, batch="网页下单", value=price_for(len(templates)),
|
||
platform="网页下单",
|
||
tpl=",".join(templates), state="inactive")[0]
|
||
# 把「这张码属于哪一单」记上 —— 状态仍是未激活,只是方便付款时按留言里的码
|
||
# 自动认出是哪一单(金钻 2026-10-01 的自动对单靠这个)。
|
||
with LOCK:
|
||
_cs = load_codes()
|
||
if newc in _cs:
|
||
_cs[newc]["order"] = oid
|
||
save_codes(_cs)
|
||
meta["codes"] = [newc]
|
||
with LOCK:
|
||
write_meta(oid, meta)
|
||
log("新订单 %s | %s | %s px | 码 %d 个 | 模板 %s | %s"
|
||
% (oid, arm, res, len(good), ",".join(templates), "待付款" if prepay else "已核销入队"))
|
||
return self.js({"ok": True, "order": oid, "token": tok, "expire": meta["expire"],
|
||
"prepay": prepay, "code": (meta.get("codes") or [None])[0]})
|
||
|
||
def order_detail(self, oid, tok):
|
||
m = read_meta(oid)
|
||
# ⚠️「订单不存在」与「口令不对」必须回同一个 404 ——
|
||
# 否则攻击者靠状态码差异就能枚举出哪些订单号是真的(信息泄露)。
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
accepted = bool(m.get("accepted")) or bool(m.get("direct")) # direct 单等于自动收货
|
||
files = []
|
||
for i, f in enumerate(m.get("files") or []):
|
||
# 文件大小:买家挑「下哪一张」时要看(标准压缩 vs 无压缩差 7 倍)
|
||
try:
|
||
fpath = os.path.join(order_dir(oid), f.get("path") or "")
|
||
fsz = os.path.getsize(fpath)
|
||
fver = int(os.path.getmtime(fpath)) # 版本号 = 文件 mtime
|
||
except OSError:
|
||
fsz = 0
|
||
fver = 0
|
||
files.append({
|
||
"name": f.get("name"),
|
||
"size": fsz,
|
||
"skin": f.get("skin"),
|
||
"tpl": f.get("tpl") or "", # 重渲弹窗要知道哪个模板已经出图(2026-10-07)
|
||
"is_raw": ("无压缩" in (f.get("name") or "")),
|
||
# 收货前:给预览地址;收货后:给原图地址
|
||
# ⚠️ 必须带 v=<文件 mtime>:重渲会把同名文件原地覆盖,URL 不变的话
|
||
# 浏览器直接拿缓存里的旧图(2026-10-04 金钻:「重渲之后的图为什么还是之前的图」)
|
||
"url": "/order/api/dl/%s/%d?t=%s&v=%d" % (oid, i, tok, fver),
|
||
"prev": ("/order/api/dl/%s/%d?t=%s&p=1&v=%d" % (oid, i, tok, fver)) if f.get("prev") else None,
|
||
"has_prev": bool(f.get("prev")),
|
||
})
|
||
st = m.get("state")
|
||
note = m.get("note") or ""
|
||
hbs = heartbeat()
|
||
# 金额按「出图张数」算,**不是按码个数** —— 网页单根本没有码(2026-09-30 踩过)
|
||
skins = skins_of(m)
|
||
n_img = img_total(m) # 皮肤 × 模板 的组合数
|
||
amount = m.get("amount")
|
||
if amount is None or m.get("skins"): # 有 skins 就现算(追补皮肤后金额要涨)
|
||
amount = price_for(n_img)
|
||
if st == "unpaid":
|
||
# 一句话就够 —— 付款三步写在付款框里,这里别再复述(金钻 2026-10-01:太乱了)
|
||
note = "内容已存好,付款后自动排队出图。"
|
||
elif st == "paid":
|
||
note = "收到你的付款申报了,正在等金钻确认到账 —— 确认后会自动进队列渲染,不用再操作。"
|
||
elif st == "waiting" and m.get("codes"):
|
||
# 卡密单(闲鱼/B站发来的码)本来就是付过款的,别再让买家以为要付款
|
||
pos = queue_pos(oid)
|
||
# 页面把 note 当纯文本显示 —— 别写 Markdown 的 **,买家会看到两对星号(2026-10-05 外部复查)
|
||
note = ("这单是用卡密下的,已经付过款,不用再付款。"
|
||
+ ("渲染机在线,正在排队(前面还有 %d 单)。" % (pos - 1) if hbs["online"]
|
||
else "渲染机当前离线,等金钻开机器后会自动开始渲染,着急可点「呼叫金钻」。"))
|
||
elif st == "waiting":
|
||
pos = queue_pos(oid)
|
||
note = ("渲染机在线,正在排队(前面还有 %d 单)。" % (pos - 1)) if hbs["online"] \
|
||
else "渲染机当前离线,等金钻开机器后会自动开始渲染。着急可点「呼叫金钻」。"
|
||
elif st == "working":
|
||
note = "正在渲染中,稍等片刻。"
|
||
elif st == "done":
|
||
if m.get("direct") and not m.get("accepted"):
|
||
m["note"] = "渲染完成 —— 这一单不用确认收货,看完预览直接下原图就行。"
|
||
note = ("渲染完成,已确认收货 —— 原图可以下载了。成品在服务器只保留 72 小时,请及时下载备份。"
|
||
if accepted else
|
||
"渲染完成!先看下面的 512 预览图(带水印),确认没问题点「确认收货」,"
|
||
"就能下载原图(标准压缩 + 无压缩 16bit,两张都记得下载)。")
|
||
if m.get("partial"):
|
||
# 状态话术不许骗人:少交了就直说(金钻那边已经收到提醒)
|
||
note = ("有 %d 个文件没渲出来,已经自动通知金钻补。下面是已经出好的部分。"
|
||
% max(0, int(m["partial"].get("want") or 0) - int(m["partial"].get("got") or 0))) + note
|
||
elif st == "failed":
|
||
note = note or "渲染失败,已记录,可点「呼叫金钻」处理。"
|
||
return self.js({"ok": True, "oid": oid, "state": st, "created": m.get("created"),
|
||
"started": m.get("started"), "finished": m.get("finished"),
|
||
"templates": m.get("templates"),
|
||
"res": int(m.get("res") or DEFAULT_RES),
|
||
"note": note,
|
||
"accepted": accepted,
|
||
# 买家自助重渲:用过没有 + 上次选了什么(页面按钮据此置灰)
|
||
"redo_used": bool(m.get("redo_used")),
|
||
# 直发单没有收货这一步(accepted 恒为真),免费重渲照样给;
|
||
# 买家亲手点过「确认收货」的单才关掉重渲 —— 前端靠这个区分(2026-10-07)
|
||
"direct": bool(m.get("direct")),
|
||
"accepted_by_buyer": bool(m.get("accepted")),
|
||
"redo_files": m.get("redo_files") or [],
|
||
"amount": amount,
|
||
"amount": amount,
|
||
"n_img": n_img,
|
||
"codes": m.get("codes") or [],
|
||
"skins": [{"id": x.get("id"), "name": x.get("fileName"),
|
||
"arm": x.get("arm"), "size": x.get("skin_size"),
|
||
"tpls": skin_tpls(m, x)} for x in skins],
|
||
"n_tpl": len(m.get("templates") or []),
|
||
"accepted_at": m.get("accepted_at"),
|
||
# 卡密的张数 / 模板锁定(金钻 2026-09-30 晚):页面要照它提示与拦人
|
||
"rules": (m.get("rules") or codes_rules(m.get("codes") or [])),
|
||
"files": files,
|
||
# 到期时间按「开放下载后 72 小时」现算(老单没有 accepted_at 就用创建时间)
|
||
"expire": ((expire_at(m) or now()).isoformat(timespec="seconds")
|
||
if expire_at(m) else m.get("expire")),
|
||
"open_at": open_at(m),
|
||
"progress": m.get("progress"),
|
||
"eta_sec": tpl_eta_sec(m.get("templates"), n_img),
|
||
"machine_online": hbs["online"]})
|
||
|
||
def _read_skin(self, d):
|
||
"""把请求里的皮肤解码 + 体检 + 洗白,返回 (ok, err, clean_bytes, size, notes)"""
|
||
raw = (d.get("skin") or "").split(",", 1)[-1]
|
||
try:
|
||
data = base64.b64decode(raw, validate=False)
|
||
except Exception:
|
||
return False, "皮肤图解析失败", None, None, []
|
||
if len(data) > MAX_SKIN:
|
||
return False, "皮肤文件过大", None, None, []
|
||
sz = png_size(data)
|
||
if sz is None:
|
||
return False, "皮肤必须是 PNG 图片", None, None, []
|
||
w, h = sz
|
||
if w != h:
|
||
if h * 2 == w or w * 2 == h:
|
||
return False, "皮肤尺寸 %d×%d 是旧版 2:1 皮肤(没有独立左臂/左腿纹路),模板渲染不了" % (w, h), None, None, []
|
||
return False, "皮肤尺寸 %d×%d 不是皮肤比例(应为正方形)" % (w, h), None, None, []
|
||
if w < MIN_SIDE or w > MAX_SIDE:
|
||
return False, "皮肤尺寸 %d×%d 超出范围(%d~%d)" % (w, h, MIN_SIDE, MAX_SIDE), None, None, []
|
||
okp, why, clean, notes = pngcheck.scan(data)
|
||
if not okp:
|
||
return False, "皮肤图片未通过安全核验:%s" % why, None, None, []
|
||
return True, None, clean, sz, notes
|
||
|
||
def add_skin(self):
|
||
"""往已有订单**追补**一张皮肤(金钻 2026-09-30:「玩家填完可以在后面补」)。
|
||
|
||
每张皮肤各自判臂型 —— A 可能 Steve 粗臂、B 可能 Alex 细臂,
|
||
出图 = 皮肤 × 模板 的组合。已经开渲的单不让补(不然队列对不上)。
|
||
"""
|
||
ip = ip_of(self)
|
||
if not skin_allowed(ip):
|
||
return self.err("操作太频繁,请稍后再试", 429)
|
||
if not disk_ok():
|
||
return self.err("服务器空间不足,请联系金钻处理", 503)
|
||
d = self.body_json() # 单张皮肤(现在上限 10MB,见 MAX_SKIN)
|
||
if not d:
|
||
return self.err("请求体不合法")
|
||
oid, tok = (d.get("oid") or "").strip(), d.get("token") or ""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") not in ("unpaid", "paid", "waiting"):
|
||
return self.err("这一单已经在渲染或已完成,不能再加皮肤了。要加请另开一单。")
|
||
ok, e, clean, sz, notes = self._read_skin(d)
|
||
if not ok:
|
||
return self.err(e)
|
||
arm = d.get("arm") or "classic"
|
||
if arm not in ("classic", "slim"):
|
||
return self.err("手臂规格不合法")
|
||
skins = skins_of(m)
|
||
if len(skins) >= MAX_IMAGES:
|
||
return self.err("一张单最多 %d 张皮肤" % MAX_IMAGES)
|
||
# 这张皮肤自己要出哪些模板(金钻 2026-10-01:逐张配,没给就沿用订单级那份)
|
||
new_tpls = [t for t in (d.get("tpls") or m.get("templates") or []) if t in TPL_KEYS][:MAX_IMAGES]
|
||
if not new_tpls:
|
||
return self.err("这张皮肤还没挑模板(要从模板清单里挑至少一个)")
|
||
# 张数卡密(金钻 2026-09-30 晚 + 10-01 改口径):加完这张一共出几张 = 各皮肤之和
|
||
n_after = sum(len(skin_tpls(m, x)) for x in skins) + len(new_tpls)
|
||
uni = list(m.get("templates") or [])
|
||
for t in new_tpls:
|
||
if t not in uni:
|
||
uni.append(t)
|
||
e2 = check_rules(codes_rules(m.get("codes") or []), n_after, uni)
|
||
if e2:
|
||
return self.err("这张皮肤加不了:" + e2)
|
||
sid = "s%d" % (len(skins) + 1)
|
||
while any(x.get("id") == sid for x in skins):
|
||
sid += "x"
|
||
sd = os.path.join(order_dir(oid), "skins")
|
||
os.makedirs(sd, exist_ok=True)
|
||
rel = "skins/%s.png" % sid
|
||
with open(os.path.join(order_dir(oid), rel), "wb") as f:
|
||
f.write(clean)
|
||
os.chmod(os.path.join(order_dir(oid), rel), 0o640)
|
||
skins.append({"id": sid, "fileName": (d.get("fileName") or ("皮肤%s.png" % len(skins))) [:80],
|
||
"arm": arm, "arm_auto": d.get("armAuto"),
|
||
"arm_certain": bool(d.get("armCertain")),
|
||
"skin_size": list(sz), "path": rel,
|
||
"tpls": new_tpls, # 这张皮肤自己出的模板
|
||
"added": now().isoformat(timespec="seconds")})
|
||
m["skins"] = skins
|
||
m["templates"] = uni # 订单级 = 并集(展示/锁定校验用)
|
||
m["amount"] = price_for(img_total(m))
|
||
# (网页单的凭证码不带张数,所以这里不需要同步 —— 见 submit 里那段注释)
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
note_skin(ip)
|
||
log("订单 %s 追补皮肤 %s(%s)→ 共 %d 张皮肤 × %d 模板 = %d 张图 ¥%s"
|
||
% (oid, sid, arm, len(skins), len(m.get("templates") or []), img_total(m), m["amount"]))
|
||
return self.js({"ok": True, "skins": len(skins), "n_img": img_total(m), "amount": m["amount"],
|
||
"skin": {"id": sid, "name": skins[-1]["fileName"], "arm": arm, "size": list(sz)}})
|
||
|
||
def set_templates(self):
|
||
"""改模板。带 `skin=<皮肤id>` 就只改那一张皮肤的;不带 = 改所有皮肤(老用法)。
|
||
|
||
金钻 2026-10-01 改成「每张皮肤各自一份模板」之后,追补/删减要能落到具体某张上。
|
||
"""
|
||
d = self.body_json() or {}
|
||
oid, tok = (d.get("oid") or "").strip(), d.get("token") or ""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") not in ("unpaid", "paid", "waiting"):
|
||
return self.err("这一单已经在渲染或已完成,改不了模板了")
|
||
tpls = [t for t in (d.get("templates") or []) if t in TPL_KEYS]
|
||
if not tpls:
|
||
return self.err("至少要留一个模板")
|
||
if len(tpls) > MAX_IMAGES:
|
||
return self.err("最多 %d 个模板" % MAX_IMAGES)
|
||
sid = (d.get("skin") or "").strip()
|
||
skins = skins_of(m)
|
||
if sid:
|
||
hit = [x for x in skins if x.get("id") == sid]
|
||
if not hit:
|
||
return self.err("没有这张皮肤:%s" % sid, 404)
|
||
hit[0]["tpls"] = list(tpls)
|
||
else:
|
||
for x in skins:
|
||
x["tpls"] = list(tpls) # 不带皮肤 = 全改(单皮肤时就是老行为)
|
||
m["skins"] = skins
|
||
m["templates"] = tpl_union(m)
|
||
# 张数 / 锁定模板:改模板会改张数,照卡密规则核一遍
|
||
e2 = check_rules(codes_rules(m.get("codes") or []), img_total(m), m["templates"])
|
||
if e2:
|
||
return self.err(e2)
|
||
m["amount"] = price_for(img_total(m))
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
return self.js({"ok": True, "templates": tpls, "n_img": img_total(m), "amount": m["amount"]})
|
||
|
||
def payplatform_hook(self):
|
||
"""爱发电「自动发货 / 订单推送」回调(金钻 2026-10-01)。
|
||
|
||
真实报文长这样(2026-10-01 21:22 抓到的,UA=PayplatformRobot):
|
||
{"ec":200,"em":"ok","data":{"type":"order","sign":"<RSA-2048 base64>",
|
||
"order":{"out_trade_no":"…","status":2,"total_amount":"5.00",
|
||
"plan_title":"…","title":"…","remark":"买家留言",
|
||
"user_id":"…","sku_detail":[{"name":"sku1","count":2}]}}}
|
||
|
||
处理顺序(**先验证再发码**,绝不靠签名猜):
|
||
① 测试单(标题带"测试")→ 只记账
|
||
② 幂等:同一个 out_trade_no 重推 → 回同一张码(爱发电会重试)
|
||
③ 用开放接口反查这笔单 → 查不到 / 没付款 → 只记账 + 记进待办,不发码
|
||
④ 查得到且 status==2 → 按规格名/金额映射张数 → 生成卡密 → 落账 → 回给爱发电
|
||
"""
|
||
raw = b""
|
||
try:
|
||
n = int(self.headers.get("Content-Length") or 0)
|
||
raw = self.rfile.read(min(n, 64 * 1024)) if n else b""
|
||
except (ValueError, OSError):
|
||
pass
|
||
try:
|
||
obj = json.loads(raw.decode("utf-8", "replace") or "{}")
|
||
except ValueError:
|
||
obj = {"_parse_error": True, "_raw": raw[:2000].decode("utf-8", "replace")}
|
||
# 回调日志(2026-10-06 安全加固):这个地址谁都能 POST —— 只记几个关键头 + 正文前 4KB,
|
||
# 超过 5MB 轮转成 .1(只留一份旧的),不然一个人就能把磁盘写满。
|
||
try:
|
||
if os.path.exists(PAYPLATFORM_LOG) and os.path.getsize(PAYPLATFORM_LOG) > 5 * 1024 * 1024:
|
||
os.replace(PAYPLATFORM_LOG, PAYPLATFORM_LOG + ".1")
|
||
keep = {k: v for k, v in self.headers.items() if k.lower() in ("user-agent", "content-type", "x-real-ip", "x-forwarded-for")}
|
||
body = json.dumps(obj, ensure_ascii=False)
|
||
with open(PAYPLATFORM_LOG, "a", encoding="utf-8") as f:
|
||
f.write(json.dumps({"ts": now().isoformat(timespec="seconds"), "ip": ip_of(self), "headers": keep,
|
||
"body": body[:4096] + ("…(截断)" if len(body) > 4096 else "")},
|
||
ensure_ascii=False) + "\n")
|
||
except OSError:
|
||
pass
|
||
|
||
with HOOK_LOCK:
|
||
return self._payplatform_hook_locked(obj)
|
||
|
||
def _payplatform_hook_locked(self, obj):
|
||
"""回调主体(在 HOOK_LOCK 里跑:同一笔单并发重推、两笔回调同时写账本都不会互相冲掉)。"""
|
||
order = (((obj.get("data") or {}).get("order")) or {})
|
||
oid_af = str(order.get("out_trade_no") or "").strip()
|
||
title = "%s %s" % (order.get("plan_title") or "", order.get("title") or "")
|
||
if not oid_af:
|
||
log("爱发电回调:没有 out_trade_no,忽略(%s)" % json.dumps(obj, ensure_ascii=False)[:200])
|
||
return self.js({"ec": 200, "em": ""})
|
||
if "测试" in title:
|
||
log("爱发电回调:测试单(%s),只记账不发码" % title.strip())
|
||
return self.js({"ec": 200, "em": ""})
|
||
led = STORE.ledger_all()
|
||
# ⚠️ 2026-10-05(外部复查):幂等原来只认「发过码」。可「对上网页单、激活了」那条路记的是
|
||
# code=None + used_by=<单号> —— 同一笔单再推一次(爱发电自己会重试;这个地址又是公开的,
|
||
# 谁都能把报文原样再 POST 一遍)就不算处理过:第二次激活失败(单子已经在排队)→ 掉进
|
||
# 「按买码处理」→ **白送一张码**,还会写进返回体里。现在:发过码 **或** 激活过单,一律原样回。
|
||
if oid_af in led and (led[oid_af].get("code") or led[oid_af].get("used_by")):
|
||
log("爱发电回调:%s 已经处理过(%s),重推原样回它"
|
||
% (oid_af, led[oid_af].get("code") or ("激活了 %s" % led[oid_af].get("used_by"))))
|
||
return self.js({"ec": 200, "em": "", "data": {"content": led[oid_af].get("content") or ""}})
|
||
|
||
if int(order.get("status") or 0) != 2:
|
||
log("爱发电回调:%s 状态不是已付款(status=%s),先不发码"
|
||
% (oid_af[:64], str(order.get("status"))[:8]))
|
||
# ⚠️ 2026-10-06 安全加固:没经过开放接口验证的报文**不写进账本**(原来会把任何人编的单号 / 金额
|
||
# 写进库里的 pay_orders,一刷就是成千上万条,每次存账本还要整表重写 → 拖慢真付款)。
|
||
_hook_unverified(oid_af, order, "未付款(status=%s)" % str(order.get("status"))[:8], ip_of(self))
|
||
return self.js({"ec": 200, "em": ""})
|
||
|
||
real = payplatform_find_order(oid_af)
|
||
if not real:
|
||
# 没验过就不发码 —— 宁可让金钻手工补,也不给伪造的报文发货
|
||
log("⚠️ 爱发电回调:%s 在开放接口里查不到(可能官方延迟/伪造),没发码" % oid_af[:64])
|
||
_hook_unverified(oid_af, order, "接口没查到,待人工核对", ip_of(self))
|
||
return self.js({"ec": 200, "em": ""})
|
||
|
||
n_img_af = payplatform_img_count(real)
|
||
sku_txt = "、".join("%s×%s" % (d.get("name") or "?", d.get("count") or 1)
|
||
for d in (real.get("sku_detail") or [])) or "-"
|
||
|
||
# ===== 先看这笔付款是不是"网页单来付的"(金钻 2026-10-01 的状态机)=====
|
||
# 线索优先级:⓪ 回调带回的订单号 custom_order_id(专链里塞的,金钻 2026-10-03 新加,最硬)
|
||
# ① 留言里写了我方的兑换码(YS-XXXX-….)② 留言里写了订单号(YS7ZBZW6)
|
||
# ③ 留言空着,但**只有一笔**待付款单的金额对得上(唯一才敢自动认,两笔就人工)
|
||
rm_up = str(real.get("remark") or "").upper()
|
||
target, how = None, ""
|
||
# ⓪ 专链下单:前端把订单号写进 custom_order_id,爱发电下单后原样带回来。
|
||
# 取不到这个字段 → 静默跳过,走下面的三条老线索(绝不因字段缺失报错)。
|
||
coid = str((real.get("custom_order_id") if isinstance(real, dict) else "")
|
||
or (order.get("custom_order_id") if isinstance(order, dict) else "") or "").strip()
|
||
if coid:
|
||
for _c in (coid, coid.upper()):
|
||
if read_meta(_c):
|
||
target, how = _c, "回调带回的订单号(custom_order_id)"
|
||
break
|
||
hit = re.search(r"YS-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}", rm_up)
|
||
if hit and not target:
|
||
target = (load_codes().get(hit.group(0)) or {}).get("order")
|
||
how = "留言里的兑换码"
|
||
if not target:
|
||
h2 = re.search(r"YS[0-9A-Z]{6}", rm_up.replace("-", ""))
|
||
if h2 and read_meta(h2.group(0)):
|
||
target, how = h2.group(0), "留言里的订单号"
|
||
if not target:
|
||
try:
|
||
amt = int(round(float(str(real.get("show_amount") or real.get("total_amount")))))
|
||
except (TypeError, ValueError):
|
||
amt = -1
|
||
cands = [x for x in list_orders(("unpaid", "paid")) if int(x.get("amount") or 0) == amt]
|
||
if len(cands) == 1:
|
||
target, how = cands[0]["oid"], "唯一一笔金额对得上的待付款单"
|
||
if target:
|
||
m_t = read_meta(target)
|
||
# ⚠️ 金额闸门(金钻 2026-10-03 提的洞):留言里的凭证/订单号只能说明"这笔钱想付哪一单",
|
||
# 不能说明"付够了"。付不够就**不激活**,记一笔待人工 ——
|
||
# 防的是"自定义金额填 0.1 元、留言写上凭证 → 直接把大单激活白嫖"。
|
||
need = float(price_for(img_total(m_t or {})) or 0)
|
||
paid = payplatform_paid(real)
|
||
if paid + 0.005 < need:
|
||
log("⚠️ 爱发电付款 %s(实付 ¥%s)想付网页单 %s,但应付 ¥%s —— 金额不足,不激活、不发码,待人工"
|
||
% (oid_af, paid, target, need))
|
||
led[oid_af] = {"ts": now().isoformat(timespec="seconds"), "code": None,
|
||
"amount": real.get("show_amount") or real.get("total_amount"),
|
||
"sku": sku_txt, "buyer": real.get("user_id"), "remark": real.get("remark"),
|
||
"want_order": target, "need": need, "paid": paid,
|
||
"note": "金额不足(应付 ¥%s,实付 ¥%s),待人工核对" % (need, paid),
|
||
"need_human": True}
|
||
STORE.ledger_save(led)
|
||
return self.js({"ec": 200, "em": "", "data": {"content":
|
||
"金钻工坊 · 自助模板渲染\n收到你的付款,但金额和订单应付款(¥%s)对不上,已记下来等人工核对。\n"
|
||
"核对没问题就立刻排队出图;如果是付少了,补齐后我们会马上处理。" % need}})
|
||
ok, msg = activate_order_paid(target, source="爱发电成交(%s)" % how)
|
||
if ok:
|
||
content = ("金钻工坊 · 自助模板渲染\n已确认你的付款,订单 %s 已激活并开始排队出图。\n"
|
||
"进度/成品都在这页看:http<WIN-PATH>"
|
||
% (target, target, (m_t or {}).get("token") or ""))
|
||
rec_led = {"ts": now().isoformat(timespec="seconds"), "code": None,
|
||
"n_img": img_total(m_t or {}), "used_by": target,
|
||
"amount": real.get("show_amount") or real.get("total_amount"),
|
||
"sku": sku_txt, "buyer": real.get("user_id"),
|
||
"remark": real.get("remark"), "content": content, "notified": False,
|
||
"matched_by": how}
|
||
# 金钻 2026-10-03:多付照样激活(不能因为多给钱就卡住出图),
|
||
# 但**必须记账 + 在回调文案里出声** —— 否则买家多付了我们不知道,
|
||
# 他也不好意思说。常见成因是「其实想多买几张」→ 待人工看一眼。
|
||
over = paid - need
|
||
if over > 0.005:
|
||
rec_led["over"] = over
|
||
rec_led["need"] = need
|
||
rec_led["paid"] = paid
|
||
rec_led["note"] = ("多收 ¥%s(应付 ¥%s,实付 ¥%s),待人工看一眼(可能是想多买)"
|
||
% (_yuan(over), _yuan(need), _yuan(paid)))
|
||
content += ("\n本次收到 ¥%s、订单应付 ¥%s,多收 ¥%s 请联系金钻退回"
|
||
"(也可以留作支持 🙏)" % (_yuan(paid), _yuan(need), _yuan(over)))
|
||
rec_led["content"] = content
|
||
led[oid_af] = rec_led
|
||
STORE.ledger_save(led)
|
||
log("爱发电付款 %s(¥%s)→ 对上网页单 %s → 已激活进队列(靠:%s)"
|
||
% (oid_af, led[oid_af]["amount"], target, how))
|
||
return self.js({"ec": 200, "em": "", "data": {"content": content}})
|
||
log("爱发电付款 %s 想激活 %s,但没成:%s" % (oid_af, target, msg))
|
||
|
||
# ===== 不是网页单(或者对不上)→ 按"买了张卡密"处理:发码 =====
|
||
# ⚠️ 发码前按**实付金额**再卡一道(金钻 2026-10-03):规格/金额说几张,就以"实付买得起几张"为准。
|
||
# 连一张都买不起(比如自定义金额填 0.1)→ 不发码,记待人工。防白嫖。
|
||
paid = payplatform_paid(real)
|
||
afford = int((paid + 0.005) // PRICE_UNIT)
|
||
n_img = min(n_img_af, afford) if afford > 0 else 0
|
||
if n_img < 1:
|
||
log("⚠️ 爱发电付款 %s 实付只有 ¥%s(不足一张 ¥%s)—— 不发码,待人工" % (oid_af, paid, PRICE_UNIT))
|
||
led[oid_af] = {"ts": now().isoformat(timespec="seconds"), "code": None,
|
||
"amount": real.get("show_amount") or real.get("total_amount"),
|
||
"sku": sku_txt, "buyer": real.get("user_id"), "remark": real.get("remark"),
|
||
"paid": paid, "note": "金额不足一张(¥%s),待人工核对" % paid,
|
||
"need_human": True}
|
||
STORE.ledger_save(led)
|
||
return self.js({"ec": 200, "em": "", "data": {"content":
|
||
"金钻工坊 · 自助模板渲染\n收到你的付款 ¥%s,但不足一张(¥%s),没法自动发码。\n"
|
||
"已记下来等人工核对;补齐差额后会马上补发。" % (paid, PRICE_UNIT)}})
|
||
if n_img < n_img_af:
|
||
log("爱发电付款 %s:规格说 %d 张,但实付 ¥%s 只够 %d 张 —— 按 %d 张发"
|
||
% (oid_af, n_img_af, paid, afford, n_img))
|
||
code = gen_codes(1, batch="爱发电自动", value=n_img * PRICE_UNIT, platform="爱发电",
|
||
tpl="", n_fix=n_img)[0] # 不限模板、只限张数(金钻口径)
|
||
content = ("金钻工坊 · 自助模板渲染\n这是你的卡密(固定 %d 张,模板随便挑):%s\n"
|
||
"到 http<WIN-PATH> 点「卡密下单」填进去就能开始。"
|
||
% (n_img, code))
|
||
rec_led = {"ts": now().isoformat(timespec="seconds"), "code": code, "n_img": n_img,
|
||
"amount": real.get("show_amount") or real.get("total_amount"),
|
||
"sku": sku_txt, "buyer": real.get("user_id"), "remark": real.get("remark"),
|
||
"content": content, "notified": False,
|
||
"note": "没对上网页单,按买码处理"}
|
||
# 金钻 2026-10-03:发码**按规格**(多付不会多发码 —— 张数算法不许动),
|
||
# 但实付明显超过这张码的值时,也记一笔待人工看一眼(同样常见于「想多买」)。
|
||
over_code = paid - n_img * PRICE_UNIT
|
||
if over_code > 0.005:
|
||
rec_led["over"] = over_code
|
||
rec_led["need"] = n_img * PRICE_UNIT
|
||
rec_led["paid"] = paid
|
||
rec_led["note"] = ("没对上网页单,按买码处理;多收 ¥%s(码值 ¥%s,实付 ¥%s),"
|
||
"待人工看一眼(可能是想多买)"
|
||
% (_yuan(over_code), _yuan(n_img * PRICE_UNIT), _yuan(paid)))
|
||
led[oid_af] = rec_led
|
||
STORE.ledger_save(led)
|
||
log("爱发电卖出:%s | 金额 %s | 规格 %s | 留言 %s | 发码 %s(%d 张)"
|
||
% (oid_af, led[oid_af]["amount"], sku_txt, (real.get("remark") or "-")[:30], code, n_img))
|
||
# 发货内容塞进返回体(爱发电的自动发货会用 content 展示给买家;不认也没关系,
|
||
# 下面那条定时任务会把成交+卡密推给金钻,绝不会漏)。
|
||
return self.js({"ec": 200, "em": "", "data": {"content": content}})
|
||
|
||
|
||
def activate_payplatform(self):
|
||
"""用**爱发电订单号**激活网页那一单(金钻 2026-10-01)。
|
||
|
||
为什么要有这条:爱发电的「自动回复 / 自动随机回复(卡密池)」**要认证创作者才能开**
|
||
(2026-10-01 金钻截图确认,两个勾选框都是灰的)。所以认证下来之前,买家拿不到码 ——
|
||
但我们有 webhook:每笔成交都记在 payplatform-orders.json 里了。
|
||
于是让买家**直接填爱发电订单号**,我们按账本认这笔成交 → 激活他那一单。**全程不用码。**
|
||
|
||
⚠️ 一笔成交只能激活一单(账本里记 used_by),不然一个订单号能白嫖出无数单。
|
||
"""
|
||
d = self.body_json() or {}
|
||
oid, tok = (d.get("oid") or "").strip().upper(), d.get("token") or ""
|
||
ano = re.sub(r"[^0-9A-Za-z]", "", str(d.get("payplatform_order") or ""))
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") not in ("unpaid", "paid"):
|
||
return self.err("这一单现在是「%s」,不用再激活了" % m.get("state"))
|
||
if len(ano) < 10:
|
||
return self.err("爱发电订单号看着不对(在爱发电「我的订单」里能复制到,一长串数字)")
|
||
ip = ip_of(self)
|
||
if too_many_fails(ip):
|
||
return self.err("尝试次数过多,请 15 分钟后再试", 429)
|
||
with HOOK_LOCK: # 账本和回调共用一把锁,免得两边同时写把对方的记录冲掉
|
||
return self._activate_payplatform_locked(oid, m, ano, ip)
|
||
|
||
def _activate_payplatform_locked(self, oid, m, ano, ip):
|
||
led = STORE.ledger_all()
|
||
rec = None
|
||
for k, v in led.items():
|
||
if str(k).endswith(ano) or str(k) == ano:
|
||
rec = v
|
||
rec["_key"] = k
|
||
break
|
||
if not rec:
|
||
note_fail(ip)
|
||
return self.err("没查到这笔爱发电订单 —— 确认一下订单号?刚付完可能要等几秒,"
|
||
"稍等再试;还不行就点「呼叫金钻」。")
|
||
if not rec.get("code"):
|
||
return self.err("这笔订单我们还没核对上(%s),请点「呼叫金钻」,金钻手工给你开。"
|
||
% (rec.get("note") or "状态异常"))
|
||
if rec.get("used_by") and rec["used_by"] != oid:
|
||
return self.err("这个爱发电订单号已经用在订单 %s 上了" % rec["used_by"])
|
||
if rec.get("used_by") == oid:
|
||
return self.js({"ok": True, "oid": oid, "state": "waiting", "again": True})
|
||
nf = int(rec.get("n_img") or 0)
|
||
want = img_total(m)
|
||
if nf and nf != want:
|
||
return self.err("你买的是 %d 张,这一单是 %d 张 —— 对不上。请点「呼叫金钻」。"
|
||
% (nf, want))
|
||
akey = rec["_key"] # ⚠️ 先存下来:下面要把 _key 从记录里 pop 掉,
|
||
led[akey]["used_by"] = oid # 之后再读 rec["_key"] 就是 KeyError(2026-10-01 实踩,500)
|
||
led[akey].pop("_key", None)
|
||
STORE.ledger_save(led)
|
||
m["payplatform_order"] = akey
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
activate_order_paid(oid, code=rec["code"], source="爱发电订单号")
|
||
return self.js({"ok": True, "oid": oid, "state": "waiting", "code": rec["code"],
|
||
"n_img": img_total(m)})
|
||
|
||
def activate(self):
|
||
"""网页下单的买家:付完款后,用平台发来的卡密**激活自己那一单**。
|
||
|
||
金钻 2026-10-01 定的流程:
|
||
网页把内容填完(挑模板 / 传皮肤)→ 跳去爱发电付款 → 回来把码填上 → 激活开渲。
|
||
**关键:网页填过的东西一个字都不能白填** —— 所以这里是"码认单"而不是"码开新单":
|
||
订单一动不动(皮肤、模板、金额、订单号全不变),只是把码绑上去 + 状态推进到 waiting。
|
||
"""
|
||
d = self.body_json() or {}
|
||
oid, tok = (d.get("oid") or "").strip().upper(), d.get("token") or ""
|
||
code = (d.get("code") or "").strip().upper()
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") not in ("unpaid", "paid"):
|
||
return self.err("这一单现在是「%s」,不用再激活了" % m.get("state"))
|
||
if not CODE_RE.match(code):
|
||
return self.err("卡密格式不对(形如 YS-XXXX-XXXX-XXXX)")
|
||
ip = ip_of(self)
|
||
if too_many_fails(ip): # 和下单共用一套「输错冷却」(2026-10-05 外部复查补)
|
||
return self.err("尝试次数过多,请 15 分钟后再试", 429)
|
||
rec = (load_codes() or {}).get(code)
|
||
if not rec:
|
||
note_fail(ip)
|
||
return self.err("没有这个卡密 —— 检查一下有没有输错")
|
||
# 填的是**自己这一单的凭证码**?金钻 2026-10-01 定的口径:「回来就用这个兑换码就行」。
|
||
# 那就把它当**报到付款**用:订单推到 paid(待激活),并告诉买家"等确认到账就开渲"。
|
||
# ⚠️ 为什么不能直接放行开渲:这张码是**提交订单时白送的**(页面上就摊着),
|
||
# 直接放行等于不付钱也能渲。所以它在这里的作用 = 「我付好了」,不是付款本身;
|
||
# 真金白银那一步由金钻点确认(面板激活)或爱发电成交自动对上(见 payplatform_hook)。
|
||
if code in (m.get("codes") or []):
|
||
if m.get("state") == "unpaid":
|
||
m["state"] = "paid"
|
||
m["paid_at"] = now().isoformat(timespec="seconds")
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("订单 %s 买家填本单凭证码 %s → 报到付款(待激活)" % (oid, code))
|
||
return self.js({"ok": True, "oid": oid, "state": m.get("state"), "paid_claim": True,
|
||
"note": "已收到你的付款登记 —— 金钻确认到账后立刻开渲(一般很快)。"
|
||
"确认后这一页会自动变成「排队中」。"})
|
||
st = code_state(rec)
|
||
if st != "active":
|
||
return self.err("这张卡密%s,换一张试试"
|
||
% ("已经用过了" if st in ("used", "bound") else "被停用了"))
|
||
# 张数必须对得上(1 张的码不能开 3 张的单)
|
||
want = img_total(m)
|
||
nf = int(rec.get("n_fix") or 0)
|
||
if nf and nf != want:
|
||
return self.err("这一单是 %d 张,你手上这张卡密是 %d 张 —— 对不上。"
|
||
"请联系金钻换一张 %d 张的码。" % (want, nf, want))
|
||
# 锁定模板的码,还要核对模板对得上
|
||
if rec.get("lock_tpl") and rec.get("tpl"):
|
||
locked = [x.strip() for x in rec["tpl"].split(",") if x.strip()]
|
||
uni = tpl_union(m)
|
||
if set(uni) - set(locked):
|
||
return self.err("这张卡密锁定了模板(%s),你这单选的是 %s —— 对不上。"
|
||
% ("、".join(locked), "、".join(uni)))
|
||
# 绑码(= 激活,不是核销)。⚠️ 查和绑必须在同一把锁里:同一张码同时激活两张单,
|
||
# 原来两边都会查到 active、都绑上(2026-10-05 外部复查)。
|
||
okb, eb, _g = redeem_bind([code], oid)
|
||
if not okb:
|
||
return self.err(eb)
|
||
m["codes"] = (m.get("codes") or []) + [code]
|
||
m["state"] = "waiting" # 进队列 —— 订单内容原封不动
|
||
m["paid_at"] = now().isoformat(timespec="seconds")
|
||
m["activated_by"] = "卡密激活"
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("订单 %s 用卡密 %s 激活 → 进队列(网页填的内容保持原样)" % (oid, code))
|
||
return self.js({"ok": True, "oid": oid, "state": "waiting", "code": code,
|
||
"n_img": img_total(m), "amount": m.get("amount")})
|
||
|
||
def payinfo(self):
|
||
"""付款方式信息(爱发电链接 / 收款码图 / 说明)—— 页面上的「去付款」按钮读它。
|
||
|
||
改法:编辑 <DATA_DIR>/payinfo.json(金钻给了链接/图就填进去)。
|
||
"""
|
||
d = jload(PAYINFO_FILE, {})
|
||
if not isinstance(d, dict):
|
||
d = {}
|
||
return self.js({"ok": True,
|
||
"payplatform": (d.get("payplatform") or "").strip(),
|
||
# 创作者 ID:前端用它拼「按本单金额生成的专链」
|
||
# (pay-platform.example/order/create?user_id=…&custom_price=…&custom_order_id=…&remark=…)。
|
||
# 没配就回落上面的固定商品链接 payplatform(兜底,金钻 2026-10-03)。
|
||
"payplatform_uid": (d.get("payplatform_uid") or "").strip(),
|
||
"qr_img": (d.get("qr_img") or "").strip(), # 服务器上的相对路径,比如 payme.png
|
||
"note": (d.get("note") or "").strip(),
|
||
"price": PRICE_UNIT,
|
||
# 价格档位表(金钻 2026-10-01):页面按买家选的张数取档位价 + 对应商品链接
|
||
"tiers": price_tiers().get("tiers") or {},
|
||
"per": price_tiers().get("per") or PRICE_UNIT})
|
||
|
||
def redo(self):
|
||
"""买家点「有问题」→ **免费重渲一次**(金钻 2026-10-02)。
|
||
上传时买家只看到 512 预览,出问题不该他吃亏;但也不能无限刷 → 每单一次。
|
||
可选 files:只挑有问题的那几张(留档用;渲染机整体重渲,同名覆盖)。"""
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "").strip()
|
||
tok = d.get("token") or ""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") not in ("done", "failed"):
|
||
return self.err("这一单还没渲完(或正在渲),等它停下来再说")
|
||
if m.get("redo_used"):
|
||
return self.err("这一单已经用过一次免费重渲了。还不行的话进官方群找金钻,他看着办。")
|
||
# ⚠️ 2026-10-07:确认收货 = 买家认可了成品、原图已经放出去了。以前收货后照样能点免费重渲,
|
||
# 等于原图拿走了还能再白出一套。直发单(没有收货这一步)不受影响。
|
||
if m.get("accepted") and not m.get("direct"):
|
||
return self.err("这一单已经确认收货了,免费重渲只能在确认收货之前用。图有问题请进官方群找金钻。")
|
||
files = [str(x)[:60] for x in (d.get("files") or [])][:12]
|
||
# 没渲出来的模板(渲染失败的那几张根本没有成品文件,勾不了文件名 → 直接报模板 key)
|
||
miss = [t for t in (d.get("miss_tpls") or []) if t in TPL_KEYS
|
||
and t in (m.get("templates") or [])][:MAX_IMAGES]
|
||
note = str(d.get("note") or "").strip()[:200]
|
||
# 换皮肤(金钻 2026-10-02:「或者他皮肤填错了重新换」)——
|
||
# 传错了很正常,他上传时只看到 512 预览,不该卡在这儿。
|
||
new_skin = d.get("skin") or ""
|
||
sid = str(d.get("skin_id") or "")[:8]
|
||
if new_skin and sid:
|
||
skins = skins_of(m)
|
||
hit = [x for x in skins if (x.get("id") or "") == sid]
|
||
if not hit:
|
||
return self.err("这张皮肤不属于这一单")
|
||
# ⚠️ 2026-10-05(外部复查):原来这里只 base64 解一下、看个大小就落盘 ——
|
||
# **绕过了 PNG 结构核验**(尾部夹带 / 未知关键块 / APNG 全都能进),
|
||
# 而且直接发给渲染机那台电脑。现在和下单 / 追补皮肤走同一个 _read_skin(核验 + 清洗)。
|
||
okr, er, raw, _sz, _notes = self._read_skin({"skin": new_skin})
|
||
if not okr:
|
||
return self.err("新皮肤不行:%s" % er)
|
||
sd = os.path.join(order_dir(oid), "skins")
|
||
os.makedirs(sd, exist_ok=True)
|
||
with open(os.path.join(sd, "%s.png" % sid), "wb") as f:
|
||
f.write(raw)
|
||
os.chmod(os.path.join(sd, "%s.png" % sid), 0o640)
|
||
# 金钻 2026-10-04:「得保证完全覆盖皮肤」—— 同一张还写一份到 skin.png。
|
||
# 任何一条读取路径(老的按 path / 新的按 skins/<id>.png)拿到的都是新皮肤,
|
||
# 不给「看着换了、实际没换」留缝。
|
||
if sid == "s1":
|
||
with open(os.path.join(order_dir(oid), "skin.png"), "wb") as f:
|
||
f.write(raw)
|
||
os.chmod(os.path.join(order_dir(oid), "skin.png"), 0o640)
|
||
hit[0]["fileName"] = (d.get("skin_name") or "换过的皮肤.png")[:80]
|
||
# ⚠️⚠️ 这行是 2026-10-04 的根因修复:换了皮肤必须**同时把 path 指到新文件**。
|
||
# 原来只写文件 + 改文件名,path 还指着旧的 skin.png →
|
||
# 渲染机下载到的永远是旧皮肤,买家看到「重渲后还是老图」(金钻实测踩到)。
|
||
hit[0]["path"] = "skins/%s.png" % sid
|
||
m["skins"] = skins
|
||
log("免费重渲 %s:换了皮肤 %s(%s)" % (oid, sid, hit[0]["fileName"]))
|
||
# 换模板(金钻 2026-10-04:「有问题的话选错模板的情况没有后悔药诶」)
|
||
new_tpls = [t for t in (d.get("tpls") or []) if t in TPL_KEYS]
|
||
if new_tpls:
|
||
uniq = list(dict.fromkeys(new_tpls))[:MAX_IMAGES]
|
||
n_after = len(uniq) * len(skins_of(m))
|
||
e2 = check_rules(codes_rules(m.get("codes") or []), n_after, uniq)
|
||
if e2:
|
||
return self.err("换模板不行:" + e2)
|
||
for x in skins_of(m):
|
||
x["tpls"] = list(uniq) # 每张皮肤都按新的一套来
|
||
m["templates"] = list(uniq)
|
||
log("免费重渲 %s:换成模板 %s" % (oid, "、".join(uniq)))
|
||
m["redo_used"] = True
|
||
m["redo_files"] = files
|
||
m["redo_note"] = note
|
||
m["redo_at"] = now().isoformat(timespec="seconds")
|
||
# 要重渲的是哪几张 → 换算成模板清单(渲染机是按「皮肤 × 模板」干活的)
|
||
# 金钻 2026-10-04:「重渲要更灵活更聪明」——
|
||
# 一律**只重出玩家勾的那几张**(换没换皮肤都一样,勾什么渲什么);
|
||
# 换了皮肤又想整套一致的话,由玩家自己勾 all=1(弹窗里那个勾选项)。
|
||
redo_tpls = []
|
||
if d.get("all"):
|
||
redo_tpls = [] # 空清单 = 整单重出
|
||
else:
|
||
want = set(files or [])
|
||
for f in (m.get("files") or []):
|
||
if (f.get("name") or "") in want and f.get("tpl") and f["tpl"] not in redo_tpls:
|
||
redo_tpls.append(f["tpl"])
|
||
for t in miss:
|
||
if t not in redo_tpls:
|
||
redo_tpls.append(t)
|
||
if not redo_tpls and files:
|
||
# 勾的图找不到模板(老单缺 tpl 字段)→ 退回整单,别让玩家点了没反应
|
||
redo_tpls = []
|
||
m["redo_tpls"] = redo_tpls
|
||
# 没换皮肤、只重渲一部分 → **保留**其它成品(claim 里清了就再也找不回来了)
|
||
if redo_tpls:
|
||
log("免费重渲 %s:只重出 %s" % (oid, "、".join(redo_tpls)))
|
||
# 重渲中的那几张先从列表里撤掉(渲染机交新的回来时同名字覆盖)
|
||
if files:
|
||
m["files"] = [f for f in (m.get("files") or []) if (f.get("name") or "") not in files]
|
||
m["state"] = "waiting"
|
||
m["started"] = m["finished"] = None
|
||
m["note"] = "买家申请免费重渲%s:%s" % (
|
||
("(只重出:%s)" % "、".join((files or []) + ["%s(上次没出来)" % t for t in miss])
|
||
if redo_tpls else "(整单重出)"),
|
||
note or "(没写原因)")
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("免费重渲 %s | 选了 %s | %s" % (oid, files or "全部", note or "(没写原因)"))
|
||
return self.js({"ok": True, "files": files})
|
||
|
||
def feedback(self):
|
||
"""买家反馈(金钻 2026-10-02:「反馈问题要能上传图片」)。
|
||
为什么改走服务器:原来是 mailto —— **手机上点了没反应**(没配邮箱客户端就什么都不发生),
|
||
而且图片根本带不出去。现在存到 <DATA_DIR>/feedback/,并且走「呼叫金钻」同一套通知。"""
|
||
ip = ip_of(self)
|
||
# ⚠️ 2026-10-05(外部复查):这个接口原来**不限频、不看磁盘**,每次能存一张 4MB 的图,
|
||
# 还会往 calls.jsonl 塞一条「呼叫」→ 写个循环就能把盘写满、把金钻的手机通知刷爆。
|
||
if not feedback_allowed(ip):
|
||
return self.err("反馈太频繁了,稍后再试(着急可以点「呼叫金钻」)", 429)
|
||
if not disk_ok():
|
||
return self.err("服务器空间不足,请联系金钻处理", 503)
|
||
d = self.body_json() or {}
|
||
note = str(d.get("note") or "").strip()[:1500]
|
||
if not note and not d.get("image"):
|
||
return self.err("总得写点什么,或者传张图")
|
||
note_feedback(ip)
|
||
try:
|
||
os.makedirs(FEEDBACK_DIR, exist_ok=True)
|
||
except OSError:
|
||
return self.err("服务器忙,稍后再试", 503)
|
||
fid = now().strftime("%Y%m%d-%H%M%S") + "-" + "".join(
|
||
secrets.choice("abcdefghijkmnpqrstuvwxyz23456789") for _ in range(4))
|
||
rec = {"id": fid, "ts": now().isoformat(timespec="seconds"), "ip": ip,
|
||
"order": str(d.get("order") or "")[:20], "note": note,
|
||
"contact": str(d.get("contact") or "")[:80],
|
||
"trail": [str(x)[:60] for x in (d.get("trail") or [])][:20],
|
||
"errs": [str(x)[:120] for x in (d.get("errs") or [])][:10],
|
||
"platform": str(d.get("platform") or "")[:60],
|
||
"ua": (self.headers.get("User-Agent") or "")[:120],
|
||
"image": ""}
|
||
img = d.get("image") or ""
|
||
if img:
|
||
try:
|
||
raw = base64.b64decode(img.split(",", 1)[-1])
|
||
except Exception:
|
||
raw = b""
|
||
_ext = _img_ext(raw)
|
||
if raw and not _ext:
|
||
rec["image"] = "(不是常见图片格式,没收)"
|
||
elif raw and len(raw) <= 4 * 1024 * 1024:
|
||
fn = "%s.%s" % (fid, _ext)
|
||
with open(os.path.join(FEEDBACK_DIR, fn), "wb") as f:
|
||
f.write(raw)
|
||
rec["image"] = fn
|
||
elif raw:
|
||
rec["image"] = "(图片超过 4MB,没收)"
|
||
with open(os.path.join(FEEDBACK_DIR, fid + ".json"), "w", encoding="utf-8") as f:
|
||
json.dump(rec, f, ensure_ascii=False, indent=1)
|
||
# 走「呼叫金钻」同一套通知:他手机能收到
|
||
add_call({"ts": rec["ts"], "ip": ip, "order": rec["order"],
|
||
"notified": False, "kind": "反馈",
|
||
"note": (note or "(只传了图)")[:120]})
|
||
log("反馈 %s | 单 %s | 图 %s | %s" % (fid, rec["order"] or "-", rec["image"] or "无", (note or "")[:60]))
|
||
return self.js({"ok": True, "id": fid})
|
||
|
||
def my_coupons(self):
|
||
"""批量查券的状态(页面把券存在浏览器里,进来时刷一次状态:可用/已用/已过期 + 还剩多久)"""
|
||
d = self.body_json() or {}
|
||
codes = [re.sub(r"[^A-Za-z0-9-]", "", str(x)).upper()[:20]
|
||
for x in (d.get("codes") or [])][:60]
|
||
cs = load_codes()
|
||
return self.js({"ok": True, "list": [coupon_status(c, cs) for c in codes if c]})
|
||
|
||
def gift_take(self):
|
||
"""领一张福利券 → 返回券码(拿去「卡密下单」用,免费)"""
|
||
d = self.body_json() or {}
|
||
ok, r = gift_claim(str(d.get("batch") or "").strip(), d.get("token") or "", ip_of(self))
|
||
if not ok:
|
||
return self.err(r)
|
||
return self.js({"ok": True, "gift": r})
|
||
|
||
def mark_paid(self):
|
||
"""买家点「我付好了」→ unpaid 转 paid(待激活)。
|
||
|
||
为什么要这一档:买家付完钱到金钻确认到账之间有一段空窗,
|
||
没这个状态买家只能干等、金钻也不知道该查哪几单(2026-09-30 金钻提)。
|
||
"""
|
||
d = self.body_json() or {}
|
||
oid, tok = (d.get("oid") or "").strip(), d.get("token") or ""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") == "paid":
|
||
return self.js({"ok": True, "state": "paid", "at": m.get("paid_at")})
|
||
if m.get("state") != "unpaid":
|
||
# 2026-10-04(金钻反馈:买家看到「提交失败:状态是 working,不需要再报付款了」很懵):
|
||
# 单已经在处理了不是错误 —— 返回 ok,前端就不会显示"提交失败"。
|
||
_stn = {"paid": "已登记付款", "waiting": "排队中", "working": "正在渲染",
|
||
"done": "已完成", "failed": "渲染失败", "void": "已注销"}.get(m.get("state"), m.get("state"))
|
||
return self.js({"ok": True, "already": True, "state": m.get("state"),
|
||
"msg": "这一单已经在处理了(%s),不用再报付款~" % _stn})
|
||
m["state"] = "paid"
|
||
m["paid_at"] = now().isoformat(timespec="seconds")
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("订单 %s 买家报「已付款」,等金钻激活" % oid)
|
||
return self.js({"ok": True, "state": "paid", "at": m["paid_at"]})
|
||
|
||
def _extend_expire(self, m, base_iso):
|
||
"""开放下载时把保留期顺延成「这之后 72 小时」(金钻 2026-09-30 晚)。
|
||
⚠️ 只往后延,不往前缩 —— 免得把已经写好的到期时间改早、文件提前被清。"""
|
||
try:
|
||
want = datetime.fromisoformat(base_iso) + timedelta(hours=KEEP_HOURS)
|
||
except (TypeError, ValueError):
|
||
return
|
||
try:
|
||
cur = datetime.fromisoformat(m.get("expire") or "")
|
||
except (TypeError, ValueError):
|
||
cur = None
|
||
if cur is None or want > cur:
|
||
m["expire"] = want.isoformat(timespec="seconds")
|
||
|
||
def accept(self):
|
||
"""买家「确认收货」—— 看过 512 预览、认了,才放原图(金钻 2026-09-30)。"""
|
||
d = self.body_json() or {}
|
||
oid, tok = (d.get("oid") or "").strip(), d.get("token") or ""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
if m.get("state") != "done":
|
||
return self.err("还没出图,等渲染完成再收货")
|
||
if m.get("accepted"):
|
||
return self.js({"ok": True, "accepted": True, "at": m.get("accepted_at")})
|
||
m["accepted"] = True
|
||
m["accepted_at"] = now().isoformat(timespec="seconds")
|
||
# 保留期从此顺延 72 小时(金钻 2026-09-30 晚:核销与清理都以「开放下载」为起算点)
|
||
self._extend_expire(m, m["accepted_at"])
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("订单 %s 买家已确认收货(成品保留到 %s)" % (oid, m.get("expire")))
|
||
return self.js({"ok": True, "accepted": True, "at": m["accepted_at"]})
|
||
|
||
def download(self, oid, idx, tok, q=None):
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
files = m.get("files") or []
|
||
if idx < 0 or idx >= len(files):
|
||
return self.err("not found", 404)
|
||
# ⚠️ 收货闸:没点「确认收货」不给原图(金钻 2026-09-30)。
|
||
# 预览也走这个接口,用 ?p=1 取 —— 预览本来就是给看不给下的。
|
||
if not m.get("accepted") and not m.get("direct") and (q.get("p") or [""])[0] != "1":
|
||
return self.err("还没确认收货:先看 512 预览,点「确认收货」后才能下载原图", 403)
|
||
if (q.get("p") or [""])[0] == "1":
|
||
rel = files[idx].get("prev")
|
||
if not rel:
|
||
return self.err("预览还没生成好,稍后再试", 404)
|
||
else:
|
||
rel = files[idx].get("path")
|
||
path = os.path.join(order_dir(oid), rel)
|
||
if not os.path.exists(path):
|
||
return self.err("文件已过期或不存在", 404)
|
||
name = files[idx].get("name") or "out.png"
|
||
# ⚠️ HTTP 头只能是 latin-1:中文文件名直接写进 filename= 会 UnicodeEncodeError,
|
||
# 连接被掐断 → nginx 侧看到 502。必须给 ASCII 回退名 + RFC 5987 的 filename*=
|
||
ascii_name = re.sub(r"[^A-Za-z0-9._-]", "_", name) or "out.png"
|
||
disp = ("attachment; filename=\"%s\"; filename*=UTF-8''%s"
|
||
% (ascii_name, quote(name, safe="")))
|
||
ctype = "image/jpeg" if rel.lower().endswith(".jpg") else "image/png"
|
||
# ⚠️ no-store:成品/预览是同名覆盖的,重渲后绝不能让浏览器拿缓存里的旧图
|
||
# ⚠️ 2026-10-05(外部复查):原来 `data = f.read()` 整张读进内存再发。4096 的无压缩 16bit
|
||
# 一张就是几十 MB,几个人同时下就顶到 MemoryMax=256M → 整个服务被 OOM 杀掉。
|
||
# 现在和 zip 一样边读边发(64KB 一块),响应头、内容一个字节都没变。
|
||
if (q.get("p") or [""])[0] == "1":
|
||
self._send_file(path, ctype, {}) # 预览内联显示,不强制下载
|
||
else:
|
||
self._send_file(path, ctype, {"Content-Disposition": disp})
|
||
|
||
def skin(self, oid, sid="s1"):
|
||
m = read_meta(oid)
|
||
if not m:
|
||
return self.err("not found", 404)
|
||
sk = [x for x in skins_of(m) if x.get("id") == sid]
|
||
if not sk:
|
||
return self.err("没有这张皮肤", 404)
|
||
# ⚠️ 优先读 skins/<id>.png:重渲换皮肤写的是这个文件。老单(2026-10-04 之前
|
||
# 换过皮肤的)meta 里的 path 还指着旧的 skin.png,这样兜住不用手工改数据。
|
||
cand = [os.path.join(order_dir(oid), "skins", "%s.png" % sid),
|
||
os.path.join(order_dir(oid), sk[0].get("path") or "skin.png")]
|
||
path = next((p for p in cand if os.path.exists(p)), cand[-1])
|
||
if not os.path.exists(path):
|
||
return self.err("not found", 404)
|
||
self._send_file(path, "image/png")
|
||
|
||
def hb(self):
|
||
if not self.is_worker():
|
||
return self.err("forbidden", 403)
|
||
d = self.body_json() or {}
|
||
# 顺手记下渲染机的出口 IP —— 管理后台面板靠它把门(见 admin_ip_ok)
|
||
ip = ip_of(self)
|
||
if ip and ip not in ("?", "localhost"):
|
||
note_home_ip(ip)
|
||
STORE.kv_put("home_ips", {"ips": HOME_IPS})
|
||
with LOCK:
|
||
status_cache_clear()
|
||
STORE.kv_put("heartbeat", {"ts": now().isoformat(timespec="seconds"),
|
||
"host": (d.get("host") or "render")[:40]})
|
||
return self.js({"ok": True, "queue": len(list_orders(("waiting",)))})
|
||
|
||
def claim(self):
|
||
"""渲染机取一单(原子)。没有待办返回 {ok:True, order:null}"""
|
||
if not self.is_worker():
|
||
return self.err("forbidden", 403)
|
||
with LOCK:
|
||
# 渲染机中途挂掉/断电:working 卡太久的单子自动退回队列重排
|
||
stale = now() - timedelta(minutes=STALE_MIN)
|
||
for mm in list_orders(("working",)):
|
||
try:
|
||
st = datetime.fromisoformat(mm.get("started") or mm.get("created"))
|
||
except (TypeError, ValueError):
|
||
st = stale - timedelta(days=1)
|
||
if st < stale:
|
||
mm["state"] = "waiting"
|
||
mm["note"] = "渲染机中断,已自动退回队列"
|
||
write_meta(mm["oid"], mm)
|
||
log("回退 %s(渲染机中断)" % mm["oid"])
|
||
waiting = list_orders(("waiting",))
|
||
if not waiting:
|
||
return self.js({"ok": True, "order": None})
|
||
# 排序:小单先出;4096 这种重单先让路,等够 HEAVY_WAIT_MIN 就恢复正常排队
|
||
waiting.sort(key=order_rank)
|
||
m = waiting[0]
|
||
m["state"] = "working"
|
||
m["started"] = now().isoformat(timespec="seconds")
|
||
# 整单重出(网页单/换皮肤的重渲)才清空成品清单;
|
||
# 「只重渲勾的那几张」时必须留着 —— 清了的话没重渲的成品就永远回不来了(金钻 2026-10-04)
|
||
if not m.get("redo_tpls"):
|
||
m["files"] = []
|
||
m.pop("plan_total", None) # 新的一轮,按渲染机这次报的 total 重新算
|
||
m.pop("partial", None)
|
||
write_meta(m["oid"], m)
|
||
log("派单 %s → 渲染机" % m["oid"])
|
||
return self.js({"ok": True, "order": {
|
||
"oid": m["oid"], "arm": m["arm"], "templates": m["templates"],
|
||
"created": m["created"], "skin_size": m.get("skin_size"),
|
||
"res": int(m.get("res") or DEFAULT_RES),
|
||
"redo_tpls": (m.get("redo_tpls") or []), "keep_n": len(m.get("files") or []), "codes": m.get("codes"),
|
||
# 2026-10-05(外部复查,⚠️ 接口**新增**字段):渲染机留档里的「条款版本」原来读不到这一项,
|
||
# 一直写的是渲染机自己写死的旧版本号(2026-10-01.1)。带上订单真实同意的那一版。
|
||
"terms_v": m.get("terms_v") or "",
|
||
# 皮肤清单(金钻 2026-10-01):渲染机按「每张皮肤 × 每个模板」出图,
|
||
# 每张皮肤各自带臂型(A 可能粗臂、B 可能细臂)
|
||
"skins": [{"id": x.get("id"), "fileName": x.get("fileName"), "arm": x.get("arm"),
|
||
"tpls": skin_tpls(m, x)} for x in skins_of(m)],
|
||
}})
|
||
|
||
def tick(self, oid, tok):
|
||
"""轻量心跳:只回「状态 + 进度」。
|
||
|
||
详情接口每次要读 meta + stat 一堆文件,不敢几秒问一次;这个只读 meta,
|
||
所以前端可以 4 秒一轮 —— 渲染机一领单、进度一动,页面上立刻能看见。
|
||
"""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
files = m.get("files") or []
|
||
return self.js({"ok": True,
|
||
"state": m.get("state"),
|
||
"n": len(files),
|
||
"started": m.get("started"),
|
||
"finished": m.get("finished"),
|
||
"progress": m.get("progress"),
|
||
"accepted": bool(m.get("accepted")) or bool(m.get("direct"))})
|
||
|
||
def progress(self):
|
||
"""渲染机报「渲到哪了」(金钻 2026-10-04:买家得看得见进度)。
|
||
|
||
允许它漏报、报错、断线 —— **绝不能因为这个影响出图**,所以任何异常都当"收到,忽略"。
|
||
"""
|
||
if not self.is_worker():
|
||
return self.err("forbidden", 403)
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "")[:20]
|
||
m = read_meta(oid)
|
||
if not m:
|
||
return self.err("订单不存在", 404)
|
||
try:
|
||
idx = int(d.get("idx") or 0)
|
||
total = int(d.get("total") or 0)
|
||
pct = int(d.get("pct") or 0)
|
||
except (TypeError, ValueError):
|
||
return self.js({"ok": True, "ignored": True})
|
||
pct = max(0, min(100, pct))
|
||
if total < 0 or total > MAX_IMAGES:
|
||
total = 0
|
||
m["progress"] = {"idx": max(0, idx), "total": total, "pct": pct,
|
||
"tpl": (d.get("tpl") or "")[:20],
|
||
"at": now().isoformat(timespec="seconds")}
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
return self.js({"ok": True})
|
||
|
||
# ⚠️ 2026-10-05(外部复查):这个方法原来叫 finish() —— 和 socketserver 的 StreamRequestHandler.finish()
|
||
# **重名**。框架在**每个请求**处理完之后都会调 self.finish(),于是每个请求结束时都会把「回传成品」
|
||
# 的逻辑再跑一遍:普通请求 → 往已经回完的连接上再写一个 403;带渲染机令牌的请求 → 再去读一次请求体
|
||
# (读到连接关闭才返回)→ 再写一个「参数不合法」。日志里那些
|
||
# 「Exception occurred during processing of request … in finish」就是它。接口路径 /api/finish 不变。
|
||
def finish_upload(self):
|
||
"""渲染机交回成品(**一张一次**,避免单次请求过大):
|
||
{oid, total, results:[{tpl,name,png}], note}
|
||
收满 total 张才把单子标成 done。"""
|
||
if not self.is_worker():
|
||
self.close_connection = True
|
||
return self.err("forbidden", 403)
|
||
d = self.body_json(MAX_BODY_WK)
|
||
if not d or not d.get("oid"):
|
||
return self.err("参数不合法")
|
||
oid = d["oid"]
|
||
m = read_meta(oid)
|
||
if not m:
|
||
return self.err("订单不存在", 404)
|
||
# 渲染机带回来的"皮肤节点认了谁"日志 —— 存进订单 meta,云端能直接查
|
||
# (2026-10-01:模板认错皮肤节点时,不用再去宿主翻渲染机日志)
|
||
if d.get("diag"):
|
||
m["skin_diag"] = [str(x)[:240] for x in (d.get("diag") or [])][:8]
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("皮肤节点判定(%s):%s" % (oid, " | ".join(m["skin_diag"])))
|
||
outdir = os.path.join(order_dir(oid), "out")
|
||
os.makedirs(outdir, exist_ok=True)
|
||
files = m.get("files") or []
|
||
for r in (d.get("results") or [])[:MAX_IMAGES]:
|
||
png = r.get("png") or ""
|
||
try:
|
||
data = base64.b64decode(png.split(",", 1)[-1])
|
||
except Exception:
|
||
continue
|
||
if not data or len(data) > MAX_BODY_WK:
|
||
continue
|
||
name = re.sub(r"[^0-9A-Za-z_\u4e00-\u9fa5.-]", "_", (r.get("name") or "out.png"))[:60]
|
||
if not name.lower().endswith(".png"):
|
||
name += ".png"
|
||
fn = "out/%s" % name
|
||
with open(os.path.join(order_dir(oid), fn), "wb") as f:
|
||
f.write(data)
|
||
entry = {"name": name, "path": fn, "tpl": (r.get("tpl") or "")[:20],
|
||
"skin": (r.get("skin") or "s1")[:8]}
|
||
# 渲染机报的单张耗时 → 存进订单,并喂给「按模板估时」的历史样本
|
||
if r.get("sec"):
|
||
try:
|
||
entry["sec"] = round(float(r["sec"]), 1)
|
||
note_tpl_time(entry["tpl"], entry["sec"])
|
||
except (TypeError, ValueError):
|
||
pass
|
||
if r.get("seq") and not m.get("seq"):
|
||
m["seq"] = int(r["seq"]) # 留档序号(渲染机给的,小票上印)
|
||
# 512 水印预览:服务器自己生成,渲染机不用多装东西。
|
||
# ⚠️ 只给「标准压缩」那张做 —— 「无压缩」是同一画面另存,再做一遍纯浪费(金钻 2026-10-01 反馈:预览列表里重复出现两张一样的)
|
||
is_raw = "无压缩" in name
|
||
if not is_raw:
|
||
pv = make_preview(oid, os.path.join(order_dir(oid), fn), name, len(files))
|
||
if pv:
|
||
entry["prev"] = pv
|
||
else:
|
||
entry["prev_failed"] = True # 交给下面的「水印没做好就不许标完成」闸门
|
||
# 重渲会把同名图重新交上来 —— 按名字替换,别在列表里堆两份(2026-10-02 加重渲时发现)
|
||
files = [f for f in files if (f.get("name") or "") != name]
|
||
files.append(entry)
|
||
# ⚠️ 2026-10-05(外部复查):渲染机收单(close)那一下**不带 total**,原来就退回按「模板数」算 ——
|
||
# 可渲染机的 total 是按**文件数**(每个模板两张)报的。于是 2 个模板只交回 2 个文件(缺两张无压缩)
|
||
# 也会被当成「收满了」。现在记住渲染机前面报过的 total(plan_total),收单时按它判断。
|
||
try:
|
||
_tot_in = int(d.get("total") or 0)
|
||
except (TypeError, ValueError):
|
||
_tot_in = 0
|
||
if _tot_in > 0:
|
||
m["plan_total"] = _tot_in
|
||
total = _tot_in or int(m.get("plan_total") or 0) or len(m.get("templates") or []) or 1
|
||
m["files"] = files
|
||
if d.get("note"):
|
||
m["note"] = str(d["note"])[:300]
|
||
# 收满 total 张,或渲染机显式收单(有部分失败时用 close),都算这单结束
|
||
# ⚠️ 水印/预览没做出来的图,**不许标「已完成」**(金钻 2026-10-01:
|
||
# 「如果水印没有做好,请不要标记渲染完成」)—— 不然买家看到「已完成」却既看不了
|
||
# 预览也下不了原图(收货闸挡着),等于卡死。宁可标 failed 让金钻/苏达看到。
|
||
bad_prev = [f.get("name") for f in files
|
||
if not f.get("prev") and "无压缩" not in (f.get("name") or "")]
|
||
if len(files) >= total or d.get("close"):
|
||
if bad_prev:
|
||
m["state"] = "failed"
|
||
m["note"] = ("预览水印没生成出来(%s),已拦下不让买家看到「已完成」。"
|
||
"金钻/苏达用 admin.py retry <单号> 退回重渲即可。"
|
||
% "、".join(bad_prev))[:300]
|
||
log("⚠️ %s 预览缺失 %s → 标 failed(水印闸门)" % (oid, bad_prev))
|
||
else:
|
||
m["state"] = "done"
|
||
m["finished"] = now().isoformat(timespec="seconds")
|
||
m.setdefault("accepted", False) # 收货闸:没确认只能看 512 预览
|
||
# ⚠️ 2026-10-05(外部复查):渲染机显式收单(close)但没收满 total 张 = 部分失败。
|
||
# 原来照样标「已完成」,失败原因只写进 note —— 而 done 状态的页面文案会把 note 盖掉,
|
||
# 买家看到「渲染完成」、金钻也收不到任何提醒(静默少交货)。
|
||
# 现在:记下缺了几张 + 往 calls.jsonl 写一条(走「呼叫金钻」同一套通知)+ 页面说实话。
|
||
if d.get("close") and len(files) < total:
|
||
m["partial"] = {"got": len(files), "want": total,
|
||
"why": str(d.get("note") or "")[:300],
|
||
"at": now().isoformat(timespec="seconds")}
|
||
add_call({"ts": m["partial"]["at"], "ip": "渲染机", "order": oid,
|
||
"notified": False, "kind": "部分失败",
|
||
"note": ("收到 %d/%d 个文件:%s" % (len(files), total,
|
||
m["partial"]["why"]))[:300]})
|
||
log("⚠️ %s 部分失败:收到 %d/%d 个文件(%s)" % (oid, len(files), total, m["partial"]["why"]))
|
||
if m.get("direct"):
|
||
# 直发单不用确认收货 —— 渲完就是「开放下载」,保留期/核销都从这一刻起算
|
||
self._extend_expire(m, m["finished"])
|
||
m["note"] = m.get("note") or ""
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("回传 %s | %d/%d 张%s" % (oid, len(files), total, " 完成" if m["state"] == "done" else ""))
|
||
return self.js({"ok": True, "n": len(files), "total": total,
|
||
"done": m["state"] == "done"})
|
||
|
||
def fail(self):
|
||
if not self.is_worker():
|
||
return self.err("forbidden", 403)
|
||
d = self.body_json() or {}
|
||
oid = d.get("oid")
|
||
m = read_meta(oid) if oid else None
|
||
if not m:
|
||
return self.err("订单不存在", 404)
|
||
m["state"] = "failed"
|
||
m["note"] = (d.get("note") or "渲染失败")[:300]
|
||
# 渲染机把 Blender 的日志尾巴和"皮肤节点判定"一起带回来 —— 失败时最需要它
|
||
if d.get("log_tail"):
|
||
m["fail_log"] = str(d["log_tail"])[-4000:]
|
||
if d.get("diag"):
|
||
m["skin_diag"] = [str(x)[:240] for x in (d.get("diag") or [])][:8]
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
log("失败 %s | %s%s" % (oid, m["note"],
|
||
(" | " + " ".join(m.get("skin_diag") or [])) if m.get("skin_diag") else ""))
|
||
return self.js({"ok": True})
|
||
|
||
def call(self):
|
||
d = self.body_json() or {}
|
||
ip = self.headers.get("X-Real-IP") or self.client_address[0]
|
||
nowt = now()
|
||
# 限频:同 IP 10 分钟内最多 3 次
|
||
since = (nowt - timedelta(seconds=600)).isoformat(timespec="seconds")
|
||
n = len(STORE.calls(ip=ip, since=since))
|
||
if n >= 3:
|
||
return self.js({"ok": True, "throttled": True})
|
||
rec = {"ts": nowt.isoformat(timespec="seconds"), "ip": ip,
|
||
"order": (d.get("order") or "")[:20],
|
||
# 买家写的原因 + 留下的邮箱(金钻 2026-10-04:要在「有问题」那一屏直接呼叫,
|
||
# 得让金钻知道到底出了什么事、修好之后找谁)
|
||
"note": (d.get("note") or "")[:600],
|
||
"email": (d.get("email") or "")[:120],
|
||
"notified": False}
|
||
add_call(rec)
|
||
log("呼叫金钻 %s" % rec)
|
||
return self.js({"ok": True})
|
||
|
||
|
||
# ------------------------------------------------------------ 打包下载(zip)
|
||
def receipt(self, oid, tok, as_file=False):
|
||
"""整单收货凭证(小票)。没有 token 不给 —— 里面有卡密和出图清单。"""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok or ""):
|
||
return self.err("not found", 404)
|
||
body = receipt_text(oid, m).encode("utf-8-sig") # 带 BOM:Windows 记事本不乱码
|
||
extra = {"Cache-Control": "no-store"}
|
||
if as_file:
|
||
extra["Content-Disposition"] = (
|
||
"attachment; filename=\"receipt-%s.txt\"; filename*=UTF-8''%s"
|
||
% (oid, quote("小票-%s.txt" % oid)))
|
||
self._send(200, body, "text/plain; charset=utf-8", extra)
|
||
|
||
def download_zip(self, oid, tok):
|
||
"""整单原图打一个 zip 发走(金钻 2026-09-30「挨个下太慢了,按需下载」)。
|
||
|
||
⚠️ zip 先落临时文件、再边读边发 —— 这台机器只有 1.6G 内存(服务限额 256M),
|
||
几十 MB 的成品绝不能整块读进内存。也不需要准确 Content-Length 之外的技巧。
|
||
"""
|
||
m = read_meta(oid)
|
||
if not m or not hmac.compare_digest(m.get("token", ""), tok):
|
||
return self.err("not found", 404)
|
||
# 和单张下载同一个收货闸:没确认收货不给原图
|
||
if not m.get("accepted") and not m.get("direct"):
|
||
return self.err("还没确认收货:先看 512 预览,点「确认收货」后才能下载原图", 403)
|
||
files = [f for f in (m.get("files") or []) if f.get("path")]
|
||
if not files:
|
||
return self.err("这一单还没有可下载的成品", 404)
|
||
base = order_dir(oid)
|
||
total = 0
|
||
for f in files:
|
||
try:
|
||
total += os.path.getsize(os.path.join(base, f["path"]))
|
||
except OSError:
|
||
pass
|
||
if total <= 0:
|
||
return self.err("文件已过期或不存在", 404)
|
||
if total > MAX_ZIP_BYTES:
|
||
return self.err("这一单合计太大(%.0f MB),请一张一张下载" % (total / 1048576.0), 413)
|
||
# ⚠️ 2026-10-05(外部复查):同一时间只打**一个**包。每个包最大 600MB 临时文件,
|
||
# 原来不限并发:同一个取件码连点 / 脚本并发几次,就能把盘和 CPU 一起占满。
|
||
if not ZIP_SEM.acquire(timeout=60):
|
||
return self.err("正在给别的订单打包,稍等一分钟再点", 503)
|
||
try:
|
||
return self._download_zip_locked(oid, m, files, base)
|
||
finally:
|
||
ZIP_SEM.release()
|
||
|
||
def _download_zip_locked(self, oid, m, files, base):
|
||
os.makedirs(TMP_DIR, exist_ok=True)
|
||
fd, zpath = tempfile.mkstemp(prefix="ys-", suffix=".zip", dir=TMP_DIR)
|
||
os.close(fd)
|
||
try:
|
||
# 随包一份**收货凭证(小票)**:金钻 2026-10-01 —— 订单号/卡密/皮肤/逐张清单/
|
||
# 分辨率/时间/留档序号/条款版本/保存期限,闲鱼对账、留证都用它。
|
||
# ⚠️ 带 BOM(utf-8-sig):Windows 记事本打开中文才不乱码。
|
||
# PNG 本身已经压过,再 deflate 一遍几乎不变小、白烧 CPU(小机器上很明显)→ 成品直接 STORED;
|
||
# 小票是文本,单独用 DEFLATED。
|
||
with zipfile.ZipFile(zpath, "w", zipfile.ZIP_STORED) as z:
|
||
z.writestr("小票.txt", receipt_text(oid, m).encode("utf-8-sig"),
|
||
compress_type=zipfile.ZIP_DEFLATED)
|
||
for i, f in enumerate(files):
|
||
nm = re.sub(r'[\\/:*?"<>|]', "_", f.get("name") or ("out%d.png" % (i + 1)))
|
||
z.write(os.path.join(base, f["path"]), "%02d_%s" % (i + 1, nm))
|
||
size = os.path.getsize(zpath)
|
||
zname = "金钻工坊-%s.zip" % oid
|
||
ascii_name = re.sub(r"[^A-Za-z0-9._-]", "_", zname) or "order.zip"
|
||
self.send_response(200)
|
||
self.send_header("Content-Type", "application/zip")
|
||
self.send_header("Content-Length", str(size))
|
||
self.send_header("Cache-Control", "no-store")
|
||
self.send_header("Content-Disposition",
|
||
"attachment; filename=\"%s\"; filename*=UTF-8''%s"
|
||
% (ascii_name, quote(zname, safe="")))
|
||
self.end_headers()
|
||
with open(zpath, "rb") as fh:
|
||
shutil.copyfileobj(fh, self.wfile, ZIP_CHUNK)
|
||
log("打包下载 %s | %d 张 %.1f MB" % (oid, len(files), size / 1048576.0))
|
||
except (BrokenPipeError, ConnectionResetError):
|
||
log("打包下载 %s 被中断(买家关页面了)" % oid)
|
||
finally:
|
||
try:
|
||
os.remove(zpath)
|
||
except OSError:
|
||
pass
|
||
|
||
# ------------------------------------------------------------ 管理接口(面板)
|
||
def admin_gate(self):
|
||
"""金钻电脑上那块后台面板的通行证 —— 两道门都要过:
|
||
① 令牌对得上(<DATA_DIR>/admin_token,和 worker_token 一个路子)
|
||
② 来源 IP 是「渲染机心跳认出来的出口 IP」= 金钻家网络的公网出口
|
||
所以**公网上别处扫到也是 403**:令牌泄露了外人也进不来。
|
||
"""
|
||
ip = ip_of(self)
|
||
if not hmac.compare_digest(self.headers.get("X-Admin-Token") or "", AT):
|
||
log("管理接口拒绝:令牌不对 (%s %s)" % (ip, self.path[:40]))
|
||
return False
|
||
if not admin_ip_ok(ip):
|
||
log("管理接口拒绝:IP 不在白名单 (%s)" % ip)
|
||
return False
|
||
return True
|
||
|
||
def admin_ping(self):
|
||
hbs = heartbeat(force=True)
|
||
cs = load_codes()
|
||
st = [code_state(r) for r in cs.values()]
|
||
return self.js({"ok": True, "machine_online": hbs["online"],
|
||
"last_seen": hbs["last_seen"], "queue": hbs["queue"],
|
||
"working": hbs["working"],
|
||
"codes_active": st.count("active"), "codes_used": st.count("used"),
|
||
"codes_bound": st.count("bound"),
|
||
"pending": len(list_orders(("unpaid", "paid"))),
|
||
"home_ips": HOME_IPS, "tpl_keys": list(TPL_KEYS),
|
||
"price": PRICE_UNIT})
|
||
|
||
def admin_gen(self):
|
||
"""后台一键生成卡密(金钻 2026-09-30:「我后台点击,上传」)。"""
|
||
d = self.body_json() or {}
|
||
try:
|
||
n = int(d.get("n") or 1)
|
||
except (TypeError, ValueError):
|
||
return self.err("数量不合法")
|
||
if not (1 <= n <= 200):
|
||
return self.err("一次生成 1~200 张")
|
||
platform = (d.get("platform") or "").strip()[:20]
|
||
batch = (d.get("batch") or "").strip()[:20]
|
||
try:
|
||
value = int(d.get("value") or PRICE_UNIT)
|
||
except (TypeError, ValueError):
|
||
value = PRICE_UNIT
|
||
tpls = [str(x).strip() for x in (d.get("tpls") or []) if str(x).strip()]
|
||
bad = [x for x in tpls if x not in TPL_KEYS]
|
||
if bad:
|
||
return self.err("模板不认识:%s" % "、".join(bad))
|
||
is_set, direct = bool(d.get("set")), bool(d.get("direct"))
|
||
# 张数卡密(金钻 2026-09-30 晚):n_fix>0 固定张数;n_max>0 封顶;lock_tpl 锁模板
|
||
try:
|
||
n_fix = int(d.get("n_fix") or 0)
|
||
n_max = int(d.get("n_max") or 0)
|
||
except (TypeError, ValueError):
|
||
return self.err("张数不合法")
|
||
if n_fix < 0 or n_max < 0 or n_fix > MAX_IMAGES or n_max > 100:
|
||
return self.err("张数不合法(固定张数最多 %d 张)" % MAX_IMAGES)
|
||
if n_fix and n_max and n_max < n_fix:
|
||
return self.err("封顶不能小于固定张数")
|
||
lock_tpl = bool(d.get("lock_tpl")) and bool(tpls)
|
||
if d.get("lock_tpl") and not tpls:
|
||
return self.err("要锁定模板,得先选模板")
|
||
n_free = bool(d.get("free"))
|
||
if n_free and n_fix:
|
||
return self.err("「不限张数」和「固定张数」只能选一个")
|
||
made = gen_codes(n, batch, value, platform, ",".join(tpls),
|
||
is_set=is_set, direct=direct,
|
||
n_fix=n_fix, n_max=n_max, lock_tpl=lock_tpl, n_free=n_free)
|
||
csv = "\n".join(
|
||
["卡密,金额,平台,模板,套装,直发,固定张数,最多张数,锁定模板"]
|
||
+ ["%s,%d,%s,%s,%s,%s,%s,%s,%s" % (c, value, platform, ",".join(tpls),
|
||
"是" if is_set else "", "是" if direct else "",
|
||
n_fix or "", n_max or "", "是" if lock_tpl else "")
|
||
for c in made])
|
||
log("后台生成 %d 张卡密 | 平台=%s 模板=%s 套装=%s 直发=%s 固定=%s 封顶=%s 锁模板=%s"
|
||
% (n, platform or "-", ",".join(tpls) or "-", is_set, direct,
|
||
n_fix or "-", n_max or "-", lock_tpl))
|
||
return self.js({"ok": True, "codes": made, "csv": csv, "value": value,
|
||
"platform": platform, "tpls": tpls,
|
||
"set": is_set, "direct": direct,
|
||
"n_fix": n_fix, "n_max": n_max, "lock_tpl": lock_tpl,
|
||
"free": n_free})
|
||
|
||
def admin_orders(self, q):
|
||
want = tuple(x for x in ((q.get("state") or [""])[0]).split(",") if x)
|
||
try:
|
||
limit = min(int((q.get("limit") or ["40"])[0]), 200)
|
||
except ValueError:
|
||
limit = 40
|
||
# 2026-10-04 金钻:面板要能看「这一单渲了什么」→ 传 done=1 就把已完成的也带上
|
||
inc_done = bool(q.get("done") or "done" in want)
|
||
rows = []
|
||
for m in list_orders(want or None):
|
||
if m.get("state") in ("done",) and not inc_done:
|
||
continue
|
||
rows.append({
|
||
"oid": m.get("oid"), "state": m.get("state"),
|
||
"created": m.get("created"), "paid_at": m.get("paid_at"),
|
||
"amount": price_for(img_total(m)),
|
||
"n_img": img_total(m),
|
||
"templates": m.get("templates") or [],
|
||
"codes": m.get("codes") or [],
|
||
"skins": [x.get("fileName") for x in skins_of(m)],
|
||
"accepted": bool(m.get("accepted")),
|
||
"files": len(m.get("files") or []),
|
||
"reported_paid": m.get("state") == "paid",
|
||
"note": m.get("note") or "",
|
||
})
|
||
rows.sort(key=lambda r: r.get("created") or "", reverse=True)
|
||
return self.js({"ok": True, "orders": rows[:limit]})
|
||
|
||
def admin_codes(self, q):
|
||
try:
|
||
limit = min(int((q.get("limit") or ["60"])[0]), 500)
|
||
except ValueError:
|
||
limit = 60
|
||
want = (q.get("state") or [""])[0].strip()
|
||
# 2026-10-05:后台面板加了搜索框 —— 按码 / 订单号 / 批次 / 平台 找(不分大小写)
|
||
kw = (q.get("q") or [""])[0].strip().upper()[:40]
|
||
out = []
|
||
for c, r in load_codes().items():
|
||
st = code_state(r)
|
||
if want and st != want:
|
||
continue
|
||
if kw and not any(kw in str(x or "").upper()
|
||
for x in (c, r.get("order"), r.get("batch"), r.get("platform"))):
|
||
continue
|
||
out.append({"code": c, "state": st, "platform": r.get("platform"),
|
||
"tpl": r.get("tpl"), "set": bool(r.get("set")),
|
||
"direct": bool(r.get("direct")), "batch": r.get("batch"),
|
||
"n_fix": int(r.get("n_fix") or 0), "n_max": int(r.get("n_max") or 0),
|
||
"lock_tpl": bool(r.get("lock_tpl")),
|
||
"order": r.get("order"), "ts": r.get("ts")})
|
||
out.sort(key=lambda r: r.get("ts") or "zzz", reverse=True)
|
||
return self.js({"ok": True, "codes": out[:limit], "total": len(out)})
|
||
|
||
def admin_code_edit(self):
|
||
"""改一张**还没用掉**的卡密(金钻 2026-09-30 晚「这个也给你开 api,方便我管理和你介入」)。
|
||
|
||
典型用法:买家说「我再加两张」→ 把这张码的固定张数从 3 改成 5;
|
||
或者临时把码停掉(state=inactive)。
|
||
"""
|
||
d = self.body_json() or {}
|
||
ok, e, info = edit_code(d.get("code"), d.get("patch"))
|
||
if not ok:
|
||
return self.err(e, 404 if "没有这张卡密" in e else 400)
|
||
return self.js({"ok": True, "code": info.get("code"), "info": info})
|
||
|
||
def admin_activate(self):
|
||
"""收到钱 → 激活这一单,进队列开渲(等于 admin.py activate)。"""
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "").strip().upper()
|
||
m = read_meta(oid) if oid else None
|
||
if not m:
|
||
return self.err("没有这个订单:%s" % oid, 404)
|
||
ok, msg = activate_order_paid(oid, source="后台激活")
|
||
if not ok:
|
||
return self.err("订单 %s :%s" % (oid, msg))
|
||
return self.js({"ok": True, "oid": oid, "state": "waiting"})
|
||
|
||
def admin_void(self):
|
||
"""注销「未激活」的订单(待付款 / 待激活)—— 只改状态,不删文件(金钻 2026-10-04)。
|
||
已经占住卡密的单不给注销,免得把码弄乱。"""
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "").strip().upper()
|
||
m = read_meta(oid) if oid else None
|
||
if not m:
|
||
return self.err("没有这个订单:%s" % oid, 404)
|
||
st = m.get("state")
|
||
if st not in ("unpaid", "paid"):
|
||
return self.err("只有「待付款 / 待激活」的单能注销,这一单现在是「%s」" % st)
|
||
# 网页下单会给这一单预生成一张 inactive 码(还没生效、本来就用不了)——那不算占住;
|
||
# 只有真被用起来的码(active / bound / used)才拦(2026-10-04 实测踩到)。
|
||
cs = load_codes()
|
||
busy = [c for c in (m.get("codes") or [])
|
||
if (cs.get(c) or {}).get("state") in ("active", "bound", "used")]
|
||
if busy:
|
||
return self.err("这一单已经占住卡密了(%s),不能注销" % "、".join(busy))
|
||
with LOCK:
|
||
m["state"] = "void"
|
||
m["void_at"] = time.strftime("%Y-%m-%dT%H:%M:%S+08:00")
|
||
write_meta(oid, m)
|
||
return self.js({"ok": True, "oid": oid, "state": "void"})
|
||
|
||
def admin_calls(self, q):
|
||
"""「呼叫金钻」/ 反馈 / 部分失败 记录,新的在前(2026-10-05:原来只能 ssh 上去 admin.py calls 看)。"""
|
||
try:
|
||
limit = min(int((q.get("limit") or ["60"])[0]), 300)
|
||
except ValueError:
|
||
limit = 60
|
||
rows = STORE.calls(limit=limit)[::-1]
|
||
return self.js({"ok": True, "calls": rows,
|
||
"open": sum(1 for r in rows if not r.get("handled"))})
|
||
|
||
def admin_call_done(self):
|
||
"""把一条呼叫标成「处理过了」。只加 handled 字段,不碰 notified(那是手机通知那边用的)。"""
|
||
d = self.body_json() or {}
|
||
try:
|
||
cid = int(d.get("id"))
|
||
except (TypeError, ValueError):
|
||
return self.err("没有这条记录", 404)
|
||
undo = bool(d.get("undo"))
|
||
if not STORE.call_mark(cid, handled=not undo,
|
||
handled_at=None if undo else now().isoformat(timespec="seconds")):
|
||
return self.err("没有这条记录", 404)
|
||
return self.js({"ok": True, "id": cid})
|
||
|
||
def admin_retry(self):
|
||
"""渲染失败的单退回队列重渲(等于 admin.py retry;面板上原来只能写「喊苏达」)。"""
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "").strip().upper()
|
||
with LOCK:
|
||
m = read_meta(oid) if oid else None
|
||
if not m:
|
||
return self.err("没有这个订单:%s" % oid, 404)
|
||
if m.get("state") != "failed":
|
||
return self.err("只有「渲染失败」的单能退回重渲,这一单现在是「%s」" % m.get("state"))
|
||
m["state"] = "waiting"
|
||
m["note"] = "管理员退回重渲"
|
||
m["started"] = m["finished"] = None
|
||
write_meta(oid, m)
|
||
status_cache_clear()
|
||
log("后台退回重渲 %s" % oid)
|
||
return self.js({"ok": True, "oid": oid, "state": "waiting"})
|
||
|
||
def admin_note(self):
|
||
d = self.body_json() or {}
|
||
oid = (d.get("oid") or "").strip().upper()
|
||
m = read_meta(oid) if oid else None
|
||
if not m:
|
||
return self.err("没有这个订单", 404)
|
||
m["note"] = str(d.get("note") or "")[:300]
|
||
with LOCK:
|
||
write_meta(oid, m)
|
||
return self.js({"ok": True})
|
||
|
||
# ---- 福利券(免费码):面板 / CLI 双入口(金钻 2026-10-02)----
|
||
# 逻辑全在 gift_batch_new / gift_batch_add / gift_batch_off(模块级),
|
||
# 这里只做「取参 → 调它 → 回 JSON」,**别再写一遍业务**。
|
||
def admin_gifts(self):
|
||
"""批次全貌 + 领取情况(谁在什么时候、哪个 IP 领了哪张)+ 剩余券池。"""
|
||
return self.js(gift_admin_view())
|
||
|
||
def admin_gift_new(self):
|
||
d = self.body_json() or {}
|
||
n_fix = d.get("n_fix")
|
||
if n_fix in (None, ""):
|
||
n_fix = 1 # 不给就按「最多 1 张」;给 0 = 不限(配合 n_free)
|
||
# ⚠️ 别写成 `d.get("count") or 20`:显式传 0 会被静默当成 20(自测当场抓到)。
|
||
# 缺省才是 20,非法值要原样交给 gift_batch_new 拦下来。
|
||
count = d.get("count")
|
||
if count in (None, ""):
|
||
count = 20
|
||
try:
|
||
bid, codes = gift_batch_new(
|
||
d.get("name"), count=count, n_fix=n_fix,
|
||
n_free=bool(d.get("n_free")), tpl=d.get("tpl") or "",
|
||
lock_tpl=bool(d.get("lock_tpl")), days=d.get("days") or 0,
|
||
note=d.get("note") or "", kind=d.get("kind") or "render",
|
||
direct=bool(d.get("direct", True)))
|
||
except ValueError as e:
|
||
return self.err(str(e), 400)
|
||
log("后台新建福利券批次 %s(%d 张)" % (bid, len(codes)))
|
||
return self.js({"ok": True, "batch": bid, "codes": codes, "n": len(codes)})
|
||
|
||
def admin_gift_add(self):
|
||
d = self.body_json() or {}
|
||
count = d.get("count") # 同上:0 不能被 `or 20` 吃掉
|
||
if count in (None, ""):
|
||
count = 20
|
||
try:
|
||
got = gift_batch_add(d.get("batch"), count,
|
||
direct=None if d.get("direct") is None
|
||
else bool(d.get("direct")))
|
||
except ValueError as e:
|
||
return self.err(str(e), 404 if "没有这个批次" in str(e) else 400)
|
||
log("后台给福利批次 %s 补货 %d 张" % (d.get("batch"), len(got)))
|
||
return self.js({"ok": True, "batch": d.get("batch"), "codes": got, "n": len(got)})
|
||
|
||
def admin_gift_off(self):
|
||
d = self.body_json() or {}
|
||
try:
|
||
gift_batch_off(d.get("batch"))
|
||
except ValueError as e:
|
||
return self.err(str(e), 404 if "没有这个批次" in str(e) else 400)
|
||
log("后台收摊福利批次 %s" % d.get("batch"))
|
||
return self.js({"ok": True, "batch": d.get("batch")})
|
||
|
||
|
||
def main():
|
||
for d in (ROOT, ORDERS, TMP_DIR):
|
||
os.makedirs(d, exist_ok=True)
|
||
srv = ThreadingHTTPServer((HOST, PORT), H)
|
||
srv.daemon_threads = True
|
||
log("ys-order 启动 %s:%d | 数据 %s | 保留 %dh" % (HOST, PORT, ROOT, KEEP_HOURS))
|
||
srv.serve_forever()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
try:
|
||
main()
|
||
except KeyboardInterrupt:
|
||
sys.exit(0)
|