voucher/internal/service/cmb.go

package service

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/transport/http"
	"github.com/robfig/cron"
	"io"
	http2 "net/http"
	"strconv"
	v1 "voucher/api/v1"
	"voucher/internal/biz"
	"voucher/internal/biz/bo"
	"voucher/internal/biz/do"
	"voucher/internal/biz/mixrepos"
	"voucher/internal/biz/vo"
	"voucher/internal/biz/wechatrepo"
	"voucher/internal/conf"
)

var _ v1.CmbHTTPServer = (*CmbService)(nil)

type CmbService struct {
	bc            *conf.Bootstrap
	cron          *cron.Cron
	VoucherBiz    *biz.VoucherBiz
	CmbMixRepo    mixrepos.CmbMixRepo
	WechatCpnRepo wechatrepo.WechatCpnRepo
}

func NewCmbService(
	bc *conf.Bootstrap,
	cron *cron.Cron,
	VoucherBiz *biz.VoucherBiz,
	CmbMixRepo mixrepos.CmbMixRepo,
	WechatCpnRepo wechatrepo.WechatCpnRepo,
) *CmbService {
	return &CmbService{
		bc:            bc,
		cron:          cron,
		VoucherBiz:    VoucherBiz,
		CmbMixRepo:    CmbMixRepo,
		WechatCpnRepo: WechatCpnRepo,
	}
}

func (c *CmbService) GetResponse(ctx context.Context, replyBizContent []byte) (*v1.CmbReply, error) {

	req := &bo.CmbResponseBo{
		RespCode:   vo.CmbResponseStatusSuccess.GetValue(),
		RespMsg:    "成功",
		BizContent: string(replyBizContent),
	}

	reply, err := c.CmbMixRepo.GetResponse(ctx, req)
	if err != nil {
		log.Errorf("build cmb response fail: %v", err)
		return nil, err
	}

	return reply, nil
}

func (this *CmbService) NotifyRetry(ctx http.Context) error {
	id := ctx.Vars().Get("id")
	if id == "" {
		return fmt.Errorf("id is empty")
	}

	orderNotifyId, err := strconv.ParseUint(id, 10, 64)
	if err != nil {
		return err
	}

	return this.VoucherBiz.PushNotifyRetryDelayMQ(ctx, 1, orderNotifyId)
}

func (this *CmbService) QueryOrder(ctx http.Context) error {

	orderNo := ctx.Vars().Get("order_no")
	if orderNo == "" {
		return fmt.Errorf("orderNo is empty")
	}

	str, err := this.VoucherBiz.QueryOrder(ctx, orderNo)
	if err != nil {
		return err
	}

	return ctx.JSON(http2.StatusOK, map[string]interface{}{
		"data": str,
	})
}

func (c *CmbService) OrderRetry(ctx context.Context, request *v1.OrderRetryRequest) (*v1.Empty, error) {

	return nil, c.VoucherBiz.OrderRetry(ctx, request.GetTransactionIds())
}

func (this *CmbService) RegisterTag(ctx http.Context) error {

	productNo := ctx.Vars().Get("product_no")
	if productNo == "" {
		return fmt.Errorf("product_no is empty")
	}

	err := this.VoucherBiz.RegisterTag(ctx, productNo)
	if err != nil {
		return err
	}

	return ctx.JSON(http2.StatusOK, map[string]interface{}{
		"data": productNo,
	})
}

func (this *CmbService) PushWechatQuery(ctx http.Context) error {

	bodyBytes, err := io.ReadAll(ctx.Request().Body)
	if err != nil {
		return err
	}

	var req *do.WechatQuery
	if err = json.Unmarshal(bodyBytes, &req); err != nil {
		return err
	}

	if req == nil {
		return fmt.Errorf("req is empty")
	}

	productNo := ctx.Vars().Get("product_no")
	if productNo == "" {
		req.ProductNo = productNo
	}

	if req.StartTime == "" || req.EndTime == "" {
		return fmt.Errorf("start_time or end_time is empty")
	}

	if err = this.VoucherBiz.PushWechatQuery(ctx, req); err != nil {
		return err
	}

	return ctx.JSON(http2.StatusOK, map[string]interface{}{
		"data": req,
	})
}

func (this *CmbService) PushWechatRetry(ctx http.Context) error {

	productNo := ctx.Vars().Get("product_no")
	if productNo == "" {
		return fmt.Errorf("product_no is empty")
	}

	err := this.VoucherBiz.PushWechatRetry(ctx, productNo)
	if err != nil {
		return err
	}

	return ctx.JSON(http2.StatusOK, map[string]interface{}{
		"data": productNo,
	})
}