125 lines
2.5 KiB
Go
125 lines
2.5 KiB
Go
package http
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
|
|
rutil "github.com/unistack-org/micro/v3/util/reflect"
|
|
util "github.com/unistack-org/micro/v3/util/router"
|
|
)
|
|
|
|
var (
|
|
templateCache = make(map[string]util.Template)
|
|
mu sync.RWMutex
|
|
)
|
|
|
|
func newPathRequest(path string, method string, body string, msg interface{}) (string, interface{}, error) {
|
|
// parse via https://github.com/googleapis/googleapis/blob/master/google/api/http.proto definition
|
|
tpl, err := newTemplate(path)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
if len(tpl.Fields) == 0 {
|
|
return path, msg, nil
|
|
}
|
|
|
|
fieldsmap := make(map[string]string, len(tpl.Fields))
|
|
for _, v := range tpl.Fields {
|
|
fieldsmap[v] = ""
|
|
}
|
|
|
|
nmsg, err := rutil.Zero(msg)
|
|
if err != nil {
|
|
return "", nil, err
|
|
}
|
|
|
|
// we cant switch on message and use proto helpers, to avoid dependency to protobuf
|
|
tmsg := reflect.ValueOf(msg)
|
|
if tmsg.Kind() == reflect.Ptr {
|
|
tmsg = tmsg.Elem()
|
|
}
|
|
|
|
tnmsg := reflect.ValueOf(nmsg)
|
|
if tnmsg.Kind() == reflect.Ptr {
|
|
tnmsg = tnmsg.Elem()
|
|
}
|
|
|
|
values := make(map[string]string)
|
|
// copy cycle
|
|
for i := 0; i < tmsg.NumField(); i++ {
|
|
val := tmsg.Field(i)
|
|
if val.IsZero() {
|
|
continue
|
|
}
|
|
fld := tmsg.Type().Field(i)
|
|
lfield := strings.ToLower(fld.Name)
|
|
if _, ok := fieldsmap[lfield]; ok {
|
|
fieldsmap[lfield] = fmt.Sprintf("%v", val.Interface())
|
|
} else if body == "*" || body == lfield && method != http.MethodGet {
|
|
tnmsg.Field(i).Set(val)
|
|
} else if method == http.MethodGet {
|
|
values[lfield] = fmt.Sprintf("%v", val.Interface())
|
|
}
|
|
}
|
|
|
|
// check not filled stuff
|
|
for k, v := range fieldsmap {
|
|
if v == "" {
|
|
return "", nil, fmt.Errorf("path param %s not filled %s", k, v)
|
|
}
|
|
}
|
|
|
|
var b strings.Builder
|
|
for _, fld := range tpl.Pool {
|
|
_, _ = b.WriteRune('/')
|
|
if v, ok := fieldsmap[fld]; ok {
|
|
_, _ = b.WriteString(v)
|
|
} else {
|
|
_, _ = b.WriteString(fld)
|
|
}
|
|
}
|
|
|
|
if method == http.MethodGet {
|
|
idx := 0
|
|
for k, v := range values {
|
|
if idx == 0 {
|
|
_, _ = b.WriteRune('?')
|
|
} else {
|
|
_, _ = b.WriteRune('&')
|
|
}
|
|
_, _ = b.WriteString(k)
|
|
_, _ = b.WriteRune('=')
|
|
_, _ = b.WriteString(v)
|
|
idx++
|
|
}
|
|
}
|
|
|
|
return b.String(), nmsg, nil
|
|
}
|
|
|
|
func newTemplate(path string) (util.Template, error) {
|
|
mu.RLock()
|
|
tpl, ok := templateCache[path]
|
|
if ok {
|
|
mu.RUnlock()
|
|
return tpl, nil
|
|
}
|
|
mu.RUnlock()
|
|
|
|
rule, err := util.Parse(path)
|
|
if err != nil {
|
|
return tpl, err
|
|
}
|
|
|
|
tpl = rule.Compile()
|
|
mu.Lock()
|
|
templateCache[path] = tpl
|
|
mu.Unlock()
|
|
|
|
return tpl, nil
|
|
}
|