xpggame/modules/pay/moonpay2/base.go

package moonpay2

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"server/common"
	"server/modules/pay/base"
	"server/modules/pay/values"
	"server/pb"
	"server/util"
	"strings"

	"github.com/gogo/protobuf/proto"
	"github.com/liangdas/mqant/log"
)

func NewSub(b *base.Base) {
	sub := &Sub{
		Base: b,
	}
	b.HttpType = base.HttpTypeJson
	b.ShouldSignUpper = true
	b.Channel = values.MoonPay2
	if b.Opt == base.OPTPay {
		b.Resp = new(PayResp)
		b.ReqURL = payURL
	} else if b.Opt == base.OPTWithdraw {
		b.Resp = new(WithdrawResp)
		b.ReqURL = withdrawURL
	} else if b.Opt == base.OPTPayCB {
		b.CallbackReq = new(PayCallbackReq)
		b.CallbackResp.Msg = "success"
	} else if b.Opt == base.OPTWithdrawCB {
		b.CallbackReq = new(WithdrawCallbackReq)
		b.CallbackResp.Msg = "success"
	} else if b.Opt == base.OPTQueryWithdraw { // 查询
		b.Resp = new(QueryWithdrawResp)
		b.ReqURL = queryWithdrawURL
	} else if b.Opt == base.OPTQueryPay { // 查询
		b.Resp = new(QueryPayResp)
		b.ReqURL = queryPayURL
	} else {
		return
	}
	b.Sub = sub
}

type Sub struct {
	Base *base.Base
}

func (s *Sub) PackHeader(header http.Header) {
}

func (s *Sub) PackReq() interface{} {
	if s.Base.Opt == base.OPTPay {
		return s.PackPayReq()
	} else if s.Base.Opt == base.OPTWithdraw {
		return s.PackWithdrawReq()
	} else if s.Base.Opt == base.OPTQueryWithdraw {
		return s.PackQueryWithdrawReq()
	} else if s.Base.Opt == base.OPTQueryPay {
		return s.PackQueryPayReq()
	}
	return nil
}

func (s *Sub) GetResp() (proto.Message, error) {
	log.Debug("resp:%v", s.Base.Resp)
	if s.Base.Opt == base.OPTPay {
		resp := s.Base.Resp.(*PayResp)
		if resp.Data.PayURL == "" {
			return nil, errors.New("pay fail")
		}
		return &pb.InnerRechargeResp{APIOrderID: resp.Data.PlatNumber, URL: resp.Data.PayURL, Channel: uint32(values.MoonPay2)}, nil
	} else if s.Base.Opt == base.OPTWithdraw {
		resp := s.Base.Resp.(*WithdrawResp)
		if s.Base.Status == 0 && resp.Code != 100 {
			return nil, errors.New("withdraw fail")
		}
		data := &WithdrawData{}
		tmp, ok := resp.Data.(map[string]interface{})
		if ok {
			str, _ := json.Marshal(tmp)
			json.Unmarshal([]byte(str), data)
		}
		return &pb.InnerWithdrawResp{APIOrderID: data.PlatNumber, Channel: uint32(values.MoonPay2)}, nil
	} else if s.Base.Opt == base.OPTQueryWithdraw {
		resp := s.Base.Resp.(*QueryWithdrawResp)
		ret := &pb.InnerQueryWithdrawResp{Msg: resp.Msg}
		if len(resp.Data) == 0 {
			ret.Status = 2
			return ret, nil
		}
		ret.OrderID = resp.Data[0].OrderNumber
		s.Base.QueryWithdrawResp.OrderID = resp.Data[0].OrderNumber
		// ret.APIOrderID=resp.Data[0].
		// s.Base.QueryWithdrawResp.APIOrderID = resp.Data.OrderID
		s.Base.QueryWithdrawResp.Msg = resp.Msg
		if s.Base.Status != 0 {
			s.Base.QueryWithdrawResp.Status = 3
		} else {
			if resp.Code == 100 && resp.Data[0].Status == 4 {
				s.Base.QueryWithdrawResp.Status = 1
			} else if resp.Data[0].Status == 2 || resp.Data[0].Status == 3 || resp.Data[0].Status == 5 {
				s.Base.QueryWithdrawResp.Status = 2
			} else {
				s.Base.QueryWithdrawResp.Status = 3
			}
		}
		return ret, nil
	} else if s.Base.Opt == base.OPTQueryPay {
		resp := s.Base.Resp.(*QueryPayResp)
		ret := &pb.InnerQueryWithdrawResp{Msg: resp.Msg}
		if len(resp.Data) == 0 {
			ret.Status = 2
			return ret, nil
		}
		s.Base.QueryPayResp.APIOrderID = resp.Data[0].OrderNumber
		// s.Base.QueryPayResp.OrderID = resp.Data.MOrderID
		s.Base.QueryPayResp.Msg = resp.Msg
		if s.Base.Status != 0 {
			s.Base.QueryPayResp.Status = 3
		} else {
			if resp.Code == 100 && resp.Data[0].Status == 4 {
				s.Base.QueryPayResp.Status = 1
			} else if resp.Data[0].Status == 3 {
				s.Base.QueryPayResp.Status = 2
			} else {
				s.Base.QueryPayResp.Status = 3
			}
		}
		return ret, nil
	}
	return nil, errors.New("unknown opt")
}

