844 lines
25 KiB
Go
844 lines
25 KiB
Go
package cloud
|
||
|
||
import (
|
||
"bytes"
|
||
_ "embed"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"net/http"
|
||
"net/url"
|
||
"regexp"
|
||
"slices"
|
||
"strings"
|
||
"sync"
|
||
"text/template"
|
||
"time"
|
||
|
||
"apigo.cc/gojs"
|
||
"apigo.cc/gojs/goja"
|
||
"github.com/gorilla/websocket"
|
||
"github.com/ssgo/config"
|
||
"github.com/ssgo/httpclient"
|
||
"github.com/ssgo/log"
|
||
"github.com/ssgo/u"
|
||
)
|
||
|
||
type Action struct {
|
||
Desc string
|
||
Config map[string]any
|
||
Method string
|
||
Path string
|
||
RequestFormat string
|
||
ResponseFormat string
|
||
Timeout int
|
||
RequestParams []*RequestParam
|
||
RequestHeaders []*HeaderParam
|
||
Response []*ResponseParam
|
||
SuccessBy string
|
||
FailedMessageBy string
|
||
}
|
||
|
||
type FixedAction struct {
|
||
Action
|
||
RequiredRequestParams []*RequestParam
|
||
NotRequiredRequestParams []*RequestParam
|
||
FuncParams string
|
||
}
|
||
|
||
type RequestParam struct {
|
||
Name string
|
||
Type string
|
||
Required bool
|
||
Value any
|
||
Desc string
|
||
Sub []*RequestParam
|
||
}
|
||
|
||
type HeaderParam struct {
|
||
Name string
|
||
Value string
|
||
Desc string
|
||
}
|
||
|
||
type ResponseParam struct {
|
||
Name string
|
||
Type string
|
||
Desc string
|
||
Sub []*ResponseParam
|
||
}
|
||
|
||
type CloudConfig struct {
|
||
Desc string
|
||
Config map[string]any
|
||
RequestFormat string
|
||
ResponseFormat string
|
||
Timeout int
|
||
RequestParams []*RequestParam
|
||
RequestHeaders []*HeaderParam
|
||
Response []*ResponseParam
|
||
Api map[string]*Action
|
||
}
|
||
|
||
// var encryptdMatcher = regexp.MustCompile(`<\*\*([\w-=]+)\*\*>`)
|
||
var encryptdMatcher = regexp.MustCompile(`^[\w-=]+$`)
|
||
|
||
var confAes = u.NewAes([]byte("?GQ$0K0GgLdO=f+~L68PLm$uhKr4'=tV"), []byte("VFs7@sK61cj^f?HZ"))
|
||
var keysIsSet = false
|
||
|
||
func SetSSKey(key, iv []byte) {
|
||
if !keysIsSet {
|
||
confAes = u.NewAes(key, iv)
|
||
keysIsSet = true
|
||
}
|
||
}
|
||
|
||
//go:embed export.ts
|
||
var exportTS string
|
||
|
||
var cloudConfigs map[string]*CloudConfig
|
||
var fixedCloudConfigs map[string]map[string]*FixedAction
|
||
var httpClients = map[string]map[int]*httpclient.ClientPool{}
|
||
var httpClientsLock = sync.RWMutex{}
|
||
|
||
func init() {
|
||
gojs.Register("apigo.cc/cloud", gojs.Module{
|
||
ObjectMaker: func(vm *goja.Runtime) gojs.Map {
|
||
logger := gojs.GetLogger(vm)
|
||
makeConfig(logger)
|
||
gojsObj := gojs.Map{}
|
||
|
||
for cloudName, actions := range fixedCloudConfigs {
|
||
httpClientsLock.RLock()
|
||
hcSet := httpClients[cloudName]
|
||
httpClientsLock.RUnlock()
|
||
if hcSet == nil {
|
||
hcSet = map[int]*httpclient.ClientPool{}
|
||
httpClientsLock.Lock()
|
||
httpClients[cloudName] = hcSet
|
||
httpClientsLock.Unlock()
|
||
}
|
||
cloudObj := map[string]any{}
|
||
for actionName, action := range actions {
|
||
httpClientsLock.RLock()
|
||
_, hcOK := hcSet[action.Timeout]
|
||
httpClientsLock.RUnlock()
|
||
if !hcOK {
|
||
hc := httpclient.GetClient(time.Duration(action.Timeout) * time.Millisecond)
|
||
httpClientsLock.Lock()
|
||
hcSet[action.Timeout] = hc
|
||
httpClientsLock.Unlock()
|
||
}
|
||
cloudObj[actionName] = makeAction(cloudName, action)
|
||
}
|
||
gojsObj[cloudName] = cloudObj
|
||
}
|
||
|
||
return gojsObj
|
||
},
|
||
TsCodeMaker: func() string {
|
||
makeConfig(log.DefaultLogger)
|
||
var err error
|
||
tsCode := ""
|
||
tpl := template.New("export")
|
||
tpl = tpl.Funcs(template.FuncMap{
|
||
"makeMap": func(args ...any) map[string]any {
|
||
out := map[string]any{}
|
||
for i := 0; i < len(args); i += 2 {
|
||
out[u.String(args[i])] = args[i+1]
|
||
}
|
||
// fmt.Println(u.BGreen(u.JsonP(out)))
|
||
return out
|
||
},
|
||
})
|
||
if tpl, err = tpl.Parse(strings.ReplaceAll(exportTS, "//----", "")); err == nil {
|
||
buf := bytes.NewBuffer(make([]byte, 0))
|
||
if err = tpl.Execute(buf, fixedCloudConfigs); err == nil {
|
||
tsCode = buf.String()
|
||
} else {
|
||
fmt.Println(u.BRed(err.Error()))
|
||
}
|
||
} else {
|
||
fmt.Println(u.BRed(err.Error()))
|
||
}
|
||
return tsCode
|
||
},
|
||
SetSSKey: SetSSKey,
|
||
})
|
||
}
|
||
|
||
func getHttpClient(cloudName string, timeout int) *httpclient.ClientPool {
|
||
httpClientsLock.RLock()
|
||
defer httpClientsLock.RUnlock()
|
||
return httpClients[cloudName][timeout]
|
||
}
|
||
|
||
var expressionMatcher = regexp.MustCompile(`(?ms){{.+?}}`)
|
||
var funcNameExcludesMatcher = regexp.MustCompile(`[^\w]`)
|
||
|
||
func makeAction(cloudName string, action *FixedAction) any {
|
||
return func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
||
// 解析参数
|
||
requiredCount := len(action.RequiredRequestParams)
|
||
args := gojs.MakeArgs(&argsIn, vm).Check(requiredCount)
|
||
params := args.Map(requiredCount + 1)
|
||
headers := args.Map(requiredCount + 2)
|
||
|
||
// 合并请求参数
|
||
for i, param := range action.RequiredRequestParams {
|
||
params[param.Name] = args.Any(i)
|
||
}
|
||
|
||
// 处理默认值
|
||
for _, param := range action.RequestParams {
|
||
if param.Value != nil && params[param.Name] == nil {
|
||
if strValue, ok := param.Value.(string); ok {
|
||
if !strings.Contains(strValue, "{{") {
|
||
params[param.Name] = param.Value
|
||
}
|
||
} else {
|
||
params[param.Name] = param.Value
|
||
}
|
||
}
|
||
}
|
||
for _, header := range action.RequestHeaders {
|
||
if header.Value != "" && headers[header.Name] == nil {
|
||
if !strings.Contains(header.Value, "{{") {
|
||
headers[header.Name] = header.Value
|
||
}
|
||
}
|
||
}
|
||
|
||
// 生成request信息
|
||
requestUrl, err := url.Parse(u.String(action.Config["endpoint"]) + action.Path)
|
||
if err != nil {
|
||
panic(vm.NewGoError(err))
|
||
}
|
||
paramsSortJoin := func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
||
args := gojs.MakeArgs(&argsIn, vm)
|
||
joinTag := args.Str(0)
|
||
linkTag := args.Str(1)
|
||
if joinTag == "" {
|
||
joinTag = "&"
|
||
}
|
||
if linkTag == "" {
|
||
linkTag = "="
|
||
}
|
||
a := make([]string, 0)
|
||
for k, v := range params {
|
||
a = append(a, k+linkTag+u.String(v))
|
||
}
|
||
slices.Sort(a)
|
||
return vm.ToValue(strings.Join(a, joinTag))
|
||
}
|
||
if requestUrl.RawPath == "" {
|
||
requestUrl.RawPath = requestUrl.Path
|
||
}
|
||
requestInfo := map[string]any{
|
||
"method": action.Method,
|
||
"scheme": requestUrl.Scheme,
|
||
"host": requestUrl.Host,
|
||
"path": requestUrl.Path,
|
||
"rawPath": requestUrl.RawPath,
|
||
"rawQuery": requestUrl.RawQuery,
|
||
"fragment": requestUrl.Fragment,
|
||
"rawFragment": requestUrl.RawFragment,
|
||
"fullPath": requestUrl.RequestURI(),
|
||
"url": requestUrl.String(),
|
||
"sortJoin": paramsSortJoin,
|
||
}
|
||
requestValue := vm.ToValue(requestInfo)
|
||
|
||
// 计算请求参数中的动态值
|
||
configValue := vm.ToValue(action.Config)
|
||
actionValue := vm.ToValue(gojs.MakeMap(action))
|
||
var paramsValue goja.Value
|
||
var headersValue goja.Value
|
||
var dataValue goja.Value
|
||
headersValue = vm.ToValue(headers)
|
||
|
||
// 处理基本信息中的动态值
|
||
if action.Path != "" && strings.Contains(action.Path, "{{") {
|
||
action.Path = expressionMatcher.ReplaceAllStringFunc(action.Path, func(s string) string {
|
||
fnCode := s[2 : len(s)-2]
|
||
newValue := runFn(fnCode, vm, "action, request, config, params, headers", actionValue, requestValue, configValue, paramsValue, headersValue)
|
||
return u.String(newValue)
|
||
})
|
||
requestUrl, err = url.Parse(u.String(action.Config["endpoint"]) + action.Path)
|
||
if err != nil {
|
||
panic(vm.NewGoError(err))
|
||
}
|
||
if requestUrl.RawPath == "" {
|
||
requestUrl.RawPath = requestUrl.Path
|
||
}
|
||
requestInfo = map[string]any{
|
||
"method": action.Method,
|
||
"scheme": requestUrl.Scheme,
|
||
"host": requestUrl.Host,
|
||
"path": requestUrl.Path,
|
||
"rawPath": requestUrl.RawPath,
|
||
"rawQuery": requestUrl.RawQuery,
|
||
"fragment": requestUrl.Fragment,
|
||
"rawFragment": requestUrl.RawFragment,
|
||
"fullPath": requestUrl.RequestURI(),
|
||
"url": requestUrl.String(),
|
||
"sortJoin": paramsSortJoin,
|
||
}
|
||
requestValue = vm.ToValue(requestInfo)
|
||
}
|
||
|
||
// 处理请求参数中的动态值
|
||
for _, param := range action.RequestParams {
|
||
if param.Value != nil && params[param.Name] == nil {
|
||
if strValue, ok := param.Value.(string); ok && strings.Contains(strValue, "{{") {
|
||
isTest := strings.Contains(param.Name, "TEST__")
|
||
if isTest {
|
||
fmt.Println("make param:", u.Cyan(param.Name))
|
||
}
|
||
|
||
// 将数据拼接到URL中（部分API在请求中需要计算签名）
|
||
if action.RequestFormat == "query" || action.RequestFormat == "binary" || action.Method == "GET" || action.Method == "WS" {
|
||
q := requestUrl.Query()
|
||
for k, v := range params {
|
||
q.Set(k, u.String(v))
|
||
}
|
||
requestUrl.RawQuery = q.Encode()
|
||
requestInfo["rawQuery"] = requestUrl.RawQuery
|
||
requestInfo["fullPath"] = requestUrl.RequestURI()
|
||
requestInfo["url"] = requestUrl.String()
|
||
requestValue = vm.ToValue(requestInfo)
|
||
}
|
||
|
||
// 计算动态值
|
||
var lastRealValue any
|
||
replaceTimes := 0
|
||
newValue := expressionMatcher.ReplaceAllStringFunc(strValue, func(s string) string {
|
||
replaceTimes++
|
||
fnCode := s[2 : len(s)-2]
|
||
// fnName := "_CLOUD_FN_" + funcNameExcludesMatcher.ReplaceAllString(fnCode, "_")
|
||
// fnValue := vm.Get(fnName)
|
||
// if fnValue == nil {
|
||
// if _, err := vm.RunString("function " + fnName + "(action, request, config, params, headers){return " + fnCode + "}"); err != nil {
|
||
// panic(vm.NewGoError(err))
|
||
// }
|
||
// fnValue = vm.Get(fnName)
|
||
// }
|
||
// if fn, ok := goja.AssertFunction(fnValue); ok {
|
||
// if r, err := fn(nil, actionValue, requestValue, configValue, vm.ToValue(params), vm.ToValue(headers)); err != nil {
|
||
// panic(vm.NewGoError(err))
|
||
// } else {
|
||
// lastRealValue = r.Export()
|
||
// if isTest {
|
||
// fmt.Println(" >", u.BMagenta(s), u.BCyan(u.JsonP(lastRealValue)), ".")
|
||
// }
|
||
// return u.String(r.Export())
|
||
// }
|
||
// } else {
|
||
// panic(vm.NewGoError(errors.New("failed to make function " + fnName)))
|
||
// }
|
||
paramsValue = vm.ToValue(params)
|
||
lastRealValue = runFn(fnCode, vm, "action, request, config, params, headers", actionValue, requestValue, configValue, paramsValue, headersValue)
|
||
if isTest {
|
||
fmt.Println(" >", u.BMagenta(s), u.BCyan(lastRealValue), ".")
|
||
}
|
||
return u.String(lastRealValue)
|
||
})
|
||
|
||
if replaceTimes == 1 && newValue == u.String(lastRealValue) {
|
||
// 如果是单一公式，直接使用最后一次替换真实类型的结果
|
||
if !isTest {
|
||
params[param.Name] = lastRealValue
|
||
}
|
||
} else {
|
||
// 替换为计算的结果
|
||
if !isTest {
|
||
params[param.Name] = newValue
|
||
} else {
|
||
// 打印调试信息
|
||
fmt.Println(" >", u.Cyan(u.JsonP(newValue)), ".")
|
||
fmt.Println()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
paramsValue = vm.ToValue(params)
|
||
|
||
// 根据RequestFormat处理请求数据
|
||
if action.RequestFormat == "query" || action.RequestFormat == "binary" || action.Method == "GET" || action.Method == "WS" {
|
||
// 将数据拼接到URL中
|
||
q := requestUrl.Query()
|
||
for k, v := range params {
|
||
q.Set(k, u.String(v))
|
||
}
|
||
requestUrl.RawQuery = q.Encode()
|
||
requestInfo["rawQuery"] = requestUrl.RawQuery
|
||
requestInfo["fullPath"] = requestUrl.RequestURI()
|
||
requestInfo["url"] = requestUrl.String()
|
||
requestValue = vm.ToValue(requestInfo)
|
||
}
|
||
|
||
var data any
|
||
switch action.RequestFormat {
|
||
case "query":
|
||
// 将数据拼接到URL中
|
||
case "binary":
|
||
// 将数据以二进制形式POST，参数拼接到URL中
|
||
args.Check(requiredCount + 1)
|
||
data = args.Bytes(requiredCount)
|
||
case "form", "upload":
|
||
// 将数据以表单类型提交
|
||
args.Check(requiredCount + 1)
|
||
form := make(map[string]string, 0)
|
||
for k, v := range params {
|
||
form[k] = u.String(v)
|
||
}
|
||
data = form
|
||
case "json":
|
||
// 将数据以JSON格式提交
|
||
data = u.Json(params)
|
||
default:
|
||
if action.Method == "GET" {
|
||
// 将数据拼接到URL中
|
||
} else {
|
||
// 将数据以JSON格式提交
|
||
data = params
|
||
}
|
||
}
|
||
// data = `{"EngSerViceType":"8k_zh","SourceType":1,"VoiceFormat":"mp3","Data":"AA","DataLen":0,"WordInfo":0,"FilterDirty":0,"FilterModal":0,"FilterPunc":0,"ConvertNumMode":1,"CustomizationId":"","InputSampleRate":0}`
|
||
|
||
dataValue = vm.ToValue(data)
|
||
|
||
// 计算请求头中的动态值
|
||
for _, header := range action.RequestHeaders {
|
||
if header.Value != "" && headers[header.Name] == nil {
|
||
if strings.Contains(header.Value, "{{") {
|
||
isTest := strings.Contains(header.Name, "TEST__")
|
||
if isTest {
|
||
fmt.Println("make header:", u.Cyan(header.Name))
|
||
}
|
||
var lastRealValue any
|
||
replaceTimes := 0
|
||
newValue := expressionMatcher.ReplaceAllStringFunc(header.Value, func(s string) string {
|
||
replaceTimes++
|
||
fnCode := s[2 : len(s)-2]
|
||
// fnName := "_CLOUD_FN_" + funcNameExcludesMatcher.ReplaceAllString(fnCode, "_")
|
||
// fnValue := vm.Get(fnName)
|
||
// if fnValue == nil {
|
||
// if _, err := vm.RunString("function " + fnName + "(action, request, config, params, headers, data){return " + fnCode + "}"); err != nil {
|
||
// panic(vm.NewGoError(err))
|
||
// }
|
||
// fnValue = vm.Get(fnName)
|
||
// }
|
||
// if fn, ok := goja.AssertFunction(fnValue); ok {
|
||
// if r, err := fn(nil, actionValue, requestValue, configValue, vm.ToValue(params), vm.ToValue(headers), vm.ToValue(data)); err != nil {
|
||
// panic(vm.NewGoError(err))
|
||
// } else {
|
||
// lastRealValue = r.Export()
|
||
// if isTest {
|
||
// fmt.Println(" >", u.BMagenta(s), u.BCyan(u.JsonP(lastRealValue)), ".")
|
||
// }
|
||
// return u.String(lastRealValue)
|
||
// }
|
||
// } else {
|
||
// panic(vm.NewGoError(errors.New("failed to make function " + fnName)))
|
||
// }
|
||
headersValue = vm.ToValue(headers)
|
||
lastRealValue = runFn(fnCode, vm, "action, request, config, params, headers, data", actionValue, requestValue, configValue, paramsValue, headersValue, dataValue)
|
||
if isTest {
|
||
fmt.Println(" >", u.BMagenta(s), u.BCyan(lastRealValue), ".")
|
||
}
|
||
// if header.Name == "TEST__待签名" {
|
||
// fmt.Println(u.BGreen(u.Json(lastRealValue)), ".")
|
||
// fmt.Println(u.BGreen(hex.EncodeToString(u.Sha256([]byte(u.String(lastRealValue))))))
|
||
// }
|
||
return u.String(lastRealValue)
|
||
})
|
||
|
||
if replaceTimes == 1 && newValue == u.String(lastRealValue) {
|
||
// 如果是单一公式，直接使用最后一次替换真实类型的结果
|
||
if !isTest {
|
||
headers[header.Name] = lastRealValue
|
||
}
|
||
} else {
|
||
// 替换为计算的结果
|
||
if !isTest {
|
||
headers[header.Name] = newValue
|
||
} else {
|
||
// 打印调试信息
|
||
fmt.Println(" >", u.Cyan(u.JsonP(newValue)), ".")
|
||
fmt.Println()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// TODO 支持SSE
|
||
// TODO 支持Download（异步回调）
|
||
|
||
// 处理请求头
|
||
headersArr := make([]string, 0)
|
||
for k, v := range headers {
|
||
headersArr = append(headersArr, k, u.String(v))
|
||
}
|
||
|
||
// 发送请求
|
||
hc := getHttpClient(cloudName, action.Timeout)
|
||
var httpResult *httpclient.Result
|
||
var otherResult any
|
||
t1 := time.Now().UnixMilli()
|
||
if action.RequestFormat == "upload" {
|
||
// 处理上传文件
|
||
files := args.Map(requiredCount)
|
||
httpResult, _ = hc.MPost(requestUrl.String(), data.(map[string]string), files, headersArr...)
|
||
} else if action.Method == "WS" {
|
||
// 处理WS请求
|
||
args.Check(requiredCount + 1)
|
||
callback := args.Func(requiredCount)
|
||
reqHeader := http.Header{}
|
||
for k, v := range headers {
|
||
reqHeader.Set(k, u.String(v))
|
||
}
|
||
if conn, resp, err := websocket.DefaultDialer.Dial(strings.Replace(requestUrl.String(), "http", "ws", 1), reqHeader); err == nil {
|
||
for {
|
||
if conn != nil {
|
||
var data any
|
||
var msgType string
|
||
if typ, buf, err := conn.ReadMessage(); err == nil {
|
||
switch typ {
|
||
case websocket.TextMessage:
|
||
msgType = "text"
|
||
if action.ResponseFormat == "json" {
|
||
obj := map[string]any{}
|
||
if err := json.Unmarshal(buf, &obj); err == nil {
|
||
msgType = "json"
|
||
data = obj
|
||
} else {
|
||
data = string(buf)
|
||
}
|
||
}
|
||
case websocket.BinaryMessage:
|
||
msgType = "binary"
|
||
data = buf
|
||
default:
|
||
msgType = "unknown"
|
||
data = string(buf)
|
||
}
|
||
} else {
|
||
break
|
||
}
|
||
if msgType == action.ResponseFormat {
|
||
// 最后一个类型相同的消息作为输出
|
||
otherResult = data
|
||
}
|
||
if callback != nil {
|
||
if r, err := callback(nil, vm.ToValue(data), vm.ToValue(msgType)); err != nil {
|
||
conn.Close()
|
||
panic(vm.NewGoError(err))
|
||
} else if u.Bool(r.Export()) {
|
||
fmt.Println(222, r.Export())
|
||
conn.Close()
|
||
break
|
||
} else {
|
||
fmt.Println(333, r.Export())
|
||
}
|
||
}
|
||
} else {
|
||
break
|
||
}
|
||
}
|
||
httpResult = &httpclient.Result{
|
||
Response: resp,
|
||
Error: err,
|
||
}
|
||
} else {
|
||
panic(vm.NewGoError(err))
|
||
}
|
||
|
||
} else {
|
||
// fmt.Println("request", action.Method, requestUrl.String(), u.Json(headersArr), "...")
|
||
httpResult = hc.Do(action.Method, requestUrl.String(), data, headersArr...)
|
||
// fmt.Println("response", result.Response.StatusCode, result.Response.Status, result.String(), "...")
|
||
}
|
||
if httpResult.Error != nil {
|
||
panic(vm.NewGoError(httpResult.Error))
|
||
}
|
||
|
||
usedTime := time.Now().UnixMilli() - t1
|
||
outHeaders := map[string]string{}
|
||
for k, v := range httpResult.Response.Header {
|
||
outHeaders[k] = v[0]
|
||
}
|
||
gojsResult := gojs.Map{
|
||
"statusCode": httpResult.Response.StatusCode,
|
||
"status": httpResult.Response.Status,
|
||
"headers": outHeaders,
|
||
"usedTime": usedTime,
|
||
}
|
||
|
||
var result any
|
||
if action.Method == "WS" {
|
||
result = otherResult
|
||
} else {
|
||
switch action.ResponseFormat {
|
||
case "json":
|
||
result = httpResult.Map()
|
||
case "binary":
|
||
gojsResult["result"] = httpResult.Bytes()
|
||
default:
|
||
gojsResult["result"] = httpResult.String()
|
||
}
|
||
}
|
||
var responseValue goja.Value
|
||
var resultValue goja.Value
|
||
|
||
if action.SuccessBy != "" || action.FailedMessageBy != "" {
|
||
responseValue = vm.ToValue(gojsResult)
|
||
resultValue = vm.ToValue(result)
|
||
}
|
||
|
||
if action.SuccessBy != "" {
|
||
fnResult := runFn(action.SuccessBy, vm, "action, request, config, params, headers, data, response, result", actionValue, requestValue, configValue, paramsValue, headersValue, dataValue, responseValue, resultValue)
|
||
gojsResult["success"] = u.Bool(fnResult)
|
||
} else {
|
||
gojsResult["success"] = httpResult.Response.StatusCode == 200
|
||
}
|
||
|
||
if gojsResult["success"] == true {
|
||
gojsResult["failedMessage"] = ""
|
||
} else {
|
||
if action.FailedMessageBy != "" {
|
||
fnResult := runFn(action.FailedMessageBy, vm, "action, request, config, params, headers, data, response, result", actionValue, requestValue, configValue, paramsValue, headersValue, dataValue, responseValue, resultValue)
|
||
gojsResult["failedMessage"] = u.String(fnResult)
|
||
} else {
|
||
gojsResult["failedMessage"] = httpResult.Response.Status
|
||
}
|
||
}
|
||
|
||
gojsResult["result"] = result
|
||
return vm.ToValue(gojsResult)
|
||
}
|
||
}
|
||
|
||
func runFn(fnCode string, vm *goja.Runtime, argsParams string, args ...goja.Value) any {
|
||
fnName := "_CLOUD_FN_" + funcNameExcludesMatcher.ReplaceAllString(fnCode, "_")
|
||
fnValue := vm.Get(fnName)
|
||
if fnValue == nil {
|
||
if _, err := vm.RunString("function " + fnName + "(" + argsParams + "){return " + fnCode + "}"); err != nil {
|
||
panic(vm.NewGoError(err))
|
||
}
|
||
fnValue = vm.Get(fnName)
|
||
}
|
||
if fn, ok := goja.AssertFunction(fnValue); ok {
|
||
if r, err := fn(nil, args...); err != nil {
|
||
panic(vm.NewGoError(err))
|
||
} else {
|
||
return r.Export()
|
||
}
|
||
} else {
|
||
panic(vm.NewGoError(errors.New("failed to make function " + fnName)))
|
||
}
|
||
}
|
||
|
||
func makeConfig(logger *log.Logger) {
|
||
if cloudConfigs != nil {
|
||
return
|
||
}
|
||
|
||
// 读取所有的配置文件
|
||
cloudConfigs = map[string]*CloudConfig{}
|
||
fixedCloudConfigs = map[string]map[string]*FixedAction{}
|
||
for _, f := range u.ReadDirN("api") {
|
||
if strings.HasSuffix(f.Name, ".yml") {
|
||
apiName := f.Name[:len(f.Name)-4]
|
||
cloudConf := CloudConfig{}
|
||
if err := u.LoadX(f.FullName, &cloudConf); err != nil {
|
||
logger.Error(err.Error())
|
||
continue
|
||
}
|
||
cloudConfigs[apiName] = &cloudConf
|
||
}
|
||
}
|
||
// 载入补充的配置
|
||
config.LoadConfig("cloud", &cloudConfigs)
|
||
|
||
// 根据配置生成gojs对象
|
||
for cloudName, cloudConf := range cloudConfigs {
|
||
// 解密 & 合并配置
|
||
if cloudConf.Config == nil {
|
||
cloudConf.Config = map[string]any{}
|
||
}
|
||
decryptConfig(cloudConf.Config)
|
||
fixedActions := map[string]*FixedAction{}
|
||
for actionName, apiConf := range cloudConf.Api {
|
||
// var newConf map[string]any
|
||
// if v, ok := cloudConf.ApiConfig[actionName]; ok && v != nil {
|
||
// newConf = *v
|
||
// }
|
||
// if newConf == nil {
|
||
// newConf = map[string]any{}
|
||
// }
|
||
// decryptConfig(newConf)
|
||
// for k, v := range cloudConf.Config {
|
||
// if _, ok := newConf[k]; !ok {
|
||
// newConf[k] = v
|
||
// }
|
||
// }
|
||
decryptConfig(apiConf.Config)
|
||
for k, v := range cloudConf.Config {
|
||
if _, ok := apiConf.Config[k]; !ok {
|
||
apiConf.Config[k] = v
|
||
}
|
||
}
|
||
fixedActions[actionName] = &FixedAction{
|
||
Action: *apiConf,
|
||
// Config: newConf,
|
||
RequiredRequestParams: make([]*RequestParam, 0),
|
||
NotRequiredRequestParams: make([]*RequestParam, 0),
|
||
}
|
||
}
|
||
for actionName, apiConf := range fixedActions {
|
||
// 合并请求参数
|
||
existsRequestParams := map[string]bool{}
|
||
for _, param := range apiConf.RequestParams {
|
||
existsRequestParams[param.Name] = true
|
||
}
|
||
for _, param := range cloudConf.RequestParams {
|
||
if !existsRequestParams[param.Name] {
|
||
existsRequestParams[param.Name] = true
|
||
apiConf.RequestParams = append(apiConf.RequestParams, param)
|
||
}
|
||
}
|
||
for _, param := range apiConf.RequestParams {
|
||
if param.Value == nil {
|
||
if param.Required {
|
||
apiConf.RequiredRequestParams = append(apiConf.RequiredRequestParams, param)
|
||
} else {
|
||
apiConf.NotRequiredRequestParams = append(apiConf.NotRequiredRequestParams, param)
|
||
}
|
||
} else {
|
||
apiConf.NotRequiredRequestParams = append(apiConf.NotRequiredRequestParams, param)
|
||
}
|
||
}
|
||
fixedActions[actionName].RequestParams = apiConf.RequestParams
|
||
fixedActions[actionName].RequiredRequestParams = apiConf.RequiredRequestParams
|
||
fixedActions[actionName].NotRequiredRequestParams = apiConf.NotRequiredRequestParams
|
||
|
||
// 合并请求头
|
||
if apiConf.RequestHeaders == nil {
|
||
apiConf.RequestHeaders = make([]*HeaderParam, 0)
|
||
}
|
||
existsRequestHeaders := map[string]bool{}
|
||
for _, header := range apiConf.RequestHeaders {
|
||
existsRequestHeaders[header.Name] = true
|
||
}
|
||
for _, header := range cloudConf.RequestHeaders {
|
||
if !existsRequestHeaders[header.Name] {
|
||
existsRequestHeaders[header.Name] = true
|
||
apiConf.RequestHeaders = append(apiConf.RequestHeaders, header)
|
||
}
|
||
}
|
||
fixedActions[actionName].RequestHeaders = apiConf.RequestHeaders
|
||
|
||
// 合并响应参数
|
||
if apiConf.Response == nil {
|
||
apiConf.Response = make([]*ResponseParam, 0)
|
||
}
|
||
existsResponse := map[string]bool{}
|
||
for _, resp := range apiConf.Response {
|
||
existsResponse[resp.Name] = true
|
||
}
|
||
for _, resp := range cloudConf.Response {
|
||
if !existsResponse[resp.Name] {
|
||
existsResponse[resp.Name] = true
|
||
apiConf.Response = append(apiConf.Response, resp)
|
||
}
|
||
}
|
||
fixedActions[actionName].Response = apiConf.Response
|
||
|
||
// 处理Sub类型
|
||
makeRequestType(cloudName, actionName, fixedActions[actionName].RequestParams)
|
||
makeResponseType(cloudName, actionName, fixedActions[actionName].Response)
|
||
|
||
// 合并其他
|
||
apiConf.Method = strings.ToUpper(apiConf.Method)
|
||
if apiConf.Method == "" {
|
||
apiConf.Method = "POST"
|
||
}
|
||
apiConf.RequestFormat = strings.ToLower(apiConf.RequestFormat)
|
||
if apiConf.RequestFormat == "" {
|
||
apiConf.RequestFormat = cloudConf.RequestFormat
|
||
}
|
||
apiConf.ResponseFormat = strings.ToLower(apiConf.ResponseFormat)
|
||
if apiConf.ResponseFormat == "" {
|
||
apiConf.ResponseFormat = cloudConf.ResponseFormat
|
||
}
|
||
if apiConf.Timeout == 0 {
|
||
apiConf.Timeout = cloudConf.Timeout
|
||
}
|
||
|
||
// 生成函数参数
|
||
funcParams := make([]string, 0)
|
||
for _, param := range apiConf.RequiredRequestParams {
|
||
if len(param.Sub) > 0 {
|
||
funcParams = append(funcParams, fmt.Sprintf("%s:%s", param.Name, param.Type))
|
||
} else {
|
||
funcParams = append(funcParams, fmt.Sprintf("%s:%s", param.Name, param.Type))
|
||
}
|
||
}
|
||
if apiConf.RequestFormat == "binary" {
|
||
funcParams = append(funcParams, "data:any")
|
||
}
|
||
if apiConf.Method == "WS" {
|
||
funcParams = append(funcParams, "callback:(data:any,type:string)=>boolean")
|
||
}
|
||
if len(apiConf.NotRequiredRequestParams) > 0 {
|
||
funcParams = append(funcParams, fmt.Sprintf("options?:%s_%sParams", cloudName, actionName))
|
||
}
|
||
if len(apiConf.RequestHeaders) > 0 {
|
||
funcParams = append(funcParams, fmt.Sprintf("headers?:%s_%sHeaders", cloudName, actionName))
|
||
}
|
||
apiConf.FuncParams = strings.Join(funcParams, ", ")
|
||
fixedActions[actionName].FuncParams = apiConf.FuncParams
|
||
}
|
||
fixedCloudConfigs[cloudName] = fixedActions
|
||
}
|
||
}
|
||
|
||
func makeRequestType(cloudName, actionName string, params []*RequestParam) {
|
||
for i, param := range params {
|
||
if len(param.Sub) > 0 {
|
||
subType := fmt.Sprintf("%s_%sParams%s", cloudName, actionName, param.Name)
|
||
if param.Type == "Array" {
|
||
params[i].Type = fmt.Sprintf("Array<%s>", subType)
|
||
} else {
|
||
params[i].Type = subType
|
||
}
|
||
makeRequestType(cloudName, actionName, param.Sub)
|
||
}
|
||
}
|
||
}
|
||
|
||
func makeResponseType(cloudName, actionName string, params []*ResponseParam) {
|
||
for i, param := range params {
|
||
if len(param.Sub) > 0 {
|
||
subType := fmt.Sprintf("%s_%sResult%s", cloudName, actionName, param.Name)
|
||
if param.Type == "Array" {
|
||
params[i].Type = fmt.Sprintf("Array<%s>", subType)
|
||
} else {
|
||
params[i].Type = subType
|
||
}
|
||
makeResponseType(cloudName, actionName, param.Sub)
|
||
}
|
||
}
|
||
}
|
||
|
||
func decryptConfig(conf map[string]any) {
|
||
for k, v := range conf {
|
||
if vStr, ok := v.(string); ok && encryptdMatcher.MatchString(vStr) {
|
||
conf[k] = confAes.DecryptUrlBase64ToString(vStr)
|
||
}
|
||
}
|
||
}
|