284 lines
9.1 KiB
Go
284 lines
9.1 KiB
Go
package js
|
|
|
|
import (
|
|
"apigo.cc/apigo/gojs"
|
|
"apigo.cc/apigo/gojs/dop251/goja"
|
|
"bytes"
|
|
_ "embed"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"github.com/ssgo/u"
|
|
"gopkg.in/yaml.v3"
|
|
"strings"
|
|
"text/template"
|
|
"time"
|
|
)
|
|
|
|
//go:embed util.ts
|
|
var utilTS string
|
|
|
|
func RegisterUtilModel() {
|
|
obj := map[string]any{
|
|
"json": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
|
|
return vm.ToValue(string(r))
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"jsonP": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
|
|
r1 := bytes.Buffer{}
|
|
if err2 := json.Indent(&r1, r, "", " "); err2 == nil {
|
|
return vm.ToValue(string(r))
|
|
} else {
|
|
return vm.ToValue(string(r))
|
|
}
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"unJson": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
var r any
|
|
if err := json.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"yaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := yaml.Marshal(args.Arguments[0].Export()); err == nil {
|
|
return vm.ToValue(string(r))
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"unYaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
var r any
|
|
if err := yaml.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"save": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(2)
|
|
filename := args.Str(0)
|
|
var data []byte
|
|
var err error
|
|
if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
|
|
data, err = yaml.Marshal(args.Any(1))
|
|
} else {
|
|
data, err = json.Marshal(args.Any(1))
|
|
}
|
|
if err == nil {
|
|
if err = u.WriteFileBytes(gojs.FindPath(vm, filename), data); err != nil {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
return nil
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
filename := args.Str(0)
|
|
if data, err := u.ReadFileBytes(gojs.FindPath(vm, filename)); err == nil {
|
|
var r any
|
|
if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
|
|
err = yaml.Unmarshal(data, &r)
|
|
} else {
|
|
err = json.Unmarshal(data, &r)
|
|
}
|
|
if err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"base64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.Base64(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"unBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.UnBase64(args.Str(0)))
|
|
},
|
|
"urlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.UrlBase64String(args.Str(0)))
|
|
},
|
|
"unUrlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.UnUrlBase64(args.Str(0)))
|
|
},
|
|
"hex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(hex.EncodeToString(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"unHex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := hex.DecodeString(args.Str(0)); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"aes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(3)
|
|
if r, err := u.EncryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"unAes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(3)
|
|
if r, err := u.DecryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"gzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := u.Gzip(u.Bytes(args.Arguments[0].Export())); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"gunzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
if r, err := u.Gunzip(u.Bytes(args.Arguments[0].Export())); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
return vm.ToValue(u.Id12())
|
|
},
|
|
"uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
return vm.ToValue(u.UniqueId())
|
|
},
|
|
"token": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
size := 20
|
|
if len(argsIn.Arguments) > 0 {
|
|
size = u.Int(argsIn.Arguments[0].Export())
|
|
}
|
|
return vm.ToValue(u.MakeToken(size))
|
|
},
|
|
"md5": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.MD5(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"sha1": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.Sha1(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"sha256": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.Sha256(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"sha512": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(u.Sha512(u.Bytes(args.Arguments[0].Export())))
|
|
},
|
|
"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(2)
|
|
var functions = map[string]any{}
|
|
if len(argsIn.Arguments) > 2 {
|
|
obj := argsIn.Arguments[2].ToObject(vm)
|
|
for _, k := range obj.Keys() {
|
|
v := obj.Get(k)
|
|
if cb, ok := goja.AssertFunction(v); ok {
|
|
functions[k] = func(in string) string {
|
|
if r, err := cb(argsIn.This, vm.ToValue(in)); err == nil {
|
|
return r.String()
|
|
}
|
|
return ""
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
buf := bytes.NewBuffer(make([]byte, 0))
|
|
var err error
|
|
tpl := template.New("tpl")
|
|
if len(functions) > 0 {
|
|
tpl.Funcs(functions)
|
|
}
|
|
if tpl, err = tpl.Parse(args.Str(0)); err == nil {
|
|
err = tpl.Execute(buf, args.Arguments[1].Export())
|
|
}
|
|
if err != nil {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
return vm.ToValue(buf.String())
|
|
},
|
|
"shell": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
a := make([]string, len(args.Arguments)-1)
|
|
for i := 1; i < len(args.Arguments); i++ {
|
|
a[i-1] = args.Str(i)
|
|
}
|
|
|
|
if r, err := u.RunCommand(args.Str(0), a...); err == nil {
|
|
return vm.ToValue(r)
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"toDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(time.UnixMilli(args.Int64(0)).Format("2006-01-02 15:04:05"))
|
|
},
|
|
"fromDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
timeStr := args.Str(0)
|
|
if len(timeStr) > 19 {
|
|
timeStr = timeStr[0:19]
|
|
}
|
|
if strings.ContainsRune(timeStr, 'T') {
|
|
timeStr = strings.ReplaceAll(timeStr, "T", " ")
|
|
}
|
|
if tm, err := time.ParseInLocation("2006-01-02 15:04:05", timeStr, time.Local); err == nil {
|
|
return vm.ToValue(tm.UnixMilli())
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
"toDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
return vm.ToValue(time.UnixMilli(args.Int64(0)).Format("2006-01-02"))
|
|
},
|
|
"fromDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
|
|
args := gojs.MakeArgs(&argsIn, vm).Check(1)
|
|
timeStr := args.Str(0)
|
|
if len(timeStr) > 10 {
|
|
timeStr = timeStr[0:10]
|
|
}
|
|
if tm, err := time.ParseInLocation("2006-01-02", timeStr, time.Local); err == nil {
|
|
return vm.ToValue(tm.UnixMilli())
|
|
} else {
|
|
panic(vm.NewGoError(err))
|
|
}
|
|
},
|
|
}
|
|
|
|
gojs.Register("util", gojs.Module{
|
|
Object: obj,
|
|
TsCode: utilTS,
|
|
Example: "",
|
|
})
|
|
}
|