209 lines
3.3 KiB
Go
209 lines
3.3 KiB
Go
package json
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
simple "github.com/bitly/go-simplejson"
|
|
"github.com/micro/go-micro/config/reader"
|
|
"github.com/micro/go-micro/config/source"
|
|
)
|
|
|
|
type jsonValues struct {
|
|
ch *source.ChangeSet
|
|
sj *simple.Json
|
|
}
|
|
|
|
type jsonValue struct {
|
|
*simple.Json
|
|
}
|
|
|
|
func newValues(ch *source.ChangeSet) (reader.Values, error) {
|
|
sj := simple.New()
|
|
data, _ := reader.ReplaceEnvVars(ch.Data)
|
|
if err := sj.UnmarshalJSON(data); err != nil {
|
|
sj.SetPath(nil, string(ch.Data))
|
|
}
|
|
return &jsonValues{ch, sj}, nil
|
|
}
|
|
|
|
func newValue(s *simple.Json) reader.Value {
|
|
if s == nil {
|
|
s = simple.New()
|
|
}
|
|
return &jsonValue{s}
|
|
}
|
|
|
|
func (j *jsonValues) Get(path ...string) reader.Value {
|
|
return &jsonValue{j.sj.GetPath(path...)}
|
|
}
|
|
|
|
func (j *jsonValues) Del(path ...string) {
|
|
// delete the tree?
|
|
if len(path) == 0 {
|
|
j.sj = simple.New()
|
|
return
|
|
}
|
|
|
|
if len(path) == 1 {
|
|
j.sj.Del(path[0])
|
|
return
|
|
}
|
|
|
|
vals := j.sj.GetPath(path[:len(path)-1]...)
|
|
vals.Del(path[len(path)-1])
|
|
j.sj.SetPath(path[:len(path)-1], vals.Interface())
|
|
return
|
|
}
|
|
|
|
func (j *jsonValues) Set(val interface{}, path ...string) {
|
|
j.sj.SetPath(path, val)
|
|
}
|
|
|
|
func (j *jsonValues) Bytes() []byte {
|
|
b, _ := j.sj.MarshalJSON()
|
|
return b
|
|
}
|
|
|
|
func (j *jsonValues) Map() map[string]interface{} {
|
|
m, _ := j.sj.Map()
|
|
return m
|
|
}
|
|
|
|
func (j *jsonValues) Scan(v interface{}) error {
|
|
b, err := j.sj.MarshalJSON()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.Unmarshal(b, v)
|
|
}
|
|
|
|
func (j *jsonValues) String() string {
|
|
return "json"
|
|
}
|
|
|
|
func (j *jsonValue) Bool(def bool) bool {
|
|
b, err := j.Json.Bool()
|
|
if err == nil {
|
|
return b
|
|
}
|
|
|
|
str, ok := j.Interface().(string)
|
|
if !ok {
|
|
return def
|
|
}
|
|
|
|
b, err = strconv.ParseBool(str)
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
return b
|
|
}
|
|
|
|
func (j *jsonValue) Int(def int) int {
|
|
i, err := j.Json.Int()
|
|
if err == nil {
|
|
return i
|
|
}
|
|
|
|
str, ok := j.Interface().(string)
|
|
if !ok {
|
|
return def
|
|
}
|
|
|
|
i, err = strconv.Atoi(str)
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
return i
|
|
}
|
|
|
|
func (j *jsonValue) String(def string) string {
|
|
return j.Json.MustString(def)
|
|
}
|
|
|
|
func (j *jsonValue) Float64(def float64) float64 {
|
|
f, err := j.Json.Float64()
|
|
if err == nil {
|
|
return f
|
|
}
|
|
|
|
str, ok := j.Interface().(string)
|
|
if !ok {
|
|
return def
|
|
}
|
|
|
|
f, err = strconv.ParseFloat(str, 64)
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
return f
|
|
}
|
|
|
|
func (j *jsonValue) Duration(def time.Duration) time.Duration {
|
|
v, err := j.Json.String()
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
value, err := time.ParseDuration(v)
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
return value
|
|
}
|
|
|
|
func (j *jsonValue) StringSlice(def []string) []string {
|
|
v, err := j.Json.String()
|
|
if err == nil {
|
|
sl := strings.Split(v, ",")
|
|
if len(sl) > 1 {
|
|
return sl
|
|
}
|
|
}
|
|
return j.Json.MustStringArray(def)
|
|
}
|
|
|
|
func (j *jsonValue) StringMap(def map[string]string) map[string]string {
|
|
m, err := j.Json.Map()
|
|
if err != nil {
|
|
return def
|
|
}
|
|
|
|
res := map[string]string{}
|
|
|
|
for k, v := range m {
|
|
res[k] = fmt.Sprintf("%v", v)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (j *jsonValue) Scan(v interface{}) error {
|
|
b, err := j.Json.MarshalJSON()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.Unmarshal(b, v)
|
|
}
|
|
|
|
func (j *jsonValue) Bytes() []byte {
|
|
b, err := j.Json.Bytes()
|
|
if err != nil {
|
|
// try return marshalled
|
|
b, err = j.Json.MarshalJSON()
|
|
if err != nil {
|
|
return []byte{}
|
|
}
|
|
return b
|
|
}
|
|
return b
|
|
}
|