eta_api/services/xfyun.go

package services

import (
	"encoding/base64"
	"encoding/json"
	"eta_gn/eta_api/models"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/crypt"
	"net/url"
	"strings"
	"time"

	"eta_gn/eta_api/utils"
	"github.com/gorilla/websocket"
)

type XfParams struct {
	XfAPPID     string
	XfAPIKey    string
	XfAPISecret string
}

func GetXfVideo(body []byte, savePath string, req XfParams) (err error) {
	path, err := assembleAuthUrl(req)
	if err != nil {
		return
	}
	conn, _, err := websocket.DefaultDialer.Dial(path, nil)
	if err != nil {
		return
	}
	defer conn.Close()

	err = conn.WriteMessage(websocket.TextMessage, body)
	if err != nil {
		return
	}

	for {
		_, message, err := conn.ReadMessage()
		if err != nil {
			fmt.Println("ReadMessage Err:" + err.Error())
			return err
		}
		item := new(models.XfReciveResult)
		err = json.Unmarshal(message, &item)
		if err != nil {
			fmt.Println("json.Unmarshal Err:" + err.Error())
			return err
		}
		if item.Code != 0 {
			goto readWebSocketFail
		}
		if item.Code == 0 && item.Data != nil {
			if item.Data.Status == 1 {
				audio := item.Data.Audio
				err = utils.SaveBase64ToFileBySeek(audio, savePath)
				if err != nil {
					fmt.Println("文件保存失败", err.Error())
					goto readWebSocketFail
				}
			} else {
				audio := item.Data.Audio
				err = utils.SaveBase64ToFileBySeek(audio, savePath)
				if err != nil {
					fmt.Println("文件保存失败", err.Error())
					goto webSocketClose
				}
				fmt.Println("goto close")
				goto webSocketClose
			}
		}
	}
readWebSocketFail:
	conn.Close()
	fmt.Println("goto readWebSocketFail")
webSocketClose:
	conn.Close()
	fmt.Println("goto webSocketClose")
	return nil
}

func assembleAuthUrl(req XfParams) (callUrl string, err error) {
	ul, err := url.Parse(utils.XfHostUrl)
	if err != nil {
		return
	}
	date := time.Now().UTC().Format(time.RFC1123)
	signString := []string{"host: " + ul.Host, "date: " + date, "GET " + ul.Path + " HTTP/1.1"}
	sign := strings.Join(signString, "\n")
	fmt.Println("sign:", sign)
	sha := crypt.HmacSha256EncryptToBase64([]byte(sign), []byte(req.XfAPISecret))
	authUrl := fmt.Sprintf("api_key=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", req.XfAPIKey,
		"hmac-sha256", "host date request-line", sha)
	authorization := base64.StdEncoding.EncodeToString([]byte(authUrl))
	v := url.Values{}
	v.Add("host", ul.Host)
	v.Add("date", date)
	v.Add("authorization", authorization)
	callUrl = utils.XfHostUrl + "?" + v.Encode()
	return
}