baize/framework/core/tag/sql/sql_mapping/usage.go

package sql_mapping

import (
	"git.sxidc.com/go-tools/utils/encoding"
	"git.sxidc.com/go-tools/utils/reflectutils"
	"git.sxidc.com/go-tools/utils/strutils"
	"github.com/pkg/errors"
	"reflect"
	"strings"
)

type Field struct {
	FieldName      string
	ColumnName     string
	IsKey          bool
	CanUpdate      bool
	CanUpdateClear bool
	Value          any
}

func DefaultUsage(e any) ([]Field, error) {
	fields := make([]Field, 0)

	err := UseTag(e, defaultCallback(&fields))
	if err != nil {
		return nil, err
	}

	return fields, nil
}

func defaultCallback(fields *[]Field) OnParsedFieldTagFunc {
	return func(fieldName string, entityFieldElemValue reflect.Value, tag *Tag) error {
		field := Field{
			FieldName:      fieldName,
			ColumnName:     tag.Name,
			IsKey:          tag.IsKey,
			CanUpdate:      tag.CanUpdate,
			CanUpdateClear: tag.CanUpdateClear,
		}

		entityFieldKind := reflectutils.GroupValueKind(entityFieldElemValue)

		if entityFieldElemValue.IsZero() && !reflectutils.IsValueTime(entityFieldElemValue) {
			if entityFieldKind == reflect.Slice && reflectutils.IsSliceValueOf(entityFieldElemValue, reflect.String) ||
				entityFieldKind == reflect.String {
				field.Value = ""
			} else {
				field.Value = reflectutils.ZeroValueToAny(entityFieldElemValue)
			}

			*fields = append(*fields, field)
			return nil
		}

		switch entityFieldKind {
		case reflect.Struct:
			if !reflectutils.IsValueTime(entityFieldElemValue) {
				return errors.New(fieldName + " Error: 解析tag内部错误，除time.Time类型之外的结构被回调")
			}

			field.Value = entityFieldElemValue.Interface()
		case reflect.Slice:
			if !reflectutils.IsSliceValueOf(entityFieldElemValue, reflect.String) {
				return errors.New(fieldName + " Error: slice仅支持[]string")
			}

			strValue, err := dealStringValue(strings.Join(entityFieldElemValue.Interface().([]string), tag.JoinWith), tag)
			if err != nil {
				return err
			}

			field.Value = strValue
		case reflect.String:
			strValue, err := dealStringValue(entityFieldElemValue.Interface().(string), tag)
			if err != nil {
				return err
			}

			field.Value = strValue
		default:
			field.Value = entityFieldElemValue.Interface()
		}

		*fields = append(*fields, field)
		return nil
	}
}

func dealStringValue(value string, tag *Tag) (string, error) {
	retValue := value

	if strutils.IsStringNotEmpty(tag.Trim) {
		retValue = strings.Trim(retValue, tag.Trim)
	} else {
		if strutils.IsStringNotEmpty(tag.TrimPrefix) {
			retValue = strings.TrimPrefix(retValue, tag.TrimPrefix)
		}

		if strutils.IsStringNotEmpty(tag.TrimSuffix) {
			retValue = strings.TrimSuffix(retValue, tag.TrimSuffix)
		}
	}

	if strutils.IsStringNotEmpty(tag.AESKey) {
		encryptedValue, err := encoding.AESEncrypt(retValue, tag.AESKey)
		if err != nil {
			return "", err
		}

		retValue = encryptedValue
	}

	return retValue, nil
}