Files
jinzuanwork/backend/backend-site/server.py
T
Suda 1d67fda9d5 backend: 交付网站后端 + 本地自助管理后台 + 测试工程(已脱敏)
范围由店主圈定:网页后端 / 自助后端、本地的自助管理后台、
用于测试的 Blender 工程、以及部署层的反代片段。

出站纪律:所有指向真实环境的值(域名/端口/盘符路径/IP/账户名)已替换为占位;
代码里本来就没有硬编码凭据(令牌走文件与环境变量)。
Blender 工程因内嵌绝对路径,做了等长替换(文件字节数未变,结构完好)。

两份交接文档各含《我们的思路与方法》,并要求对方回:
问题分析 + 改正意见 + 他改了什么(含是否动到接口/字段/数据格式)。
2026-10-05 18:52:33 +08:00

3163 lines
157 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
金钻工坊 · 渲染下单 —— 服务器端(订单登记 / 队列 / 兑换码 / 状态)
设计要点
* 纯标准库(http.server),零依赖、内存小 —— 这台机器只有 1.6G 内存
* 队列就是文件系统:orders/<订单号>/meta.json 里 state 字段 = 状态
* 渲染机主动出站拉单(宿主只能出站),服务器不主动连宿主
* 管理操作全走本地 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 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 文件要写进去)
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
CST = timezone(timedelta(hours=8))
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 = jload(GIFTS_FILE, {})
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((jload(GIFTS_FILE, {}) 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):
"""一张券现在什么状态(给"我的卡券"用)。返回 dict。"""
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 r.get("claim_token") == tok]
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 = random.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"
jsave(CODES_FILE, 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(
random.choice(GIFT_ID_ALPH) for _ in range(3))
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"),
})
jsave(GIFTS_FILE, 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")))
cs = load_codes()
for c in got:
cs[c]["gift"] = bid
jsave(CODES_FILE, cs)
log("福利券批次 %s 补货 %d 张" % (bid, len(got)))
return got
def gift_batch_off(bid):
"""收摊(已领到手的券不受影响)。批次不存在 raise ValueError。"""
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
jsave(GIFTS_FILE, 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())
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 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
def jsave(path, obj):
tmp = path + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
json.dump(obj, f, ensure_ascii=False, indent=1)
os.replace(tmp, path)
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 = (jload(HB_IPS_FILE, {}) 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)。"""
return ip in ("localhost", "::1", "localhost", "?") or ip in HOME_IPS
def new_oid():
return "YS" + "".join(random.choice(OID_ALPH) for _ in range(6))
def new_owner_token():
return "".join(random.choice(OID_ALPH) for _ in range(14))
# ----------------------------------------------------------------- 兑换码
def load_codes():
return jload(CODES_FILE, {})
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(random.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)
jsave(CODES_FILE, 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 = (load_codes() or {}).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
try:
d = json.load(open(TPL_TIMES_FILE, encoding="utf-8"))
if not isinstance(d, dict):
d = {}
except Exception:
d = {}
arr = list(d.get(tpl) or [])
arr.append(round(sec, 1))
d[tpl] = arr[-50:]
try:
tmp = TPL_TIMES_FILE + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
json.dump(d, f, ensure_ascii=False)
os.replace(tmp, TPL_TIMES_FILE) # 原子替换,断电不会写坏
except OSError:
pass
def tpl_eta_sec(templates, n_img=1):
"""这单大概要渲多久:按模板历史耗时求和;没样本的模板按每张 60 秒兜底,再加 20 秒收尾。"""
try:
d = json.load(open(TPL_TIMES_FILE, encoding="utf-8"))
if not isinstance(d, dict):
d = {}
except Exception:
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)"""
with LOCK:
codes = load_codes()
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 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")
jsave(CODES_FILE, 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:
jsave(CODES_FILE, 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):
p = os.path.join(order_dir(oid), "meta.json")
if not os.path.exists(p):
return None
return jload(p, None)
def write_meta(oid, meta):
jsave(os.path.join(order_dir(oid), "meta.json"), meta)
def list_orders(states=None):
out = []
if not os.path.isdir(ORDERS):
return out
for oid in sorted(os.listdir(ORDERS)):
m = read_meta(oid)
if m and (states is None or m.get("state") in states):
out.append(m)
return out
import pngcheck # PNG 结构核验(防夹带)—— 同目录,零依赖
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:
jsave(CODES_FILE, 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 = jload(HB_FILE, {})
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()
cs = load_codes()
if c not in cs:
return False, "没有这张卡密:%s" % c, None
if code_state(cs[c]) == "used":
return False, ("这张卡密已经用掉了(订单 %s),改不了 —— 要改请用 admin.py 直接动订单"
% (cs[c].get("order") or "")), None
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), None
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, "张数不合法", None
if n_fix > MAX_IMAGES or n_max > 100:
return False, "张数不合法(固定张数最多 %d 张)" % MAX_IMAGES, None
if n_fix and n_max and n_max < n_fix:
return False, "封顶不能小于固定张数", None
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, "要锁定模板,得先给这张码带模板", None
with LOCK:
jsave(CODES_FILE, cs)
log("改卡密 %s → %s" % (c, json.dumps({k: r.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)
# ----------------------------------------------------------------- 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 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 == "/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()
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 == "/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()
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()
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)
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,优先用它。
_n1 = int(d.get("nTotal") or 0) or len(templates)
_u1 = [t for t in (d.get("tplUnion") or 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)):
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"),
}
with LOCK:
write_meta(oid, meta)
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
jsave(CODES_FILE, _cs)
meta["codes"] = [newc]
with LOCK:
write_meta(oid, meta)
else:
burn_codes(good, oid)
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"),
"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 = ("这单是用卡密下的,**已经付过款,不用再付款**。"
+ ("渲染机在线,正在排队(前面还有 %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,两张都记得下载)。")
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")),
"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")}
try:
with open(PAYPLATFORM_LOG, "a", encoding="utf-8") as f:
f.write(json.dumps({"ts": now().isoformat(timespec="seconds"), "ip": ip_of(self),
"headers": dict(self.headers.items()), "body": obj},
ensure_ascii=False) + "\n")
except OSError:
pass
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 = jload(PAYPLATFORM_LEDGER, {}) or {}
if oid_af in led and led[oid_af].get("code"):
log("爱发电回调:%s 已经发过码 %s(重推,原样回它)" % (oid_af, led[oid_af]["code"]))
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, order.get("status")))
led[oid_af] = {"ts": now().isoformat(timespec="seconds"), "status": order.get("status"),
"amount": order.get("show_amount") or order.get("total_amount"),
"code": None, "note": "未付款"}
jsave(PAYPLATFORM_LEDGER, led)
return self.js({"ec": 200, "em": ""})
real = payplatform_find_order(oid_af)
if not real:
# 没验过就不发码 —— 宁可让金钻手工补,也不给伪造的报文发货
log("⚠️ 爱发电回调:%s 在开放接口里查不到(可能官方延迟/伪造),没发码" % oid_af)
led[oid_af] = {"ts": now().isoformat(timespec="seconds"), "code": None,
"amount": order.get("show_amount") or order.get("total_amount"),
"note": "接口没查到,待人工核对", "need_human": True}
jsave(PAYPLATFORM_LEDGER, led)
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}
jsave(PAYPLATFORM_LEDGER, 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
jsave(PAYPLATFORM_LEDGER, 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}
jsave(PAYPLATFORM_LEDGER, 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] # 不限模板、只限张数(金钻口径)
try:
os.chmod(CODES_FILE, 0o640)
except OSError:
pass
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
jsave(PAYPLATFORM_LEDGER, 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("爱发电订单号看着不对(在爱发电「我的订单」里能复制到,一长串数字)")
led = jload(PAYPLATFORM_LEDGER, {}) or {}
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:
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)
jsave(PAYPLATFORM_LEDGER, 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)")
rec = (load_codes() or {}).get(code)
if not rec:
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)))
burn_codes([code], oid) # 绑码(= 激活,不是核销)
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("这一单已经用过一次免费重渲了。还不行的话进官方群找金钻,他看着办。")
files = [str(x)[:60] for x in (d.get("files") or [])][:12]
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("这张皮肤不属于这一单")
try:
raw = base64.b64decode(new_skin.split(",", 1)[-1])
except Exception:
return self.err("新皮肤数据不合法")
if not raw or len(raw) > MAX_BODY:
return self.err("新皮肤太大或为空")
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"])
if not redo_tpls and files:
# 勾的图找不到模板(老单缺 tpl 字段)→ 退回整单,别让玩家点了没反应
redo_tpls = []
m["redo_tpls"] = redo_tpls
# 没换皮肤、只重渲一部分 → **保留**其它成品(claim 里清了就再也找不回来了)
if files and 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" % (
("(只重出 %d 张:%s)" % (len(files), "、".join(files))
if (files and 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/,并且走「呼叫金钻」同一套通知。"""
d = self.body_json() or {}
ip = self.headers.get("X-Real-IP") or self.client_address[0]
note = str(d.get("note") or "").strip()[:1500]
if not note and not d.get("image"):
return self.err("总得写点什么,或者传张图")
try:
os.makedirs(FEEDBACK_DIR, exist_ok=True)
except OSError:
return self.err("服务器忙,稍后再试", 503)
fid = now().strftime("%Y%m%d-%H%M%S") + "-" + "".join(
random.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""
if raw and len(raw) <= 4 * 1024 * 1024:
fn = "%s.png" % fid
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)
# 走「呼叫金钻」同一套通知:他手机能收到
try:
with open(CALLS_FILE, "a", encoding="utf-8") as f:
f.write(json.dumps({"ts": rec["ts"], "ip": ip, "order": rec["order"],
"notified": False, "kind": "反馈",
"note": (note or "(只传了图)")[:120]}, ensure_ascii=False) + "\n")
except OSError:
pass
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]
return self.js({"ok": True, "list": [coupon_status(c) 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)
with open(path, "rb") as f:
data = f.read()
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:成品/预览是同名覆盖的,重渲后绝不能让浏览器拿缓存里的旧图
if (q.get("p") or [""])[0] == "1":
self._send(200, data, ctype, {"Cache-Control": "no-store"}) # 预览内联显示,不强制下载
else:
self._send(200, data, ctype, {"Content-Disposition": disp, "Cache-Control": "no-store"})
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)
with open(path, "rb") as f:
data = f.read()
self._send(200, data, "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)
jsave(HB_IPS_FILE, {"ips": HOME_IPS})
with LOCK:
status_cache_clear()
jsave(HB_FILE, {"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"] = []
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-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})
def finish(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]
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)
total = int(d.get("total") 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 预览
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 次
try:
recent = [json.loads(l) for l in open(CALLS_FILE, encoding="utf-8") if l.strip()]
except OSError:
recent = []
n = sum(1 for r in recent[-50:] if r.get("ip") == ip
and (nowt - datetime.fromisoformat(r["ts"])).total_seconds() < 600)
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}
with open(CALLS_FILE, "a", encoding="utf-8") as f:
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
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)
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 记事本打开中文才不乱码。
with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED, compresslevel=1) as z:
z.writestr("小票.txt", receipt_text(oid, m).encode("utf-8-sig"))
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()
out = []
for c, r in load_codes().items():
st = code_state(r)
if want and st != want:
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_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)