275 lines
9.1 KiB
Python
275 lines
9.1 KiB
Python
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
from .settings import get_settings
|
|
|
|
|
|
def _md5(value: str) -> str:
|
|
return hashlib.md5(value.encode("utf-8")).hexdigest().lower()
|
|
|
|
|
|
def _is_internal_ip(ip: str | None) -> bool:
|
|
if not ip:
|
|
return True
|
|
value = ip.strip().lower()
|
|
if value in {"127.0.0.1", "localhost", "::1"}:
|
|
return True
|
|
if value.startswith("10.") or value.startswith("192.168."):
|
|
return True
|
|
if value.startswith("172."):
|
|
parts = value.split(".")
|
|
if len(parts) > 1 and parts[1].isdigit():
|
|
return 16 <= int(parts[1]) <= 31
|
|
return False
|
|
|
|
|
|
def resolve_channel(channel: str | None) -> str:
|
|
return "wxpay" if str(channel or "").lower() in {"", "wx", "wechat", "wxpay"} else "alipay"
|
|
|
|
|
|
class ZPayProvider:
|
|
name = "zpay"
|
|
|
|
def __init__(self) -> None:
|
|
settings = get_settings()
|
|
self.pid = settings.zpay_pid
|
|
self.key = settings.zpay_key
|
|
self.submit_url = settings.zpay_submit_url
|
|
self.mapi_url = settings.zpay_mapi_url
|
|
self.query_url = settings.zpay_query_url
|
|
|
|
def sign(self, params: dict[str, Any]) -> str:
|
|
filtered = {
|
|
key: value
|
|
for key, value in params.items()
|
|
if key not in {"sign", "sign_type"} and value is not None and str(value) != ""
|
|
}
|
|
raw = "&".join(f"{key}={filtered[key]}" for key in sorted(filtered)) + self.key
|
|
return _md5(raw)
|
|
|
|
def create_order(
|
|
self,
|
|
*,
|
|
order_id: str,
|
|
name: str,
|
|
amount_yuan: str,
|
|
channel: str,
|
|
notify_url: str,
|
|
return_url: str,
|
|
client_ip: str = "",
|
|
) -> dict[str, Any]:
|
|
params: dict[str, Any] = {
|
|
"pid": self.pid,
|
|
"type": resolve_channel(channel),
|
|
"out_trade_no": order_id,
|
|
"notify_url": notify_url,
|
|
"return_url": return_url,
|
|
"name": name,
|
|
"money": amount_yuan,
|
|
"sign_type": "MD5",
|
|
}
|
|
if client_ip and not _is_internal_ip(client_ip):
|
|
params["clientip"] = client_ip
|
|
params["sign"] = self.sign(params)
|
|
return {
|
|
"status": "ok",
|
|
"provider": self.name,
|
|
"params": params,
|
|
"pay_url": self.submit_url,
|
|
"submit_method": "POST",
|
|
}
|
|
|
|
async def create_order_api(
|
|
self,
|
|
*,
|
|
order_id: str,
|
|
name: str,
|
|
amount_yuan: str,
|
|
channel: str,
|
|
notify_url: str,
|
|
return_url: str,
|
|
client_ip: str = "",
|
|
device: str = "pc",
|
|
) -> dict[str, Any]:
|
|
params: dict[str, Any] = {
|
|
"pid": self.pid,
|
|
"type": resolve_channel(channel),
|
|
"out_trade_no": order_id,
|
|
"notify_url": notify_url,
|
|
"return_url": return_url,
|
|
"name": name,
|
|
"money": amount_yuan,
|
|
"device": device,
|
|
"sign_type": "MD5",
|
|
}
|
|
if client_ip and not _is_internal_ip(client_ip):
|
|
params["clientip"] = client_ip
|
|
params["sign"] = self.sign(params)
|
|
|
|
try:
|
|
async with httpx.AsyncClient(timeout=15.0, trust_env=False) as client:
|
|
res = await client.post(self.mapi_url, data=params)
|
|
except Exception as exc:
|
|
return {"status": "error", "provider": self.name, "msg": str(exc)}
|
|
|
|
result: Any
|
|
try:
|
|
result = res.json()
|
|
except Exception:
|
|
result = {}
|
|
if isinstance(result, str):
|
|
try:
|
|
result = json.loads(result)
|
|
except Exception:
|
|
result = {}
|
|
if not isinstance(result, dict):
|
|
result = {}
|
|
msg = result.get("msg")
|
|
if isinstance(msg, str) and msg.strip().startswith("{"):
|
|
try:
|
|
inner = json.loads(msg)
|
|
if isinstance(inner, dict):
|
|
result = inner
|
|
except Exception:
|
|
pass
|
|
try:
|
|
code = int(float(result.get("code", 0)))
|
|
except (TypeError, ValueError):
|
|
code = 0
|
|
if code == 1:
|
|
return {
|
|
"status": "ok",
|
|
"provider": self.name,
|
|
"payurl": result.get("payurl"),
|
|
"payurl2": result.get("payurl2"),
|
|
"qrcode": result.get("qrcode"),
|
|
"img": result.get("img"),
|
|
"trade_no": result.get("trade_no"),
|
|
}
|
|
return {"status": "error", "provider": self.name, "msg": result.get("msg") or res.text[:500]}
|
|
|
|
def verify_notify(self, data: dict[str, Any]) -> bool:
|
|
return self.sign(data) == str(data.get("sign", ""))
|
|
|
|
def parse_notify(self, data: dict[str, Any]) -> dict[str, Any]:
|
|
return {
|
|
"order_id": str(data.get("out_trade_no", "")),
|
|
"trade_no": str(data.get("trade_no", "")),
|
|
"pay_price": str(data.get("money", "")),
|
|
"trade_status": "success" if data.get("trade_status") == "TRADE_SUCCESS" else "pending",
|
|
}
|
|
|
|
async def query_order_status(self, order_id: str, timeout: float = 8.0) -> dict[str, Any]:
|
|
try:
|
|
async with httpx.AsyncClient(timeout=timeout, trust_env=False) as client:
|
|
res = await client.get(
|
|
self.query_url,
|
|
params={
|
|
"act": "order",
|
|
"pid": self.pid,
|
|
"key": self.key,
|
|
"out_trade_no": order_id,
|
|
},
|
|
)
|
|
data = res.json() if res.is_success else {}
|
|
except Exception as exc:
|
|
return {"paid": False, "error": str(exc)}
|
|
try:
|
|
code = int(float(data.get("code", 0)))
|
|
status = int(float(data.get("status", 0)))
|
|
except (TypeError, ValueError):
|
|
return {"paid": False, "msg": data.get("msg", "查询失败")}
|
|
pay_price = data.get("money") or data.get("pay_price") or ""
|
|
return {"paid": code == 1 and status == 1, "status": status, "pay_price": str(pay_price)}
|
|
|
|
def success_response(self) -> str:
|
|
return "success"
|
|
|
|
|
|
class XorPayProvider:
|
|
name = "xorpay"
|
|
|
|
def __init__(self) -> None:
|
|
settings = get_settings()
|
|
self.aid = settings.xorpay_aid
|
|
self.secret = settings.xorpay_secret
|
|
self.cashier_url = settings.xorpay_cashier_url.rstrip("/")
|
|
self.query_url = settings.xorpay_query_url.rstrip("/")
|
|
|
|
def create_order(
|
|
self,
|
|
*,
|
|
order_id: str,
|
|
name: str,
|
|
amount_yuan: str,
|
|
notify_url: str,
|
|
) -> dict[str, Any]:
|
|
params = {
|
|
"name": name,
|
|
"pay_type": "jsapi",
|
|
"price": amount_yuan,
|
|
"order_id": order_id,
|
|
"notify_url": notify_url,
|
|
}
|
|
params["sign"] = _md5(
|
|
params["name"] + params["pay_type"] + params["price"] + params["order_id"] + params["notify_url"] + self.secret
|
|
)
|
|
return {"status": "ok", "provider": self.name, "params": params, "pay_url": f"{self.cashier_url}/{self.aid}"}
|
|
|
|
def verify_notify(self, data: dict[str, Any]) -> bool:
|
|
raw = (
|
|
str(data.get("aoid", ""))
|
|
+ str(data.get("order_id", ""))
|
|
+ str(data.get("pay_price", ""))
|
|
+ str(data.get("pay_time", ""))
|
|
+ self.secret
|
|
)
|
|
return _md5(raw) == str(data.get("sign", ""))
|
|
|
|
def parse_notify(self, data: dict[str, Any]) -> dict[str, Any]:
|
|
pay_price = str(data.get("pay_price", "")).strip()
|
|
try:
|
|
paid = float(pay_price) > 0
|
|
except (TypeError, ValueError):
|
|
paid = False
|
|
return {
|
|
"order_id": str(data.get("order_id", "")),
|
|
"trade_no": str(data.get("aoid", "")),
|
|
"pay_price": pay_price,
|
|
"trade_status": "success" if paid else "pending",
|
|
}
|
|
|
|
async def query_order_status(self, order_id: str, timeout: float = 8.0) -> dict[str, Any]:
|
|
sign = _md5(order_id + self.secret)
|
|
try:
|
|
async with httpx.AsyncClient(timeout=timeout, trust_env=False) as client:
|
|
res = await client.get(f"{self.query_url}/{self.aid}", params={"order_id": order_id, "sign": sign})
|
|
data = res.json() if res.is_success else {}
|
|
status = str(data.get("status", "")).lower()
|
|
return {
|
|
"paid": status in {"payed", "success"},
|
|
"status": status,
|
|
"pay_price": data.get("pay_price") or data.get("price") or "",
|
|
}
|
|
except Exception as exc:
|
|
return {"paid": False, "error": str(exc)}
|
|
|
|
def success_response(self) -> str:
|
|
return "ok"
|
|
|
|
|
|
def provider_for(device: str = "pc", requested: str = "", user_agent: str = "") -> ZPayProvider | XorPayProvider:
|
|
req = requested.strip().lower()
|
|
if req == "xorpay":
|
|
return XorPayProvider()
|
|
if req == "zpay":
|
|
return ZPayProvider()
|
|
if device.lower() == "wechat" or "micromessenger" in user_agent.lower():
|
|
return XorPayProvider()
|
|
return ZPayProvider()
|