252 lines
6.6 KiB
Go
252 lines
6.6 KiB
Go
// Package json_tool ...
|
|
//
|
|
// Description : json_tool ...
|
|
//
|
|
// Author : go_developer@163.com<张德满>
|
|
//
|
|
// Date : 2022/01/22 9:19 PM
|
|
package json_tool
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"git.zhangdeman.cn/zhangdeman/gopkg/util"
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/tidwall/gjson"
|
|
|
|
"github.com/Jeffail/gabs"
|
|
)
|
|
|
|
// FilterDataRule 参数过滤规则
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/22 9:44 PM
|
|
type FilterDataRule struct {
|
|
SourceKey string // 原始数据路径
|
|
MapKey string // 提取后映射到的数据路径
|
|
DefaultValue interface{} // 原始数据路径不存在时的默认值
|
|
WithDefault bool // 是否使用默认值
|
|
}
|
|
|
|
// NewDataFilter 获取数据过滤方法实例
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/22 9:50 PM
|
|
func NewDataFilter(source string, filterRule []*FilterDataRule) *DataFilter {
|
|
return &DataFilter{
|
|
source: source,
|
|
filterRule: filterRule,
|
|
hasDealDiffPath: make(map[string]string),
|
|
}
|
|
}
|
|
|
|
// DataFilter 数据过滤
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/22 9:20 PM
|
|
type DataFilter struct {
|
|
source string
|
|
filterRule []*FilterDataRule
|
|
itemKeyToSlice bool
|
|
hasDealDiffPath map[string]string
|
|
}
|
|
|
|
// Filter 数据过滤
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/22 9:36 PM
|
|
func (df *DataFilter) Filter() (string, error) {
|
|
var (
|
|
jsonObject *gabs.Container
|
|
err error
|
|
)
|
|
// 格式化映射规则
|
|
df.formatRule()
|
|
// 记录 obj => slice 的数据类型
|
|
obg2slice := make(map[string]string)
|
|
// 创建数据的根结点
|
|
jsonObject = gabs.New()
|
|
for _, item := range df.filterRule {
|
|
// 数据源路径不识数组, 多个key写入到同一个map key, 并且map key 不是以[]结尾, 自动格式化
|
|
// 目标位置, 是一个数组
|
|
if df.pathIsArrayValue(item.MapKey) {
|
|
realMapKey := strings.ReplaceAll(item.MapKey, ".[]", "")
|
|
if exist := jsonObject.Exists(realMapKey); !exist {
|
|
if _, err = jsonObject.ArrayP(realMapKey); nil != err {
|
|
return "", err
|
|
}
|
|
}
|
|
valueResult := gjson.Get(df.source, item.SourceKey)
|
|
dataType := df.getValueType(valueResult)
|
|
if _, exist := obg2slice[realMapKey]; !exist {
|
|
obg2slice[realMapKey] = dataType
|
|
}
|
|
if dataType != obg2slice[realMapKey] {
|
|
return "", errors.New(realMapKey + " 预期写入的字段数据类型不一致")
|
|
}
|
|
if err = jsonObject.ArrayAppend(valueResult.Value(), realMapKey); nil != err {
|
|
return "", err
|
|
}
|
|
continue
|
|
}
|
|
sourceSearchResult := gjson.Get(df.source, item.SourceKey)
|
|
if !sourceSearchResult.Exists() {
|
|
if item.WithDefault {
|
|
if _, err = jsonObject.SetP(item.DefaultValue, item.MapKey); nil != err {
|
|
return "", err
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
if _, err = jsonObject.SetP(sourceSearchResult.Value(), item.MapKey); nil != err {
|
|
return "", err
|
|
}
|
|
}
|
|
return jsonObject.String(), nil
|
|
}
|
|
|
|
// UserItemToSlice 支持多个独立的字段合并到slice中
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 3:27 PM 2022/1/24
|
|
func (df *DataFilter) UserItemToSlice() {
|
|
df.itemKeyToSlice = true
|
|
}
|
|
|
|
// getValueType 获取数据类型
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/23 12:45 AM
|
|
func (df *DataFilter) getValueType(valueResult gjson.Result) string {
|
|
dataTypeVal := reflect.TypeOf(valueResult.Value())
|
|
if nil == dataTypeVal {
|
|
return "NIL"
|
|
}
|
|
dataType := dataTypeVal.String()
|
|
if strings.Contains(dataType, "int") {
|
|
return "int64"
|
|
}
|
|
if strings.Contains(dataType, "float") {
|
|
return "float64"
|
|
}
|
|
return dataType
|
|
}
|
|
|
|
// pathIsArrayValue 判断路径是否为数组值
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022/1/23 12:56 AM
|
|
func (df *DataFilter) pathIsArrayValue(path string) bool {
|
|
return strings.Contains(path, "[]")
|
|
}
|
|
|
|
// formatRule 格式化映射规则
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2:43 PM 2022/1/24
|
|
func (df *DataFilter) formatRule() {
|
|
mapKeyCnt := make(map[string]int)
|
|
for _, item := range df.filterRule {
|
|
// source 为数组, map 不是
|
|
if df.pathIsArrayValue(item.SourceKey) {
|
|
if !df.pathIsArrayValue(item.MapKey) {
|
|
item.MapKey = item.MapKey + ".[]"
|
|
} else {
|
|
// source 是数组, map也是数组, 检测数组层级匹配
|
|
sourcePathArr := strings.Split(item.SourceKey, ".[].")
|
|
mapPathArr := strings.Split(item.MapKey, ".[].")
|
|
if len(sourcePathArr) == len(mapPathArr) {
|
|
// 数组层级深度相同,无需特殊处理
|
|
continue
|
|
}
|
|
// 数组层级深度不同,重新对对齐数据
|
|
diffArr := sourcePathArr[0 : len(sourcePathArr)-len(mapPathArr)+1]
|
|
if newPath := df.dealDiffArr(diffArr); len(newPath) > 0 {
|
|
sourcePathArr[len(sourcePathArr)-len(mapPathArr)] = newPath
|
|
item.SourceKey = strings.Join(sourcePathArr[len(sourcePathArr)-len(mapPathArr):], ".[].")
|
|
}
|
|
}
|
|
} else {
|
|
if df.pathIsArrayValue(item.MapKey) {
|
|
continue
|
|
}
|
|
// source 不是数组, map 也不是
|
|
if !df.itemKeyToSlice {
|
|
continue
|
|
}
|
|
mapKeyCnt[item.MapKey]++
|
|
}
|
|
}
|
|
// 多个source指向一个map,自动转化为list
|
|
for _, item := range df.filterRule {
|
|
if mapKeyCnt[item.MapKey] > 1 {
|
|
item.MapKey = item.MapKey + ".[]"
|
|
}
|
|
}
|
|
}
|
|
|
|
// dealDiffArr 提取数据映射关系
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 5:04 下午 2022/1/25
|
|
func (df *DataFilter) dealDiffArr(diffArr []string) string {
|
|
if len(diffArr) == 0 {
|
|
return ""
|
|
}
|
|
diffArrStr := strings.Join(diffArr, ".[].")
|
|
if _, exist := df.hasDealDiffPath[diffArrStr]; exist {
|
|
// 已经处理过, 不再重复处理
|
|
return df.hasDealDiffPath[diffArrStr]
|
|
}
|
|
|
|
// 没处理过, 开始处理
|
|
jsonResultList := df.getArrayData(df.source, diffArr)
|
|
if len(jsonResultList) == 0 {
|
|
return ""
|
|
}
|
|
newPath := util.GenRandomString("", 8)
|
|
var result map[string]interface{}
|
|
_ = json.Unmarshal([]byte(df.source), &result)
|
|
JSONObject, _ := gabs.Consume(result)
|
|
_, _ = JSONObject.ArrayP(newPath)
|
|
for _, item := range jsonResultList {
|
|
if err := JSONObject.ArrayAppendP(item.Value(), newPath); nil != err {
|
|
fmt.Println(err.Error())
|
|
}
|
|
}
|
|
|
|
df.source = JSONObject.String()
|
|
df.hasDealDiffPath[diffArrStr] = newPath
|
|
return newPath
|
|
}
|
|
|
|
// getArrayData 获取数据
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2:22 下午 2022/1/26
|
|
func (df *DataFilter) getArrayData(source string, pathArr []string) []gjson.Result {
|
|
if len(pathArr) == 1 {
|
|
return gjson.Get(source, pathArr[0]).Array()
|
|
}
|
|
resultList := make([]gjson.Result, 0)
|
|
dataList := gjson.Get(source, pathArr[0]).Array()
|
|
for idx := 0; idx < len(dataList); idx++ {
|
|
resultList = append(resultList, df.getArrayData(dataList[idx].String(), pathArr[1:])...)
|
|
}
|
|
return resultList
|
|
}
|