YouChuKoffee/app/third/youchu/youchu_api.go

package youchu

import (
	"encoding/json"
	"qteam/app/constants/errorcode"
	"qteam/app/http/entities/front"
	"qteam/app/models/ordersmodel"
	"qteam/app/utils"
	"qteam/app/utils/postbank"
	"qteam/config"
	"time"
)

func NewYouChuClient(cfg config.YouChuConfig) *YouChuClient {
	return &YouChuClient{
		cfg: cfg,
	}
}

func (this *YouChuClient) Login(code string) (Code int, response front.YouChuLoginResponse) {
	partnerTxSriNo := time.Now().Format("20060102150405") + utils.RandomNumber(10)
	url := this.cfg.LoginHost + this.cfg.MerchantId + ".htm?partnerTxSriNo=" + partnerTxSriNo
	request := front.YouChuLoginRequest{
		Head: front.YouChuRequestHeader{
			PartnerTxSriNo: partnerTxSriNo,
			AccessType:     "API",
			Reserve:        "",
			ReqTime:        time.Now().Format("20060102150405"),
			Method:         "crecard.getCustomerInfo",
			Version:        "1",
			MerchantId:     config.GetConf().YouChu.MerchantId,
			AppID:          config.GetConf().YouChu.AppID,
		},
		Body: front.YouChuLoginBody{
			Code:         code,
			CustNo:       "000000",
			ReqTransTime: time.Now().Format("20060102150405"),
		},
	}
	requestData := EncryptRequest(request)
	bytes, err := json.Marshal(requestData)
	utils.Log(nil, "YouChuLoginRequest", string(bytes))
	if err != nil {
		return errorcode.SystemError, response
	}
	post, err := this.doPost(url, partnerTxSriNo, "crecard.getCustomerInfo", bytes)
	if err != nil {
		return errorcode.SystemError, response
	}
	responseData := DecryptResponse(string(post), false)
	utils.Log(nil, "YouChuLogin", responseData)
	err = json.Unmarshal([]byte(responseData), &response)
	if err != nil {
		return errorcode.SystemError, response
	}
	return errorcode.Success, response
}

func (this *YouChuClient) OrderQuery(order ordersmodel.Orders) (code int, response front.YouChuOrderQueryResponse) {
	var BusiMainId = time.Now().Format("20060102150405") + utils.RandomNumber(10)
	request := front.YouChuRequestBody{
		Body: front.YouChuOrderRequest{
			BusiMainId:   BusiMainId,
			ReqTransTime: order.CreateTime.Format("20060102150405"),
			Data: front.OrderQuery{
				TxnCode:    "1004",
				SourceId:   "16",
				ReqTraceId: order.OrderNo,
				ReqDate:    time.Now().Format("20060102150405"),
				TxnDt:      time.Now().Format("20060102"),
				MchtNo:     config.GetConf().YouChu.MchtNo,
				OldSeqNo:   utils.GenerateRequestNumber(),
			},
		},
		Head: front.YouChuRequestHeader{
			PartnerTxSriNo: BusiMainId,
			ReqTime:        time.Now().Format("20060102150405"),
			AccessType:     "API",
			Reserve:        "",
			Method:         "b2c.gatewaypay.orderQuery",
			Version:        "1",
			MerchantId:     config.GetConf().YouChu.MerchantId,
			AppID:          config.GetConf().YouChu.AppID,
		},
	}
	url := this.cfg.OrderHost + config.GetConf().YouChu.MerchantId + ".htm?partnerTxSriNo=" + request.Body.BusiMainId
	requestData := EncryptRequest(request)
	bytes, err := json.Marshal(requestData)
	if err != nil {
		return errorcode.SystemError, response
	}
	post, err := this.doPost(url, request.Body.BusiMainId, "b2c.gatewaypay.orderQuery", bytes)
	if err != nil {
		return errorcode.SystemError, response
	}
	responseData := DecryptResponse(string(post), false)
	utils.Log(nil, "OrderQuery", responseData)
	err = json.Unmarshal([]byte(responseData), &response)
	if err != nil {
		return errorcode.SystemError, response
	}
	return errorcode.Success, response
}

