346 lines
9.6 KiB
Go
346 lines
9.6 KiB
Go
// Package filter ...
|
|
//
|
|
// Description : filter ...
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 2022-07-04 17:47
|
|
package filter
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"git.zhangdeman.cn/zhangdeman/consts"
|
|
"git.zhangdeman.cn/zhangdeman/serialize"
|
|
"git.zhangdeman.cn/zhangdeman/wrapper"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"github.com/tidwall/gjson"
|
|
"github.com/tidwall/sjson"
|
|
|
|
"errors"
|
|
)
|
|
|
|
// NewFilter 过滤器实例
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 11:54 2022/7/4
|
|
func NewFilter(sourceData string, filterRuleList []MapRule) *filter {
|
|
return &filter{
|
|
sourceData: sourceData,
|
|
formatResult: "{}",
|
|
filterRuleList: filterRuleList,
|
|
}
|
|
}
|
|
|
|
// filter 数据过滤
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 11:58 2022/7/4
|
|
type filter struct {
|
|
sourceData string
|
|
formatResult string
|
|
filterRuleList []MapRule
|
|
}
|
|
|
|
// Deal ...
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 11:59 2022/7/4
|
|
func (f *filter) Deal() error {
|
|
var (
|
|
err error
|
|
formatVal any
|
|
)
|
|
|
|
for _, rule := range f.filterRuleList {
|
|
if f.IsArray(rule) {
|
|
// 对于list的处理
|
|
if err = f.handleArray(rule); nil != err {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
sourceResult := gjson.Get(f.sourceData, rule.SourcePath)
|
|
if formatVal, err = f.getValue(rule.DataType, sourceResult, rule.DefaultValue); nil != err {
|
|
return fmt.Errorf("%s = %v can not convert to %s : %s", rule.SourcePath, sourceResult.Value(), rule.DataType, err.Error())
|
|
}
|
|
if reflect.TypeOf(formatVal).Kind() == reflect.Map {
|
|
// 获取的数据是map类型, 处理数据覆盖
|
|
// eg : 配置如下两个规则 process.id(string) 、process(map[string]any)
|
|
// 若输入数据的process.id为int类型, 则格式化后的process.id必为 string, 应为 process.id 规则的控制更精细
|
|
gjsonVal := gjson.Get(f.formatResult, rule.TargetPath)
|
|
if gjsonVal.Exists() && gjsonVal.IsObject() {
|
|
var (
|
|
existRes = map[string]any{}
|
|
formatRes = map[string]any{}
|
|
)
|
|
// 已存在, 且是对象
|
|
_ = serialize.JSON.UnmarshalWithNumber([]byte(gjsonVal.String()), &existRes)
|
|
if err = serialize.JSON.Transition(formatVal, &formatRes); nil != err {
|
|
return errors.New("conflict data path config deal fail : " + err.Error())
|
|
}
|
|
for k, v := range existRes {
|
|
formatRes[k] = v
|
|
}
|
|
formatVal = formatRes // 重新赋值 formatVal
|
|
}
|
|
}
|
|
if f.formatResult, err = sjson.Set(f.formatResult, rule.TargetPath, formatVal); nil != err {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// IsArray 判断是否为数组
|
|
//
|
|
// Author : zhangdeman001@ke.com<张德满>
|
|
//
|
|
// Date : 17:48 2023/1/1
|
|
func (f *filter) IsArray(rule MapRule) bool {
|
|
return strings.Contains(rule.SourcePath, "[]")
|
|
}
|
|
|
|
// handleArray 处理数组(最复杂的场景)
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 17:41 2023/1/1
|
|
func (f *filter) handleArray(rule MapRule) error {
|
|
var (
|
|
err error
|
|
)
|
|
|
|
sourcePathArray := strings.Split(rule.SourcePath, "[]")
|
|
for idx, item := range sourcePathArray {
|
|
sourcePathArray[idx] = strings.Trim(item, ".")
|
|
}
|
|
mapPathArray := strings.Split(strings.TrimRight(rule.TargetPath, ".[]"), "[]")
|
|
for idx, item := range mapPathArray {
|
|
mapPathArray[idx] = strings.Trim(item, ".")
|
|
}
|
|
if len(sourcePathArray) != len(mapPathArray) {
|
|
if len(mapPathArray) != 1 {
|
|
return errors.New("map rule is invalid")
|
|
}
|
|
// 提取某一个list下的字段, 组成一个list
|
|
res := make([]string, 0)
|
|
if len(sourcePathArray[0]) == 0 {
|
|
f.getAllFinalData(&res, gjson.Parse(f.sourceData).Array(), sourcePathArray[1:])
|
|
} else {
|
|
f.getAllFinalData(&res, gjson.Get(f.sourceData, sourcePathArray[0]).Array(), sourcePathArray[1:])
|
|
}
|
|
if f.formatResult, err = sjson.Set(f.formatResult, mapPathArray[0], res); nil != err {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// extraFinalResult 提取全部最底层结果
|
|
//
|
|
// Author : zhangdeman001@ke.com<张德满>
|
|
//
|
|
// Date : 14:00 2023/1/2
|
|
func (f *filter) getAllFinalData(res *[]string, resultList []gjson.Result, pathArr []string) {
|
|
if len(pathArr) == 1 {
|
|
for _, item := range resultList {
|
|
*res = append(*res, item.Get(pathArr[0]).String())
|
|
}
|
|
return
|
|
}
|
|
for _, item := range resultList {
|
|
f.getAllFinalData(res, item.Array(), pathArr[1:])
|
|
}
|
|
return
|
|
}
|
|
|
|
// String 获取格式化之后的字符串
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 21:18 2022/12/31
|
|
func (f *filter) String() string {
|
|
return f.formatResult
|
|
}
|
|
|
|
// Byte 获取格式化之后的字节数组
|
|
//
|
|
// Author : zhangdeman001@ke.com<张德满>
|
|
//
|
|
// Date : 21:18 2022/12/31
|
|
func (f *filter) Byte() []byte {
|
|
return []byte(f.String())
|
|
}
|
|
|
|
// Parse 解析返回结果
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 21:20 2022/12/31
|
|
func (f *filter) Parse(receiver interface{}) error {
|
|
if nil == receiver {
|
|
return errors.New("receiver is nil")
|
|
}
|
|
return json.Unmarshal(f.Byte(), receiver)
|
|
}
|
|
|
|
// getValue 获取值
|
|
//
|
|
// Author : go_developer@163.com<白茶清欢>
|
|
//
|
|
// Date : 12:25 2022/7/4
|
|
func (f *filter) getValue(dataType consts.DataType, sourceValue gjson.Result, defaultValue string) (any, error) {
|
|
sourceValueStr := defaultValue
|
|
if sourceValue.Exists() {
|
|
str := sourceValue.String()
|
|
if len(str) > 0 {
|
|
sourceValueStr = str
|
|
}
|
|
}
|
|
|
|
strVal := wrapper.String(sourceValueStr)
|
|
|
|
switch dataType {
|
|
case consts.DataTypeInt:
|
|
intVal := strVal.ToInt()
|
|
return intVal.Value, intVal.Err
|
|
case consts.DataTypeUint:
|
|
uintVal := strVal.ToUint64()
|
|
return uintVal.Value, uintVal.Err
|
|
case consts.DataTypeBool:
|
|
boolVal := strVal.ToBool()
|
|
return boolVal.Value, boolVal.Err
|
|
case consts.DataTypeFloat:
|
|
floatVal := strVal.ToFloat64()
|
|
return floatVal.Value, floatVal.Err
|
|
case consts.DataTypeString:
|
|
return strVal.Value(), nil
|
|
case consts.DataTypeAny:
|
|
if sourceValue.Exists() {
|
|
return sourceValue.Value(), nil
|
|
}
|
|
return defaultValue, nil
|
|
case consts.DataTypeSliceAny:
|
|
// 任意类型的list
|
|
sliceVal := strVal.ToAnySlice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceInt, consts.DataTypeSliceIntWithChar:
|
|
// 任意类型的list
|
|
if strings.HasPrefix(strVal.Value(), "[") && strings.HasPrefix(strVal.Value(), "]") {
|
|
// 序列化之后的数组
|
|
sliceVal := strVal.ToInt64Slice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
}
|
|
// 分隔的数组
|
|
sliceVal := strVal.ToInt64Slice(",")
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceUint, consts.DataTypeSliceUintWithChar:
|
|
// 任意类型的list
|
|
if strings.HasPrefix(strVal.Value(), "[") && strings.HasPrefix(strVal.Value(), "]") {
|
|
// 序列化之后的数组
|
|
sliceVal := strVal.ToUint64Slice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
}
|
|
// 分隔的数组
|
|
sliceVal := strVal.ToUint64Slice(",")
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceFloat, consts.DataTypeSliceFloatWithChar:
|
|
// 任意类型的list
|
|
if strings.HasPrefix(strVal.Value(), "[") && strings.HasPrefix(strVal.Value(), "]") {
|
|
// 序列化之后的数组
|
|
sliceVal := strVal.ToFloat64Slice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
}
|
|
// 分隔的数组
|
|
sliceVal := strVal.ToFloat64Slice(",")
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceBool, consts.DataTypeSliceBoolWithChar:
|
|
// 任意类型的list
|
|
if strings.HasPrefix(strVal.Value(), "[") && strings.HasPrefix(strVal.Value(), "]") {
|
|
// 序列化之后的数组
|
|
sliceVal := strVal.ToBoolSlice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
}
|
|
// 分隔的数组
|
|
sliceVal := strVal.ToBoolSlice(",")
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceString, consts.DataTypeSliceStringWithChar:
|
|
// 任意类型的list
|
|
if strings.HasPrefix(strVal.Value(), "[") && strings.HasPrefix(strVal.Value(), "]") {
|
|
// 序列化之后的数组
|
|
sliceVal := strVal.ToStringSlice()
|
|
return sliceVal.Value, sliceVal.Err
|
|
}
|
|
// 分隔的数组
|
|
sliceVal := strVal.ToStringSlice(",")
|
|
return sliceVal.Value, sliceVal.Err
|
|
case consts.DataTypeSliceSlice, consts.DataTypeMapAnyAny:
|
|
return nil, errors.New(consts.DataTypeSliceSlice.String() + " : data type is not support")
|
|
case consts.DataTypeSliceMapStringAny:
|
|
if !sourceValue.IsArray() {
|
|
return nil, errors.New("data type is not array")
|
|
}
|
|
var res []map[string]any
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrInt:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]int64
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrUint:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]uint64
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrFloat:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]float64
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrBool:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]bool
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrAny:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]any
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrStr:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string]string
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
case consts.DataTypeMapStrSlice:
|
|
if !sourceValue.IsObject() {
|
|
return nil, errors.New("data type is not object")
|
|
}
|
|
var res map[string][]any
|
|
err := strVal.ToStruct(&res)
|
|
return res, err
|
|
default:
|
|
return nil, errors.New(dataType.String() + " is not support!")
|
|
}
|
|
}
|