json_filter/filter.go

// Package filter ...
//
// Description : filter ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2022-07-04 17:47
package filter

import (
	"encoding/json"
	"fmt"
	"strings"

	"github.com/tidwall/gjson"
	"github.com/tidwall/sjson"

	"errors"

	"git.zhangdeman.cn/zhangdeman/util"
)

// 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 interface{}
	)

	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 f.formatResult, err = sjson.Set(f.formatResult, rule.MapPath, 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.MapPath, ".[]"), "[]")
	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 string, sourceValue gjson.Result, defaultValue string) (interface{}, error) {
	sourceValueStr := defaultValue
	if sourceValue.Exists() {
		str := sourceValue.String()
		if len(str) > 0 {
			sourceValueStr = str
		}
	}

	switch dataType {
	case DataTypeInt8:
		return util.StringConvert.ToInt8(sourceValueStr)
	case DataTypeInt16:
		return util.StringConvert.ToInt16(sourceValueStr)
	case DataTypeInt32:
		return util.StringConvert.ToInt32(sourceValueStr)
	case DataTypeInt64:
		return util.StringConvert.ToInt64(sourceValueStr)
	case DataTypeInt:
		return util.StringConvert.ToInt(sourceValueStr)
	case DataTypeUint8:
		return util.StringConvert.ToUint8(sourceValueStr)
	case DataTypeUint16:
		return util.StringConvert.ToUint16(sourceValueStr)
	case DataTypeUint32:
		return util.StringConvert.ToUint32(sourceValueStr)
	case DataTypeUint64:
		return util.StringConvert.ToUint64(sourceValueStr)
	case DataTypeUint:
		return util.StringConvert.ToUint(sourceValueStr)
	case DataTypeBool:
		return util.StringConvert.ToBool(sourceValueStr)
	case DataTypeFloat32:
		return util.StringConvert.ToFloat32(sourceValueStr)
	case DataTypeFloat64:
		return util.StringConvert.ToFloat64(sourceValueStr)
	case DataTypeFloat:
		return util.StringConvert.ToFloat64(sourceValueStr)
	case DataTypeDouble:
		return util.StringConvert.ToDouble(sourceValueStr)
	case DataTypeNumber:
		return util.StringConvert.ToNumber(sourceValueStr)
	case DataTypeString:
		return sourceValueStr, nil
	case DataTypeAny:
		return sourceValue.Value(), nil
	case DataTypeAnySlice:
		// 任意类型的list
		var (
			result []interface{}
		)
		if err := util.JSON.UnmarshalWithNumber([]byte(sourceValueStr), &result); nil != err {
			return nil, err
		}
		return result, nil
	case DataTypeObject:
		// object
		var (
			result map[string]interface{}
		)
		if err := util.JSON.UnmarshalWithNumber([]byte(sourceValueStr), &result); nil != err {
			return nil, err
		}
		return result, nil
	default:
		return nil, errors.New(dataType + " is not support!")
	}
}