332 lines
12 KiB
Go
332 lines
12 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"regexp"
|
|
"time"
|
|
|
|
"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/payments"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
)
|
|
|
|
const paymentOrderColumns = `id, organization_id, account_id, request_key, mch_id, app_id,
|
|
amount_fen, currency, status, COALESCE(code_url, ''), COALESCE(transaction_id, ''),
|
|
created_at, updated_at, expires_at, paid_at`
|
|
|
|
const createPaymentOrderSQL = `INSERT INTO public.payment_orders
|
|
(id, organization_id, account_id, request_key, mch_id, app_id, amount_fen, currency, expires_at)
|
|
SELECT $1::text, organization.id, account.id, $4::text, $5::text, $6::text,
|
|
$7::bigint, $8::text, $9::timestamptz
|
|
FROM public.platform_organizations AS organization
|
|
JOIN public.platform_users AS account ON account.id = $3::text
|
|
WHERE organization.id = $2::text AND organization.status = 'active'
|
|
AND account.status = 'active' AND account.organization_id = organization.id
|
|
AND account.role IN ('organization_admin', 'super_admin')
|
|
ON CONFLICT DO NOTHING
|
|
RETURNING ` + paymentOrderColumns
|
|
|
|
const getPaymentOrderSQL = `SELECT ` + paymentOrderColumns + ` FROM public.payment_orders WHERE id = $1::text`
|
|
const getPaymentOrderByRequestSQL = `SELECT ` + paymentOrderColumns + ` FROM public.payment_orders WHERE organization_id = $1::text AND request_key = $2::text`
|
|
const listPaymentOrdersSQL = `SELECT ` + paymentOrderColumns + ` FROM public.payment_orders WHERE organization_id = $1::text ORDER BY created_at DESC, id DESC LIMIT $2::integer`
|
|
const pendingPaymentOrdersSQL = `SELECT ` + paymentOrderColumns + ` FROM public.payment_orders WHERE status = 'pending' ORDER BY updated_at ASC, created_at ASC, id ASC LIMIT $1::integer`
|
|
const updatePendingPaymentOrderSQL = `UPDATE public.payment_orders SET
|
|
code_url = CASE WHEN $2::text = '' THEN code_url ELSE $2::text END,
|
|
updated_at = now()
|
|
WHERE id = $1::text AND status = 'pending'
|
|
RETURNING ` + paymentOrderColumns
|
|
const closePaymentOrderSQL = `UPDATE public.payment_orders SET
|
|
status = 'closed', code_url = NULL, updated_at = now()
|
|
WHERE id = $1::text AND status = 'pending'
|
|
RETURNING ` + paymentOrderColumns
|
|
const lockPaymentOrderSQL = `SELECT ` + paymentOrderColumns + ` FROM public.payment_orders WHERE id = $1::text FOR UPDATE`
|
|
const paidPaymentOrderSQL = `UPDATE public.payment_orders SET
|
|
status = 'paid', transaction_id = $2::text, code_url = NULL,
|
|
paid_at = $3::timestamptz, updated_at = now()
|
|
WHERE id = $1::text AND status IN ('pending', 'closed')
|
|
RETURNING ` + paymentOrderColumns
|
|
|
|
var paymentKeyPattern = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
|
|
|
|
func (db *Database) paymentQuerier() (Querier, error) {
|
|
if db == nil || db.config.Backend != BackendPostgres || db.querier == nil {
|
|
return nil, payments.ErrUnavailable
|
|
}
|
|
return db.querier, nil
|
|
}
|
|
|
|
func validPaymentKey(s string, maxLength int) bool {
|
|
return len(s) > 0 && len(s) <= maxLength && paymentKeyPattern.MatchString(s)
|
|
}
|
|
|
|
func (db *Database) CreatePaymentOrder(ctx context.Context, input payments.Order) (payments.Order, error) {
|
|
q, err := db.paymentQuerier()
|
|
if err != nil {
|
|
return payments.Order{}, err
|
|
}
|
|
if !validPaymentKey(input.ID, 32) || !validPaymentKey(input.RequestKey, 64) ||
|
|
input.OrganizationID == "" || input.AccountID == "" || input.MchID == "" || input.AppID == "" ||
|
|
len(input.MchID) > 64 || len(input.AppID) > 64 || input.Currency != "CNY" ||
|
|
input.ExpiresAt.IsZero() || !input.ExpiresAt.After(time.Now()) {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
if input.AmountFen < 1 || input.AmountFen > 1_000_000 {
|
|
return payments.Order{}, payments.ErrInvalidAmount
|
|
}
|
|
created, found, err := queryPaymentOrder(ctx, q, createPaymentOrderSQL,
|
|
input.ID, input.OrganizationID, input.AccountID, input.RequestKey,
|
|
input.MchID, input.AppID, input.AmountFen, input.Currency, input.ExpiresAt)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("create payment order", err)
|
|
}
|
|
if found {
|
|
return created, nil
|
|
}
|
|
previous, found, err := queryPaymentOrder(ctx, q, getPaymentOrderByRequestSQL, input.OrganizationID, input.RequestKey)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("read payment request", err)
|
|
}
|
|
if !found || previous.AccountID != input.AccountID || previous.AmountFen != input.AmountFen ||
|
|
previous.Currency != input.Currency || previous.AppID != input.AppID || previous.MchID != input.MchID {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
return previous, nil
|
|
}
|
|
|
|
func (db *Database) GetPaymentOrder(ctx context.Context, id string) (payments.Order, error) {
|
|
q, err := db.paymentQuerier()
|
|
if err != nil {
|
|
return payments.Order{}, err
|
|
}
|
|
order, found, err := queryPaymentOrder(ctx, q, getPaymentOrderSQL, id)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("get payment order", err)
|
|
}
|
|
if !found {
|
|
return payments.Order{}, payments.ErrNotFound
|
|
}
|
|
return order, nil
|
|
}
|
|
|
|
func (db *Database) ListPaymentOrders(ctx context.Context, organizationID string, limit int) ([]payments.Order, error) {
|
|
q, err := db.paymentQuerier()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if organizationID == "" {
|
|
return nil, payments.ErrConflict
|
|
}
|
|
return queryPaymentOrders(ctx, q, listPaymentOrdersSQL, organizationID, boundedPaymentLimit(limit))
|
|
}
|
|
|
|
func (db *Database) PendingPaymentOrders(ctx context.Context, limit int) ([]payments.Order, error) {
|
|
q, err := db.paymentQuerier()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return queryPaymentOrders(ctx, q, pendingPaymentOrdersSQL, boundedPaymentLimit(limit))
|
|
}
|
|
|
|
func boundedPaymentLimit(limit int) int {
|
|
if limit < 1 {
|
|
return 1
|
|
}
|
|
if limit > 500 {
|
|
return 500
|
|
}
|
|
return limit
|
|
}
|
|
|
|
func (db *Database) UpdatePaymentOrder(ctx context.Context, id, status, codeURL string) (payments.Order, error) {
|
|
q, err := db.paymentQuerier()
|
|
if err != nil {
|
|
return payments.Order{}, err
|
|
}
|
|
if id == "" || len(codeURL) > 2048 || (status != payments.StatusPending && status != payments.StatusClosed) {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
statement := closePaymentOrderSQL
|
|
args := []any{id}
|
|
if status == payments.StatusPending {
|
|
statement = updatePendingPaymentOrderSQL
|
|
args = append(args, codeURL)
|
|
}
|
|
order, found, err := queryPaymentOrder(ctx, q, statement, args...)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("update payment order", err)
|
|
}
|
|
if found {
|
|
return order, nil
|
|
}
|
|
return db.GetPaymentOrder(ctx, id)
|
|
}
|
|
|
|
func (db *Database) SettlePaymentOrder(ctx context.Context, transaction payments.Transaction) (payments.Order, error) {
|
|
if _, err := db.paymentQuerier(); err != nil || db.transactions == nil {
|
|
return payments.Order{}, payments.ErrUnavailable
|
|
}
|
|
if transaction.OrderID == "" || transaction.MchID == "" || transaction.AppID == "" ||
|
|
transaction.TransactionID == "" || transaction.TradeState != "SUCCESS" ||
|
|
transaction.Currency != "CNY" || transaction.AmountFen < 1 || transaction.AmountFen > 1_000_000 {
|
|
return payments.Order{}, payments.ErrVerification
|
|
}
|
|
tx, err := db.transactions.Begin(ctx)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("begin payment settlement", err)
|
|
}
|
|
committed := false
|
|
defer func() {
|
|
if !committed {
|
|
_ = tx.Rollback(ctx)
|
|
}
|
|
}()
|
|
order, found, err := queryPaymentOrder(ctx, tx, lockPaymentOrderSQL, transaction.OrderID)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("lock payment order", err)
|
|
}
|
|
if !found {
|
|
return payments.Order{}, payments.ErrNotFound
|
|
}
|
|
if order.MchID != transaction.MchID || order.AppID != transaction.AppID ||
|
|
order.AmountFen != transaction.AmountFen || order.Currency != transaction.Currency {
|
|
return payments.Order{}, payments.ErrVerification
|
|
}
|
|
if order.Status == payments.StatusPaid {
|
|
if order.TransactionID != transaction.TransactionID {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return payments.Order{}, paymentSQLError("commit payment replay", err)
|
|
}
|
|
committed = true
|
|
return order, nil
|
|
}
|
|
if order.Status != payments.StatusPending && order.Status != payments.StatusClosed {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
paidAt := transaction.SuccessTime
|
|
if paidAt.IsZero() {
|
|
paidAt = time.Now().UTC()
|
|
}
|
|
paid, found, err := queryPaymentOrder(ctx, tx, paidPaymentOrderSQL, order.ID, transaction.TransactionID, paidAt)
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("record payment transaction", err)
|
|
}
|
|
if !found {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
metadata, err := json.Marshal(map[string]string{
|
|
"source": "wechat_native", "paymentOrderId": order.ID,
|
|
"transactionId": transaction.TransactionID, "mchId": transaction.MchID,
|
|
"appId": transaction.AppID, "initiatedByAccountId": order.AccountID,
|
|
})
|
|
if err != nil {
|
|
return payments.Order{}, err
|
|
}
|
|
rows, err := tx.Query(ctx, PostWalletEntrySQL,
|
|
"wechat-native-entry:"+order.ID, order.OrganizationID, nil, nil,
|
|
"recharge", order.AmountFen, "CNY", "wechat-native:"+order.MchID+":"+order.ID,
|
|
"微信扫码充值", json.RawMessage(metadata))
|
|
if err != nil {
|
|
return payments.Order{}, paymentSQLError("post payment wallet credit", err)
|
|
}
|
|
if !rows.Next() {
|
|
rowErr := rows.Err()
|
|
rows.Close()
|
|
if rowErr != nil {
|
|
return payments.Order{}, paymentSQLError("read payment wallet credit", rowErr)
|
|
}
|
|
return payments.Order{}, fmt.Errorf("payment wallet credit returned no row")
|
|
}
|
|
var posting WalletEntry
|
|
if err := rows.Scan(&posting.LedgerID, &posting.BalanceAfterFen, &posting.BalanceFen,
|
|
&posting.TotalRechargedFen, &posting.TotalChargedFen, &posting.CreatedAt,
|
|
&posting.UpdatedAt, &posting.DeltaFen); err != nil {
|
|
rows.Close()
|
|
return payments.Order{}, paymentSQLError("scan payment wallet credit", err)
|
|
}
|
|
rowErr := rows.Err()
|
|
rows.Close()
|
|
if rowErr != nil {
|
|
return payments.Order{}, paymentSQLError("complete payment wallet credit", rowErr)
|
|
}
|
|
if posting.DeltaFen != order.AmountFen || posting.LedgerID != "wechat-native-entry:"+order.ID {
|
|
return payments.Order{}, payments.ErrConflict
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
// The commit result can be ambiguous. A replay with this transaction ID
|
|
// resolves it safely because paid status and wallet entry commit together.
|
|
return payments.Order{}, paymentSQLError("commit payment settlement; query or replay the order", err)
|
|
}
|
|
committed = true
|
|
return paid, nil
|
|
}
|
|
|
|
func queryPaymentOrder(ctx context.Context, q Querier, statement string, args ...any) (payments.Order, bool, error) {
|
|
rows, err := q.Query(ctx, statement, args...)
|
|
if err != nil {
|
|
return payments.Order{}, false, err
|
|
}
|
|
defer rows.Close()
|
|
if !rows.Next() {
|
|
return payments.Order{}, false, rows.Err()
|
|
}
|
|
order, err := scanPaymentOrder(rows)
|
|
if err != nil {
|
|
return payments.Order{}, false, err
|
|
}
|
|
return order, true, rows.Err()
|
|
}
|
|
|
|
func queryPaymentOrders(ctx context.Context, q Querier, statement string, args ...any) ([]payments.Order, error) {
|
|
rows, err := q.Query(ctx, statement, args...)
|
|
if err != nil {
|
|
return nil, paymentSQLError("list payment orders", err)
|
|
}
|
|
defer rows.Close()
|
|
out := make([]payments.Order, 0)
|
|
for rows.Next() {
|
|
order, err := scanPaymentOrder(rows)
|
|
if err != nil {
|
|
return nil, paymentSQLError("scan payment order", err)
|
|
}
|
|
out = append(out, order)
|
|
}
|
|
return out, paymentSQLError("read payment orders", rows.Err())
|
|
}
|
|
|
|
func scanPaymentOrder(rows Rows) (payments.Order, error) {
|
|
var order payments.Order
|
|
var paidAt sql.NullTime
|
|
err := rows.Scan(&order.ID, &order.OrganizationID, &order.AccountID, &order.RequestKey,
|
|
&order.MchID, &order.AppID, &order.AmountFen, &order.Currency, &order.Status,
|
|
&order.CodeURL, &order.TransactionID, &order.CreatedAt, &order.UpdatedAt,
|
|
&order.ExpiresAt, &paidAt)
|
|
if err != nil {
|
|
return payments.Order{}, err
|
|
}
|
|
if paidAt.Valid {
|
|
order.PaidAt = &paidAt.Time
|
|
}
|
|
if order.Status != payments.StatusPending {
|
|
order.CodeURL = ""
|
|
}
|
|
return order, nil
|
|
}
|
|
|
|
func paymentSQLError(action string, err error) error {
|
|
if err == nil {
|
|
return nil
|
|
}
|
|
var pgErr *pgconn.PgError
|
|
if errors.As(err, &pgErr) && (pgErr.Code == "23505" || pgErr.Code == "23503" || pgErr.Code == "23514") {
|
|
return fmt.Errorf("%w: %s: %v", payments.ErrConflict, action, err)
|
|
}
|
|
return fmt.Errorf("%s: %w", action, err)
|
|
}
|
|
|
|
var _ payments.Repository = (*Database)(nil)
|