release / release (release) Canceled after 0s
- new EpayClient: V1 md5 signing, submit.php page pay, api.php order query - create/verify epay payment links with CNY exchange-rate conversion - signed async notify handler (/admin/payment/callback_epay) with amount check plus idempotent crediting, and a gateway query fallback - epay channel config form, channel row and payment_method enum extended - RechargeModal: send payment_method (was payment_channel, so every recharge fell through to Stripe and 500'd) and re-enable the channel picker - payment config encryption key moved to a local .env, never committed
165 lines
7.0 KiB
Python
165 lines
7.0 KiB
Python
from fastapi import APIRouter, Depends, Request
|
|
from fastapi.responses import PlainTextResponse
|
|
from sqlalchemy.orm import Session
|
|
from pydantic import BaseModel
|
|
from urllib.parse import parse_qsl
|
|
|
|
from services.common.database import get_db
|
|
from services.common.utils.response_utils import ResponseUtils
|
|
from services.admin_service.services.payment_service import PaymentService
|
|
from services.admin_service.services.user_wallet_history_service import UserWalletHistoryService
|
|
from services.admin_service.tasks.order_monitor_task import OrderMonitorTask
|
|
from services.admin_service.utils.user_utils import UserUtils
|
|
from services.common import error_msg
|
|
router = APIRouter()
|
|
|
|
|
|
def get_payment(db: Session = Depends(get_db)) -> PaymentService:
|
|
return PaymentService(db)
|
|
|
|
|
|
def get_user_wallet_history(db: Session = Depends(get_db)) -> UserWalletHistoryService:
|
|
return UserWalletHistoryService(db)
|
|
|
|
|
|
def _request_base_url(request: Request) -> str:
|
|
"""Public base URL of this site (honours the reverse proxy headers)."""
|
|
forwarded_proto = (request.headers.get("X-Forwarded-Proto") or "").split(",")[0].strip()
|
|
scheme = forwarded_proto or request.url.scheme or "http"
|
|
host = (request.headers.get("X-Forwarded-Host") or "").split(",")[0].strip()
|
|
host = host or request.headers.get("Host") or request.url.netloc
|
|
return f"{scheme}://{host}"
|
|
|
|
|
|
class CreatePaymentLinkRequest(BaseModel):
|
|
amount: float
|
|
currency: str = "usd"
|
|
payment_method: str = "stripe"
|
|
success_url: str = ""
|
|
|
|
|
|
@router.post("/create_payment_link", response_model=dict)
|
|
def create_payment_link(
|
|
request: Request,
|
|
body: CreatePaymentLinkRequest,
|
|
payment: PaymentService = Depends(get_payment),
|
|
):
|
|
"""Create Stripe payment link for the user."""
|
|
if not UserUtils.is_normal_user(request):
|
|
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
|
|
user = request.scope.get("user")
|
|
if not user:
|
|
return ResponseUtils.error(message="User not found", code=404)
|
|
try:
|
|
match body.payment_method:
|
|
case "alipay":
|
|
payment_info = payment.create_alipay_payment_link(user_id=user.id, amount=body.amount, currency=body.currency)
|
|
if not payment_info:
|
|
return ResponseUtils.error(message="Failed to create Alipay payment link", code=500)
|
|
task = OrderMonitorTask.get_instance()
|
|
task.add_order_to_monitor(payment_id=payment_info.get("payment_id"))
|
|
case "wechat":
|
|
payment_info = payment.create_wxpay_payment_link(user_id=user.id, amount=body.amount, currency=body.currency)
|
|
if not payment_info:
|
|
return ResponseUtils.error(message="Failed to create Wechat payment link", code=500)
|
|
task = OrderMonitorTask.get_instance()
|
|
task.add_order_to_monitor(payment_id=payment_info.get("payment_id"))
|
|
case "epay":
|
|
payment_info = payment.create_epay_payment_link(
|
|
user_id=user.id,
|
|
amount=body.amount,
|
|
base_url=_request_base_url(request),
|
|
success_url=body.success_url,
|
|
currency=body.currency,
|
|
)
|
|
if not payment_info:
|
|
return ResponseUtils.error(
|
|
message="Failed to create Epay payment link (check channel config)", code=500
|
|
)
|
|
# epay is settled by the async notify; the order monitor has no
|
|
# epay client, so it is intentionally not registered here.
|
|
case _:
|
|
if not body.success_url:
|
|
return ResponseUtils.error(message="Success URL is required for Stripe payments", code=400)
|
|
payment_info = payment.create_stripe_payment_link(body.success_url, user_id=user.id, amount=body.amount, currency=body.currency)
|
|
if payment_info:
|
|
return ResponseUtils.success({"pay_url": payment_info.get("payment_link"), "payment_id": payment_info.get("payment_id")})
|
|
return ResponseUtils.error(message="Failed to create payment link", code=500)
|
|
except Exception as e:
|
|
return ResponseUtils.error(message=str(e), code=500)
|
|
|
|
@router.post("/callback_stripe", response_model = dict)
|
|
async def callback_stripe(
|
|
request: Request,
|
|
payment: PaymentService = Depends(get_payment),
|
|
):
|
|
"""Handle Stripe payment webhook callback."""
|
|
payload = (await request.body()).decode("utf-8")
|
|
sig_header = request.headers.get("Stripe-Signature") or ""
|
|
result = payment.stripe_payment_callback(payload, sig_header)
|
|
if result:
|
|
return ResponseUtils.success()
|
|
else:
|
|
return ResponseUtils.error(message="Stripe callback failed", code=500)
|
|
|
|
@router.get("/callback_epay")
|
|
@router.post("/callback_epay")
|
|
async def callback_epay(
|
|
request: Request,
|
|
payment: PaymentService = Depends(get_payment),
|
|
):
|
|
"""Handle an epay (易支付) async notify.
|
|
|
|
The gateway sends a GET query string (some forks POST form data) and
|
|
expects the literal body `success` to stop retrying.
|
|
"""
|
|
if request.method == "POST":
|
|
body = (await request.body()).decode("utf-8", "replace")
|
|
params = dict(parse_qsl(body, keep_blank_values=True))
|
|
else:
|
|
params = dict(request.query_params)
|
|
|
|
try:
|
|
ok = payment.epay_payment_callback(params)
|
|
except Exception as e: # never let an unexpected error hide the ack
|
|
from services.common.logging_config import get_logger
|
|
get_logger(__name__).error(f"Epay callback failed: {e}")
|
|
ok = False
|
|
return PlainTextResponse("success" if ok else "error", status_code=200 if ok else 500)
|
|
|
|
|
|
# @router.post("/callback_alipay", response_model=dict)
|
|
# async def callback_alipay(request: Request, payment: PaymentService = Depends(get_payment)):
|
|
# """Handle Alipay payment webhook callback."""
|
|
# payload = (await request.body()).decode("utf-8")
|
|
# result = payment.alipay_payment_callback(payload)
|
|
# if result:
|
|
# return ResponseUtils.success()
|
|
# else:
|
|
# return ResponseUtils.error(message="Alipay callback failed", code=500)
|
|
|
|
|
|
@router.get("/order_status", response_model=dict)
|
|
async def order_status(
|
|
request: Request,
|
|
payment_id: str,
|
|
payment: PaymentService = Depends(get_payment),
|
|
get_user_wallet_history: UserWalletHistoryService = Depends(get_user_wallet_history),
|
|
):
|
|
"""Check payment order completion status."""
|
|
if not UserUtils.is_normal_user(request):
|
|
return ResponseUtils.error(error_msg=error_msg.NO_PERMISSION)
|
|
if get_user_wallet_history.check_order_complete(payment_id):
|
|
return ResponseUtils.success({"status": 1})
|
|
|
|
# epay fallback: if the async notify never reached us, ask the gateway now.
|
|
try:
|
|
if payment.sync_epay_order(payment_id):
|
|
return ResponseUtils.success({"status": 1})
|
|
except Exception:
|
|
pass
|
|
|
|
if get_user_wallet_history.check_order_complete(payment_id):
|
|
return ResponseUtils.success({"status": 1})
|
|
return ResponseUtils.success({"status": 0})
|