125 lines
2.5 KiB
Go
Raw Normal View History

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
}