ppanel-server/queue/logic/order/checkOrderLogic.go

package orderLogic

import (
	"context"
	"encoding/json"
	"github.com/hibiken/asynq"
	order2 "github.com/perfect-panel/ppanel-server/internal/logic/public/order"
	"github.com/perfect-panel/ppanel-server/internal/model/payment"
	"github.com/perfect-panel/ppanel-server/internal/svc"
	"github.com/perfect-panel/ppanel-server/pkg/logger"
	"github.com/perfect-panel/ppanel-server/pkg/payment/alipay"
	"github.com/perfect-panel/ppanel-server/pkg/payment/payssion"
	"github.com/perfect-panel/ppanel-server/pkg/payment/stripe"
	"github.com/perfect-panel/ppanel-server/queue/types"
	"go.uber.org/zap"
)

type CheckOrderLogic struct {
	svc *svc.ServiceContext
}

func NewCheckOrderLogic(svc *svc.ServiceContext) *CheckOrderLogic {
	return &CheckOrderLogic{
		svc: svc,
	}
}

func (l *CheckOrderLogic) ProcessTask(ctx context.Context, task *asynq.Task) error {

	orderList, err := l.svc.OrderModel.QueryPendingOrders(ctx)
	if err != nil {
		logger.Errorf("query pending orders error: %v", zap.Error(err))
		return err
	}
	logger.Infof("查到订单数据: %v", orderList)
	for _, order := range orderList {
		paymentConfig, err := l.svc.PaymentModel.FindOne(ctx, order.PaymentId)
		if err != nil {
			logger.Errorw("[CheckOrder] Find payment config failed", logger.Field("error", err.Error()), logger.Field("paymentMark", order.Method))
			continue
		}
		logger.Infof("查到配置数据[%s]: %v", order.Method, orderList)
		var flag bool
		switch order.Method {
		case order2.AlipayF2f:
			if l.queryAlipay(paymentConfig, order.TradeNo) {
				flag = true
			}
			break
		case order2.Payssion:
			logger.Infof("匹配配置类型: %v", order2.Payssion)
			if l.queryPayssion(paymentConfig, order.OrderNo) {
				flag = true
			}
			break
		case order2.StripeWeChatPay:
			if l.queryStripe(paymentConfig, order.TradeNo) {
				flag = true
			}
			break
		default:
			logger.Infow("[CheckOrder] Unsupported payment method", logger.Field("paymentMethod", order.Method))
			continue
		}
		logger.Infof("[CheckOrder] Unsupported payment method[%v]", flag)
		if flag {
			err := l.svc.OrderModel.UpdateOrderStatus(ctx, order.OrderNo, 2)
			if err != nil {
				logger.Errorf("[CheckOrder] query order status error: %v", zap.Error(err))
			}
			logger.Info("[CheckOrder] Notify status success", logger.Field("orderNo", order.TradeNo))
			payload := types.ForthwithActivateOrderPayload{
				OrderNo: order.OrderNo,
			}
			bytes, err := json.Marshal(&payload)
			if err != nil {
				logger.Error("[CheckOrder] Marshal payload failed", logger.Field("error", err.Error()))
				return err
			}
			task := asynq.NewTask(types.ForthwithActivateOrder, bytes)
			taskInfo, err := l.svc.Queue.EnqueueContext(ctx, task)
			if err != nil {
				logger.Error("[CheckOrder] Enqueue task failed", logger.Field("error", err.Error()))
				return err
			}
			logger.Info("[CheckOrder] Enqueue task success", logger.Field("taskInfo", taskInfo))
		}
	}

	return nil
}

// queryAlipay Query Alipay payment status
//
//nolint:unused
func (l *CheckOrderLogic) queryAlipay(paymentConfig *payment.Payment, TradeNo string) bool {
	config := payment.AlipayF2FConfig{}
	if err := json.Unmarshal([]byte(paymentConfig.Config), &config); err != nil {
		zap.S().Errorw("[CheckOrder] Unmarshal payment config failed", logger.Field("error", err.Error()), logger.Field("config", paymentConfig.Config))
		return false
	}
	client := alipay.NewClient(alipay.Config{
		AppId:       config.AppId,
		PrivateKey:  config.PrivateKey,
		PublicKey:   config.PublicKey,
		InvoiceName: config.InvoiceName,
	})
	status, err := client.QueryTrade(context.Background(), TradeNo)
	if err != nil {
		zap.S().Errorw("[CheckOrder] Query trade failed", logger.Field("error", err.Error()), logger.Field("TradeNo", TradeNo))
		return false
	}
	if status == alipay.Success || status == alipay.Finished {
		return true
	}
	return false
}

// queryStripe Query Stripe payment status
//
//nolint:unused
func (l *CheckOrderLogic) queryStripe(paymentConfig *payment.Payment, TradeNo string) bool {
	config := payment.StripeConfig{}
	if err := json.Unmarshal([]byte(paymentConfig.Config), &config); err != nil {
		zap.S().Errorw("[CheckOrder] Unmarshal payment config failed", logger.Field("error", err.Error()), logger.Field("config", paymentConfig.Config))
		return false
	}
	client := stripe.NewClient(stripe.Config{
		PublicKey:     config.PublicKey,
		SecretKey:     config.SecretKey,
		WebhookSecret: config.WebhookSecret,
	})
	status, err := client.QueryOrderStatus(TradeNo)
	if err != nil {
		zap.S().Errorw("[CheckOrder] Query order status failed", logger.Field("error", err.Error()), logger.Field("TradeNo", TradeNo))
		return false
	}
	return status
}

// queryPayssion Query Stripe payment status
//
//nolint:unused
func (l *CheckOrderLogic) queryPayssion(paymentConfig *payment.Payment, TradeNo string) bool {
	zap.S().Infof("[CheckOrder]1 Query Payssion called")
	payssionConfig := payment.PayssionConfig{}
	if err := json.Unmarshal([]byte(paymentConfig.Config), &payssionConfig); err != nil {
		zap.S().Errorw("[CheckOrder] Unmarshal error", logger.Field("error", err.Error()))
		return false
	}
	zap.S().Infof("[CheckOrder]2 Query Payssion called")
	client := payssion.NewClient(payssionConfig.ApiKey, payssionConfig.SecretKey, payssionConfig.PmId, payssionConfig.Currency, payssionConfig.QueryUrl, payssionConfig.CreateUrl)
	// create payment
	result, err := client.QueryOrder(TradeNo)
	if err != nil {
		zap.S().Errorw("[CheckOrder] Query order status failed", logger.Field("error", err.Error()), logger.Field("TradeNo", TradeNo))
		return false
	}
	zap.S().Infof("[CheckOrder]3 Query Payssion called")
	return result.Transaction.State == "completed"
}