func (this *YouChuClient) OrderRefund(order ordersmodel.Orders) (code int, response front.YouChuOrderRefundResponse) {
	var BusiMainId = time.Now().Format("20060102150405") + utils.RandomNumber(10)
	request := front.YouChuOrderRefundRequest{
		Head: front.YouChuRequestHeader{
			PartnerTxSriNo: BusiMainId,
			AccessType:     "API",
			ReqTime:        time.Now().Format("20060102150405"),
			Reserve:        "",
			Method:         "b2c.gatewaypay.orderRefund",
			Version:        "1",
			MerchantId:     config.GetConf().YouChu.MerchantId,
			AppID:          config.GetConf().YouChu.AppID,
		},
		Body: front.RefundRequestBody{
			BusiMainId:   BusiMainId,
			ReqTransTime: order.CreateTime.Format("2006-01-02 15:04:05"),
			Data: front.RefundRequestData{
				TxnCode:    "1003",
				SourceId:   "16",
				ReqTraceId: order.OrderNo,
				ReqDate:    time.Now().Format("20060102150405"),
				MchtNo:     config.GetConf().YouChu.MchtNo,
				OrgTxnSeq:  order.OrgTxnSeq,
				TxnAmt:     order.Price,
				OrgTxnAmt:  order.Price,
				RefundDesc: "用户主动退款",
			},
		},
	}
	url := this.cfg.OrderHost + config.GetConf().YouChu.MerchantId + ".htm?partnerTxSriNo=" + request.Body.BusiMainId
	requestData := EncryptRequest(request)
	bytes, err := json.Marshal(requestData)
	if err != nil {
		return errorcode.SystemError, response
	}
	post, err := this.doPost(url, request.Body.BusiMainId, "b2c.gatewaypay.orderRefund", bytes)
	utils.Log(nil, "b2c.orderRefund", post)
	if err != nil {
		return errorcode.YouChuOrderRefundFail, response
	}
	responseData := DecryptResponse(string(post), false)
	utils.Log(nil, "OrderQuery", responseData)
	err = json.Unmarshal([]byte(responseData), &response)
	if err != nil {
		return errorcode.SystemError, front.YouChuOrderRefundResponse{}
	}
	return errorcode.Success, response
}

func EncryptRequest(request interface{}) (RequestData front.YouChuRequest) {
	input, _ := json.Marshal(request)
	MerchantId := config.GetConf().YouChu.MerchantId
	PrivateKey := config.GetConf().Sm2.PrivateKey
	PublicKey := config.GetConf().YouChu.SopPublicKey
	encrypt, err := postbank.Encrypt(MerchantId, PrivateKey, PublicKey, string(input), "", true)
	if err != nil {
		return front.YouChuRequest{}
	}
	err = json.Unmarshal([]byte(encrypt), &RequestData)
	if err != nil {
		return front.YouChuRequest{}
	}
	return RequestData
}

func DecryptResponse(response string, isRequest bool) (Rsponse string) {
	MerchantId := config.GetConf().YouChu.MerchantId
	PrivateKey := config.GetConf().Sm2.PrivateKey
	PublicKey := config.GetConf().YouChu.SopPublicKey
	encrypt, err := postbank.Decrypt(MerchantId, PrivateKey, PublicKey, response, isRequest)
	if err != nil {
		return Rsponse
	}
	var RsponseData map[string]interface{}
	err = json.Unmarshal([]byte(encrypt), &RsponseData)
	utils.Log(nil, "DecryptResponse-body", err)
	if err != nil {
		return Rsponse
	} else {
		if RsponseData["body"] != nil {
			body, err := json.Marshal(RsponseData["body"].(map[string]interface{}))
			if err != nil {
				return Rsponse
			}
			Rsponse = string(body)
		}
	}
	utils.Log(nil, "DecryptResponse-body", Rsponse)
	return Rsponse
}

type T struct {
	Head string `json:"head"`
	Body string `json:"body"`
}