fonchain-fiee/pkg/service/artwork_third_party.go

package service

import (
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork"
	"github.com/fonchain_enterprise/fonchain-main/api/artwork_third_party"
	"github.com/fonchain_enterprise/fonchain-main/pkg/common"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/utils"
	"github.com/gin-gonic/gin"
	"time"
)

func NfcList(c *gin.Context) {
	var req artwork_third_party.NfcListReq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("NfcList ShouldBind err", err)
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	if err := req.Validate(); err != nil {
		err = common.SubstrError(err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	resp, err := GrpcArtworkThirdPartyImpl.NfcList(context.Background(), &req)
	if err != nil {
		ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}
	ResponseMsg(c, e.SUCCESS, serializer.Response{
		Msg:    resp.Msg,
		Status: e.Ok,
		Data:   resp,
	})
}

func LoadData(c *gin.Context) {
	var req artwork_third_party.LoadDataReq
	/*if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("LoadSetting ShouldBind err", err)
		ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	if err := req.Validate(); err != nil {
		err = common.SubstrError(err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}*/
	resp, err := GrpcArtworkThirdPartyImpl.LoadData(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, resp.Msg, nil)
}

// https://www.oceanbase.com/docs/common-ocp-1000000000348383
func AddCollector(c *gin.Context) {
	var req artwork.CollectorReq
	if err := c.ShouldBind(&req); err != nil {
		logger.Errorf("AddCollector err ShouldBind", err)
		ResponseQuickMsg(c, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	var host string = "erptest.fontree.cn:9020"
	// 我自己的签名
	xSdkDate := c.Request.Header.Get("x-sdk-date")
	authorization := c.Request.Header.Get("Authorization")
	//host := strings.Replace(config.ApiHost, "https://", "", 1)
	if config.Env == "prod" {
		host = "erpapi.fontree.cn"
	}
	//fmt.Println(host)
	newAuth := akSkSign(&req, xSdkDate, host)
	if err := req.Validate(); err != nil {
		err = common.SubstrError(err)
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	if newAuth != authorization {
		fmt.Println("newAuth--", newAuth)
		ResponseQuickMsg(c, e.Failed, "签名不一致", nil)
		return
	}

	//contentType := c.Request.Header.Get("Content-Type")
	//host := c.Request.Header.Get("Host")

	//ResponseQuickMsg(c, e.Ok, e.GetMsg(e.Success), dd)
	_, err := GrpcArtworkImpl.Collector(context.Background(), &req)
	if err != nil {
		ResponseQuickMsg(c, e.Failed, err.Error(), nil)
		return
	}
	ResponseQuickMsg(c, e.Ok, e.GetMsg(e.Success), nil)
}

// ak sk 签名规则

func akSkSign(req *artwork.CollectorReq, date, host string) string {
	// 以下表示有三个消息头参与签名：Content-Type、Host、X-Sdk-Date
	//Host := "erptest.fontree.cn:9020"

	//test
	ak := config.ErpAk
	sk := config.ErpSk

	collector := req.Collector
	tfnum := req.Tfnum
	api := "/artwork/add-collector"
	//date := time.Now().Format("2006-01-02 15:04:05")
	//content := map[string]string{
	//	"Collector": "1234",
	//	"Tfnum":     "T51523012",
	//}

	ContentMd5 := utils.Md5Str("Collector=" + collector + "&Tfnum=" + tfnum)
	ContentType := "application/json"
	//message = Http Method + "\n" + Content-md5 + "\n" + Content-Type + "\n" + Date+ "\n" + Host+ uri
	signInfo := "POST" + "\n" + ContentMd5 + "\n" + ContentType + "\n" + date + "\n" + host + "\n" + api

	fmt.Println("signInfo--", signInfo)
	sha256Str := HmacSha256Hex(sk, signInfo)
	fmt.Println("sha256Str--", sha256Str)
	sign := base64.StdEncoding.EncodeToString([]byte(sha256Str))
	authorization := "OCP-ACCESS-KEY-HMACSHA1 " + ak + ":" + sign
	header := map[string]string{
		"Content-Type":  "application/json",
		"Authorization": authorization,
		"x-sdk-date":    date,
		"Host":          host,
	}
	fmt.Printf("%+v", header)
	fmt.Println("authorization", authorization)
	fmt.Println("x-sdk-date", date)
	fmt.Println("Host", host)
	return authorization
}

func FormatISO8601Date(timestamp_second int64) string {
	tm := time.Unix(timestamp_second, 0).UTC()
	return tm.Format("2006-01-02T15:04:05Z")
}

func HmacSha256Hex(key, str_to_sign string) string {
	hasher := hmac.New(sha256.New, []byte(key))
	hasher.Write([]byte(str_to_sign))
	return hex.EncodeToString(hasher.Sum(nil))
}