func (s *Sub) PackPayReq() interface{} {
	r := s.Base.PayReq
	if len(r.Phone) == 12 {
		r.Phone = r.Phone[2:]
	}
	r.Amount /= 100
	send := &PayReq{
		MerchantID:  mid,
		OrderNumber: r.OrderID,
		OrderAmount: fmt.Sprintf("%d", r.Amount),
		Email:       r.Email,
		Name:        r.Name,
		Phone:       r.Phone,
		Deeplink:    "0",
		NotifyURL:   values.GetPayCallback(values.MoonPay2),
	}
	send.Sign = strings.ToUpper(util.CalculateMD5(send.OrderNumber + mid + signKey))
	return send
}

func (s *Sub) PackWithdrawReq() interface{} {
	r := s.Base.WithdrawReq
	send := &WithdrawReq{
		MerchantID:  mid,
		OrderNumber: r.OrderID,
		OrderAmount: fmt.Sprintf("%d", r.Amount),
		// Type: ,
		// VPA: ,
		Email: r.Email,
		// Account: ,
		Name: r.Name,
		// IFSC: ,
		Phone:     r.Phone,
		NotifyURL: values.GetWithdrawCallback(values.MoonPay2),
	}
	if r.PayType == int64(common.PayTypeBank) {
		send.Type = "BANK"
		send.Account = r.CardNo
		send.IFSC = r.PayCode
	} else if r.PayType == int64(common.PayTypeUPI) {
		send.Type = "UPI"
		send.VPA = r.PayCode
	} else {
		return nil
	}
	signData, _ := json.Marshal(send)
	sign, _ := base.SignWithSHA256(signData, string(privateKey))
	send.Sign = sign
	return send
}

func (s *Sub) CheckSign(str string) bool {
	log.Debug("callback:%v", s.Base.CallbackReq)
	if s.Base.Opt == base.OPTPayCB {
		req := s.Base.CallbackReq.(*PayCallbackReq)
		s.Base.CallbackResp.OrderID = req.OrderNumber
		s.Base.CallbackResp.APIOrderID = req.PlatNumber
		if req.Status == 1 {
			return false
		}
		s.Base.CallbackResp.Success = req.Status == 4

		return strings.ToUpper(util.CalculateMD5(req.OrderNumber+mid+signKey)) == req.Sign
	} else if s.Base.Opt == base.OPTWithdrawCB {
		req := s.Base.CallbackReq.(*WithdrawCallbackReq)
		s.Base.CallbackResp.OrderID = req.OrderNumber
		if req.Status == 1 {
			return false
		}
		s.Base.CallbackResp.Success = req.Status == 4
		err := base.RsaDecode(req.Sign, string(publicKey))
		if err != nil {
			log.Error("err:%v", err)
		}
		return err == nil
	}
	return false
}

func (s *Sub) PackQueryWithdrawReq() interface{} {
	r := s.Base.WithdrawReq
	send := &QueryWithdrawReq{
		MerchantID: mid,
		OrderList:  []string{r.OrderID},
	}
	send.Sign = strings.ToUpper(util.CalculateMD5(mid + signKey))
	return send
}

func (s *Sub) PackQueryPayReq() interface{} {
	r := s.Base.PayReq
	send := &QueryPayReq{
		MerchantID: mid,
		OrderList:  []string{r.OrderID},
	}
	send.Sign = strings.ToUpper(util.CalculateMD5(mid + signKey))
	return send
}