123 lines
2.5 KiB
Go
123 lines
2.5 KiB
Go
package utils
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
)
|
|
|
|
func GetConcretValue(value reflect.Value) reflect.Value {
|
|
for {
|
|
if value.Kind() == reflect.Interface || value.Kind() == reflect.Ptr {
|
|
value = value.Elem()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return value
|
|
}
|
|
|
|
func DictKeysMan(data interface{}, keysToRemove []string, keysToKeep []string) interface{} {
|
|
if data == nil || (keysToKeep == nil && keysToRemove == nil) {
|
|
return data
|
|
}
|
|
|
|
var keysToRemoveMap map[string]int
|
|
var keysToKeepMap map[string]int
|
|
if keysToKeep != nil {
|
|
keysToKeepMap = make(map[string]int)
|
|
for _, v := range keysToKeep {
|
|
keysToKeepMap[v] = 1
|
|
}
|
|
} else if keysToRemove != nil {
|
|
keysToRemoveMap = make(map[string]int)
|
|
for _, v := range keysToRemove {
|
|
keysToRemoveMap[v] = 1
|
|
}
|
|
}
|
|
|
|
dataIsSlice := true
|
|
valueOfData := reflect.ValueOf(data)
|
|
if valueOfData.Kind() != reflect.Slice {
|
|
dataIsSlice = false
|
|
valueOfData = reflect.ValueOf([]interface{}{data})
|
|
} else if valueOfData.Len() == 0 {
|
|
return data
|
|
}
|
|
|
|
retVal := make([]interface{}, valueOfData.Len())
|
|
|
|
for index := 0; index < valueOfData.Len(); index++ {
|
|
realV := GetConcretValue(valueOfData.Index(index))
|
|
if keysToRemoveMap != nil || keysToKeepMap != nil {
|
|
mapV := make(map[string]interface{})
|
|
for _, key := range realV.MapKeys() {
|
|
fieldName := key.String()
|
|
wantThisField := true
|
|
if keysToKeepMap != nil {
|
|
if _, ok := keysToKeepMap[fieldName]; !ok {
|
|
wantThisField = false
|
|
}
|
|
} else if keysToRemoveMap != nil {
|
|
if _, ok := keysToRemoveMap[fieldName]; ok {
|
|
wantThisField = false
|
|
}
|
|
}
|
|
if wantThisField {
|
|
mapV[fieldName] = GetConcretValue(realV.MapIndex(key)).Interface()
|
|
}
|
|
}
|
|
retVal[index] = mapV
|
|
} else {
|
|
retVal[index] = realV.Interface()
|
|
}
|
|
}
|
|
|
|
if !dataIsSlice {
|
|
return retVal[0]
|
|
}
|
|
return retVal
|
|
}
|
|
|
|
func UnmarshalUseNumber(data []byte, result interface{}) error {
|
|
d := json.NewDecoder(bytes.NewReader(data))
|
|
d.UseNumber()
|
|
return d.Decode(result)
|
|
}
|
|
|
|
func MustMarshal(obj interface{}) []byte {
|
|
byteArr, err := json.Marshal(obj)
|
|
if err != nil {
|
|
panic(fmt.Sprintf("err when Marshal obj:%v", obj))
|
|
}
|
|
|
|
return byteArr
|
|
}
|
|
|
|
func Bool2String(value bool) string {
|
|
if value {
|
|
return "true"
|
|
}
|
|
return "false"
|
|
}
|
|
|
|
func Str2Int(str string) int {
|
|
retVal, _ := strconv.Atoi(str)
|
|
return retVal
|
|
}
|
|
|
|
func Str2Int64(str string) int64 {
|
|
retVal, _ := strconv.ParseInt(str, 10, 64)
|
|
return retVal
|
|
}
|
|
|
|
func Int64ToStr(value int64) string {
|
|
return strconv.FormatInt(value, 10)
|
|
}
|
|
|
|
func Int2Str(value int) string {
|
|
return strconv.Itoa(value)
|
|
}
|