139 lines
2.6 KiB
Go
139 lines
2.6 KiB
Go
package params
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"google.golang.org/protobuf/types/known/structpb"
|
|
)
|
|
|
|
// Reader provides typed helpers around a Struct param payload.
|
|
type Reader struct {
|
|
raw map[string]interface{}
|
|
}
|
|
|
|
// New builds a Reader for the provided struct, tolerating nil inputs.
|
|
func New(params *structpb.Struct) Reader {
|
|
if params == nil {
|
|
return Reader{}
|
|
}
|
|
return Reader{raw: params.AsMap()}
|
|
}
|
|
|
|
// Value returns the raw value and whether it was present.
|
|
func (r Reader) Value(key string) (interface{}, bool) {
|
|
if r.raw == nil {
|
|
return nil, false
|
|
}
|
|
value, ok := r.raw[key]
|
|
return value, ok
|
|
}
|
|
|
|
// String returns the string value for a key, or "" if missing/not a string.
|
|
func (r Reader) String(key string) string {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return ""
|
|
}
|
|
switch v := value.(type) {
|
|
case string:
|
|
return v
|
|
case fmt.Stringer:
|
|
return v.String()
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// Bool returns the bool value for a key, or false when missing/not a bool.
|
|
func (r Reader) Bool(key string) bool {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return false
|
|
}
|
|
switch v := value.(type) {
|
|
case bool:
|
|
return v
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Int64 returns the int64 value for a key with a presence flag.
|
|
func (r Reader) Int64(key string) (int64, bool) {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
switch v := value.(type) {
|
|
case int64:
|
|
return v, true
|
|
case int32:
|
|
return int64(v), true
|
|
case int:
|
|
return int64(v), true
|
|
case float64:
|
|
return int64(v), true
|
|
case float32:
|
|
return int64(v), true
|
|
default:
|
|
return 0, false
|
|
}
|
|
}
|
|
|
|
// Float64 returns the float64 value for a key with a presence flag.
|
|
func (r Reader) Float64(key string) (float64, bool) {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
switch v := value.(type) {
|
|
case float64:
|
|
return v, true
|
|
case float32:
|
|
return float64(v), true
|
|
case int:
|
|
return float64(v), true
|
|
case int64:
|
|
return float64(v), true
|
|
default:
|
|
return 0, false
|
|
}
|
|
}
|
|
|
|
// Map returns a nested object value as a map.
|
|
func (r Reader) Map(key string) map[string]interface{} {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
if m, ok := value.(map[string]interface{}); ok {
|
|
return m
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// List returns a list value as a slice.
|
|
func (r Reader) List(key string) []interface{} {
|
|
value, ok := r.Value(key)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
if list, ok := value.([]interface{}); ok {
|
|
return list
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// StringMap converts a nested map into a string map.
|
|
func (r Reader) StringMap(key string) map[string]string {
|
|
raw := r.Map(key)
|
|
if len(raw) == 0 {
|
|
return nil
|
|
}
|
|
out := make(map[string]string, len(raw))
|
|
for k, v := range raw {
|
|
out[k] = fmt.Sprint(v)
|
|
}
|
|
return out
|
|
}
|