527 lines
17 KiB
Go
527 lines
17 KiB
Go
package payment
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"time"
|
|
|
|
"hfb_sys/backend/internal/model"
|
|
"hfb_sys/backend/internal/modules/rentergrowth"
|
|
|
|
"go.uber.org/zap"
|
|
"gorm.io/datatypes"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
)
|
|
|
|
func (r *Repository) StartRefund(ctx context.Context, orderID uint64, refundAmountCent int64, bizType string, remark string) (*RefundDTO, error) {
|
|
originalPayment, err := r.findOriginalPayment(ctx, orderID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
runtimeConfig, err := r.runtimeConfigForPayment(ctx, &originalPayment)
|
|
if err != nil {
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
|
|
refundOrder, existing, err := r.prepareRefundOrder(ctx, originalPayment, *runtimeConfig, refundAmountCent, bizType)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if existing {
|
|
latest, syncErr := r.syncRefundPayment(ctx, refundOrder, refundOrder.Status != "refunded")
|
|
if syncErr != nil {
|
|
r.log().Warn("payment existing refund sync failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
[]zap.Field{zap.String("biz_type", bizType), zap.Error(syncErr)},
|
|
)...,
|
|
)...)
|
|
dto := toRefundDTO(*refundOrder)
|
|
return &dto, nil
|
|
}
|
|
dto := toRefundDTO(*latest)
|
|
return &dto, nil
|
|
}
|
|
|
|
if runtimeConfig.isMockMode() {
|
|
raw := map[string]string{"mock": "true"}
|
|
if remark != "" {
|
|
raw["remark"] = remark
|
|
}
|
|
if err := r.applyRefundChannelStatus(ctx, refundOrder, refundChannelStatusUpdate{
|
|
Status: "refunded",
|
|
ProviderRefundID: "MOCKREF" + refundOrder.ThirdOrderID,
|
|
Raw: raw,
|
|
Source: channelSourceMock,
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
latest, err := r.findPaymentByID(ctx, refundOrder.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
r.recordConfigUsage(ctx, runtimeConfig, latest)
|
|
dto := toRefundDTO(*latest)
|
|
return &dto, nil
|
|
}
|
|
|
|
r.log().Info("payment refund start", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
runtimeConfigFields(runtimeConfig),
|
|
[]zap.Field{
|
|
zap.String("merchant_refund_id", refundOrder.ThirdOrderID),
|
|
zap.String("origin_third_order_id", originalPayment.ThirdOrderID),
|
|
zap.String("origin_provider_order_id", refundOriginProviderOrderID(originalPayment)),
|
|
},
|
|
)...,
|
|
)...)
|
|
r.recordConfigUsage(ctx, runtimeConfig, refundOrder)
|
|
if err := r.markOrderRefunding(ctx, orderID, refundAmountCent); err != nil {
|
|
r.log().Warn("payment mark order refunding failed", paymentLogFields(ctx,
|
|
zap.Uint64("order_id", orderID),
|
|
zap.Int64("refund_amount_cent", refundAmountCent),
|
|
zap.Error(err),
|
|
)...)
|
|
}
|
|
|
|
if runtimeConfig.Channel == nil {
|
|
if err := r.markRefundFailed(ctx, refundOrder.ID, orderID, refundAmountCent, map[string]string{"error": "payment channel unavailable"}, nil); err != nil {
|
|
r.log().Warn("payment mark refund failed status failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
[]zap.Field{zap.Error(err)},
|
|
)...,
|
|
)...)
|
|
}
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
resp, err := runtimeConfig.Channel.CreateRefund(ctx, channelCreateRefundRequest{
|
|
ThirdOrderID: originalPayment.ThirdOrderID,
|
|
ProviderOrderID: refundOriginProviderOrderID(originalPayment),
|
|
MerchantRefundID: refundOrder.ThirdOrderID,
|
|
RefundAmountCent: refundAmountCent,
|
|
NotifyURL: runtimeConfig.NotifyURL,
|
|
Attach: originalPayment.OrderNo,
|
|
Remark: remark,
|
|
})
|
|
if err != nil {
|
|
var rawRequest map[string]string
|
|
if resp != nil {
|
|
rawRequest = resp.RawRequest
|
|
}
|
|
if markErr := r.markRefundFailed(ctx, refundOrder.ID, orderID, refundAmountCent, map[string]string{"error": err.Error()}, rawRequest); markErr != nil {
|
|
r.log().Warn("payment mark refund failed status failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
[]zap.Field{zap.Error(markErr)},
|
|
)...,
|
|
)...)
|
|
}
|
|
r.log().Warn("payment refund request failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
runtimeConfigFields(runtimeConfig),
|
|
[]zap.Field{zap.Error(err)},
|
|
)...,
|
|
)...)
|
|
return nil, err
|
|
}
|
|
if !resp.OK {
|
|
if markErr := r.markRefundFailed(ctx, refundOrder.ID, orderID, refundAmountCent, resp.Raw, resp.RawRequest); markErr != nil {
|
|
r.log().Warn("payment mark refund rejected status failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
[]zap.Field{zap.Error(markErr)},
|
|
)...,
|
|
)...)
|
|
}
|
|
r.log().Warn("payment refund rejected", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
runtimeConfigFields(runtimeConfig),
|
|
[]zap.Field{
|
|
zap.String("channel_code", firstNonEmpty(resp.Raw["code"], resp.Raw["resp_code"], resp.Raw["result_code"])),
|
|
zap.String("channel_message", resp.ErrorMessage),
|
|
zap.Strings("raw_response_keys", stringMapKeys(resp.Raw)),
|
|
},
|
|
)...,
|
|
)...)
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
|
|
if err := r.applyRefundChannelStatus(ctx, refundOrder, refundChannelStatusUpdate{
|
|
Status: resp.Status,
|
|
ProviderRefundID: resp.ProviderRefundID,
|
|
RawRequest: resp.RawRequest,
|
|
Raw: resp.Raw,
|
|
Source: channelSourceCreate,
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
r.log().Info("payment refund result", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(refundOrder),
|
|
runtimeConfigFields(runtimeConfig),
|
|
[]zap.Field{
|
|
zap.String("refund_status", resp.Status),
|
|
zap.String("provider_refund_id", resp.ProviderRefundID),
|
|
},
|
|
)...,
|
|
)...)
|
|
|
|
latest, err := r.findPaymentByID(ctx, refundOrder.ID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
dto := toRefundDTO(*latest)
|
|
return &dto, nil
|
|
}
|
|
func (r *Repository) QueryRefundStatus(ctx context.Context, orderID uint64) (*RefundDTO, error) {
|
|
var payment model.PaymentOrder
|
|
if err := r.db.WithContext(ctx).Where("order_id = ? AND biz_type IN ?", orderID, refundBizTypes).Order("id DESC").First(&payment).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, ErrPaymentNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
latest, err := r.syncRefundPayment(ctx, &payment, payment.Status == "failed")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
dto := toRefundDTO(*latest)
|
|
return &dto, nil
|
|
}
|
|
func (r *Repository) SyncRefundStatusByPaymentID(ctx context.Context, paymentID uint64) (*RefundDTO, error) {
|
|
payment, err := r.findPaymentByID(ctx, paymentID)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, ErrPaymentNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
if !isRefundBizType(payment.BizType) {
|
|
return nil, ErrPaymentNotFound
|
|
}
|
|
latest, err := r.syncRefundPayment(ctx, payment, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
dto := toRefundDTO(*latest)
|
|
return &dto, nil
|
|
}
|
|
func (r *Repository) findOriginalPayment(ctx context.Context, orderID uint64) (model.PaymentOrder, error) {
|
|
var originalPayment model.PaymentOrder
|
|
if err := r.db.WithContext(ctx).Where("order_id = ? AND status = 'paid' AND biz_type = 'order_pay'", orderID).Order("id DESC").First(&originalPayment).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return originalPayment, ErrPaymentNotFound
|
|
}
|
|
return originalPayment, err
|
|
}
|
|
return originalPayment, nil
|
|
}
|
|
|
|
// prepareRefundOrder 创建退款支付单，并继承原支付单回溯出的支付配置。
|
|
func (r *Repository) prepareRefundOrder(ctx context.Context, originalPayment model.PaymentOrder, runtimeConfig runtimePaymentConfig, refundAmountCent int64, bizType string) (*model.PaymentOrder, bool, error) {
|
|
var paymentID uint64
|
|
existing := false
|
|
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var order model.RentalOrder
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, originalPayment.OrderID).Error; err != nil {
|
|
return err
|
|
}
|
|
var existingRefund model.PaymentOrder
|
|
err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
|
Where("order_id = ? AND biz_type = ?", originalPayment.OrderID, bizType).
|
|
Order("id DESC").
|
|
First(&existingRefund).Error
|
|
if err == nil {
|
|
paymentID = existingRefund.ID
|
|
existing = true
|
|
return nil
|
|
}
|
|
if err != gorm.ErrRecordNotFound {
|
|
return err
|
|
}
|
|
paymentNo, err := newPaymentNo()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
merchantRefundID := "REF" + paymentNo[3:]
|
|
refundOrder := model.PaymentOrder{
|
|
PaymentNo: paymentNo,
|
|
OrderID: originalPayment.OrderID,
|
|
OrderNo: originalPayment.OrderNo,
|
|
UserID: originalPayment.UserID,
|
|
PaymentConfigID: runtimeConfig.ID,
|
|
Provider: runtimeConfig.Provider,
|
|
MerchantID: runtimeConfig.MerchantID,
|
|
ThirdOrderID: merchantRefundID,
|
|
ProviderOrderID: "",
|
|
PayWay: originalPayment.PayWay,
|
|
JSPayFlag: originalPayment.JSPayFlag,
|
|
AmountCent: refundAmountCent,
|
|
BizType: bizType,
|
|
Status: "refunding",
|
|
}
|
|
if err := tx.Create(&refundOrder).Error; err != nil {
|
|
return err
|
|
}
|
|
paymentID = refundOrder.ID
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
payment, err := r.findPaymentByID(ctx, paymentID)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
return payment, existing, nil
|
|
}
|
|
func (r *Repository) syncRefundPayment(ctx context.Context, payment *model.PaymentOrder, queryTerminal bool) (*model.PaymentOrder, error) {
|
|
if payment.Status == "refunded" && !queryTerminal {
|
|
if err := r.updateOrderRefundStatus(ctx, payment.OrderID, payment.AmountCent, payment.BizType); err != nil {
|
|
return nil, err
|
|
}
|
|
return payment, nil
|
|
}
|
|
if payment.Status == "failed" && !queryTerminal {
|
|
if err := r.markOrderRefundFailed(ctx, payment.OrderID, payment.AmountCent); err != nil {
|
|
return nil, err
|
|
}
|
|
return payment, nil
|
|
}
|
|
runtimeConfig, err := r.runtimeConfigForPayment(ctx, payment)
|
|
if err != nil {
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
if runtimeConfig.isMockMode() {
|
|
if payment.Status == "refunded" {
|
|
if err := r.updateOrderRefundStatus(ctx, payment.OrderID, payment.AmountCent, payment.BizType); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return payment, nil
|
|
}
|
|
if runtimeConfig.Channel == nil {
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
originalPayment, err := r.findOriginalPayment(ctx, payment.OrderID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := runtimeConfig.Channel.QueryRefund(ctx, refundQueryRequest(*payment, originalPayment))
|
|
if err != nil {
|
|
if resp != nil && resp.RawRequest != nil {
|
|
if updateErr := r.updateRefundRawRequest(ctx, payment.ID, resp.RawRequest); updateErr != nil {
|
|
r.log().Warn("payment refund query raw request update failed", paymentLogFields(ctx, appendFields(
|
|
paymentOrderFields(payment),
|
|
[]zap.Field{zap.Error(updateErr)},
|
|
)...,
|
|
)...)
|
|
}
|
|
}
|
|
return nil, err
|
|
}
|
|
if !resp.OK {
|
|
return nil, ErrPaymentUnavailable
|
|
}
|
|
if err := r.applyRefundChannelStatus(ctx, payment, refundChannelStatusUpdate{
|
|
Status: resp.Status,
|
|
ProviderRefundID: resp.ProviderRefundID,
|
|
RefundTime: resp.RefundTime,
|
|
Raw: resp.Raw,
|
|
Source: channelSourceQuery,
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
return r.findPaymentByID(ctx, payment.ID)
|
|
}
|
|
|
|
type refundChannelStatusUpdate struct {
|
|
Status string
|
|
ProviderRefundID string
|
|
RefundTime string
|
|
RawRequest map[string]string
|
|
Raw map[string]string
|
|
Source string
|
|
}
|
|
|
|
func (r *Repository) applyRefundChannelStatus(ctx context.Context, payment *model.PaymentOrder, update refundChannelStatusUpdate) error {
|
|
status := update.Status
|
|
if status != "refunded" && status != "failed" {
|
|
status = "refunding"
|
|
}
|
|
updates := map[string]any{
|
|
"status": status,
|
|
"raw_response": jsonMap(withRawSource(update.Raw, update.Source)),
|
|
}
|
|
if update.ProviderRefundID != "" {
|
|
updates["provider_order_id"] = update.ProviderRefundID
|
|
}
|
|
if update.RawRequest != nil {
|
|
updates["raw_request"] = jsonMap(update.RawRequest)
|
|
}
|
|
if status == "refunded" {
|
|
paidAt := parseChannelTime(update.RefundTime)
|
|
if paidAt == nil {
|
|
now := time.Now()
|
|
paidAt = &now
|
|
}
|
|
updates["paid_at"] = paidAt
|
|
}
|
|
if update.Source == channelSourceNotify {
|
|
updates["notified_at"] = time.Now()
|
|
}
|
|
if err := r.db.WithContext(ctx).Model(&model.PaymentOrder{}).Where("id = ?", payment.ID).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
switch status {
|
|
case "refunded":
|
|
return r.updateOrderRefundStatus(ctx, payment.OrderID, payment.AmountCent, payment.BizType)
|
|
case "failed":
|
|
return r.markOrderRefundFailed(ctx, payment.OrderID, payment.AmountCent)
|
|
default:
|
|
return r.markOrderRefunding(ctx, payment.OrderID, payment.AmountCent)
|
|
}
|
|
}
|
|
func isRefundBizType(bizType string) bool {
|
|
for _, item := range refundBizTypes {
|
|
if item == bizType {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
func refundQueryRequest(payment model.PaymentOrder, originalPayment model.PaymentOrder) channelQueryRefundRequest {
|
|
return channelQueryRefundRequest{
|
|
ThirdOrderID: originalPayment.ThirdOrderID,
|
|
ProviderOrderID: refundOriginProviderOrderID(originalPayment),
|
|
MerchantRefundID: payment.ThirdOrderID,
|
|
ProviderRefundID: payment.ProviderOrderID,
|
|
}
|
|
}
|
|
func (r *Repository) updateOrderRefundStatus(ctx context.Context, orderID uint64, refundAmountCent int64, bizType string) error {
|
|
return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var order model.RentalOrder
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
|
|
return err
|
|
}
|
|
now := time.Now()
|
|
order.RefundStatus = "refunded"
|
|
order.RefundAmountCent = refundAmountCent
|
|
order.RefundedAt = &now
|
|
if bizType == "admin_refund" && order.Status == "completed" && refundAmountCent >= order.RentAmountCent+order.DepositAmountCent {
|
|
if err := rentergrowth.RevokeOrderCompleted(tx, &order); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return tx.Save(&order).Error
|
|
})
|
|
}
|
|
func (r *Repository) markOrderRefunding(ctx context.Context, orderID uint64, refundAmountCent int64) error {
|
|
return r.db.WithContext(ctx).Model(&model.RentalOrder{}).Where("id = ?", orderID).Updates(map[string]any{
|
|
"refund_status": "refunding",
|
|
"refund_amount_cent": refundAmountCent,
|
|
"refunded_at": nil,
|
|
}).Error
|
|
}
|
|
func (r *Repository) markOrderRefundFailed(ctx context.Context, orderID uint64, refundAmountCent int64) error {
|
|
return r.db.WithContext(ctx).Model(&model.RentalOrder{}).Where("id = ?", orderID).Updates(map[string]any{
|
|
"refund_status": "failed",
|
|
"refund_amount_cent": refundAmountCent,
|
|
"refunded_at": nil,
|
|
}).Error
|
|
}
|
|
func (r *Repository) updateRefundRawRequest(ctx context.Context, paymentID uint64, rawRequest map[string]string) error {
|
|
if rawRequest == nil {
|
|
return nil
|
|
}
|
|
return r.db.WithContext(ctx).Model(&model.PaymentOrder{}).Where("id = ?", paymentID).Update("raw_request", jsonMap(rawRequest)).Error
|
|
}
|
|
func (r *Repository) markRefundFailed(ctx context.Context, paymentID uint64, orderID uint64, refundAmountCent int64, raw map[string]string, rawRequest map[string]string) error {
|
|
if raw == nil {
|
|
raw = map[string]string{"error": "refund failed"}
|
|
}
|
|
updates := map[string]any{
|
|
"status": "failed",
|
|
"raw_response": jsonMap(raw),
|
|
}
|
|
if rawRequest != nil {
|
|
updates["raw_request"] = jsonMap(rawRequest)
|
|
}
|
|
if err := r.db.WithContext(ctx).Model(&model.PaymentOrder{}).Where("id = ?", paymentID).Updates(updates).Error; err != nil {
|
|
return err
|
|
}
|
|
return r.markOrderRefundFailed(ctx, orderID, refundAmountCent)
|
|
}
|
|
func toRefundDTO(payment model.PaymentOrder) RefundDTO {
|
|
return RefundDTO{
|
|
ID: payment.ID,
|
|
PaymentNo: payment.PaymentNo,
|
|
OrderID: payment.OrderID,
|
|
OrderNo: payment.OrderNo,
|
|
BizType: payment.BizType,
|
|
AmountCent: payment.AmountCent,
|
|
Status: payment.Status,
|
|
ProviderOrderID: payment.ProviderOrderID,
|
|
PaidAt: payment.PaidAt,
|
|
CreatedAt: payment.CreatedAt,
|
|
UpdatedAt: payment.UpdatedAt,
|
|
}
|
|
}
|
|
func refundOriginProviderOrderID(payment model.PaymentOrder) string {
|
|
if payment.Provider != "lakala" {
|
|
return payment.ProviderOrderID
|
|
}
|
|
if tradeID := lakalaOriginTradeID(payment.RawResponse); tradeID != "" {
|
|
return tradeID
|
|
}
|
|
return payment.ProviderOrderID
|
|
}
|
|
func lakalaOriginTradeID(raw datatypes.JSON) string {
|
|
if len(raw) == 0 {
|
|
return ""
|
|
}
|
|
var payload map[string]any
|
|
if err := json.Unmarshal(raw, &payload); err != nil {
|
|
return ""
|
|
}
|
|
if tradeID := firstStringValue(payload, "trade_no", "origin_trade_no"); tradeID != "" {
|
|
return tradeID
|
|
}
|
|
value, ok := payload["order_trade_info_list"]
|
|
if !ok {
|
|
return ""
|
|
}
|
|
switch typed := value.(type) {
|
|
case string:
|
|
var items []map[string]any
|
|
if err := json.Unmarshal([]byte(typed), &items); err != nil {
|
|
return ""
|
|
}
|
|
for _, item := range items {
|
|
if tradeID := firstStringValue(item, "trade_no", "origin_trade_no"); tradeID != "" {
|
|
return tradeID
|
|
}
|
|
}
|
|
case []any:
|
|
for _, item := range typed {
|
|
itemMap, ok := item.(map[string]any)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if tradeID := firstStringValue(itemMap, "trade_no", "origin_trade_no"); tradeID != "" {
|
|
return tradeID
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
func firstStringValue(values map[string]any, keys ...string) string {
|
|
for _, key := range keys {
|
|
value, ok := values[key]
|
|
if !ok {
|
|
continue
|
|
}
|
|
if text, ok := value.(string); ok && text != "" {
|
|
return text
|
|
}
|
|
}
|
|
return ""
|
|
}
|