refactor: 使用泛型重构参数绑定等

server/pkg/utils/structx/structx.go

@@ -1,7 +1,6 @@
 package structx
 
 import (
-	"database/sql"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -11,126 +10,18 @@ import (
 	"strings"
 )
 
-// Copy copy things，引用至copier
-func Copy(toValue any, fromValue any) (err error) {
-	var (
-		isSlice bool
-		amount  = 1
-		from    = Indirect(reflect.ValueOf(fromValue))
-		to      = Indirect(reflect.ValueOf(toValue))
-	)
+// CopyTo 将fromValue转为T类型并返回
+func CopyTo[T any](fromValue any) T {
+	t := NewInstance[T]()
+	Copy(t, fromValue)
+	return t
+}
 
-	if !to.CanAddr() {
-		return errors.New("copy to value is unaddressable")
-	}
-
-	// Return is from value is invalid
-	if !from.IsValid() {
-		return
-	}
-
-	fromType := IndirectType(from.Type())
-	toType := IndirectType(to.Type())
-
-	// Just set it if possible to assign
-	// And need to do copy anyway if the type is struct
-	if fromType.Kind() != reflect.Struct && from.Type().AssignableTo(to.Type()) {
-		to.Set(from)
-		return
-	}
-
-	if fromType.Kind() != reflect.Struct || toType.Kind() != reflect.Struct {
-		return
-	}
-
-	if to.Kind() == reflect.Slice {
-		isSlice = true
-		if from.Kind() == reflect.Slice {
-			amount = from.Len()
-		}
-	}
-
-	for i := 0; i < amount; i++ {
-		var dest, source reflect.Value
-
-		if isSlice {
-			// source
-			if from.Kind() == reflect.Slice {
-				source = Indirect(from.Index(i))
-			} else {
-				source = Indirect(from)
-			}
-			// dest
-			dest = Indirect(reflect.New(toType).Elem())
-		} else {
-			source = Indirect(from)
-			dest = Indirect(to)
-		}
-
-		// check source
-		if source.IsValid() {
-			fromTypeFields := deepFields(fromType)
-			//fmt.Printf("%#v", fromTypeFields)
-			// Copy from field to field or method
-			for _, field := range fromTypeFields {
-				name := field.Name
-
-				if fromField := source.FieldByName(name); fromField.IsValid() {
-					// has field
-					if toField := dest.FieldByName(name); toField.IsValid() {
-						if toField.CanSet() {
-							if !set(toField, fromField) {
-								if err := Copy(toField.Addr().Interface(), fromField.Interface()); err != nil {
-									return err
-								}
-							}
-						}
-					} else {
-						// try to set to method
-						var toMethod reflect.Value
-						if dest.CanAddr() {
-							toMethod = dest.Addr().MethodByName(name)
-						} else {
-							toMethod = dest.MethodByName(name)
-						}
-
-						if toMethod.IsValid() && toMethod.Type().NumIn() == 1 && fromField.Type().AssignableTo(toMethod.Type().In(0)) {
-							toMethod.Call([]reflect.Value{fromField})
-						}
-					}
-				}
-			}
-
-			// Copy from method to field
-			for _, field := range deepFields(toType) {
-				name := field.Name
-
-				var fromMethod reflect.Value
-				if source.CanAddr() {
-					fromMethod = source.Addr().MethodByName(name)
-				} else {
-					fromMethod = source.MethodByName(name)
-				}
-
-				if fromMethod.IsValid() && fromMethod.Type().NumIn() == 0 && fromMethod.Type().NumOut() == 1 {
-					if toField := dest.FieldByName(name); toField.IsValid() && toField.CanSet() {
-						values := fromMethod.Call([]reflect.Value{})
-						if len(values) >= 1 {
-							set(toField, values[0])
-						}
-					}
-				}
-			}
-		}
-		if isSlice {
-			if dest.Addr().Type().AssignableTo(to.Type().Elem()) {
-				to.Set(reflect.Append(to, dest.Addr()))
-			} else if dest.Type().AssignableTo(to.Type().Elem()) {
-				to.Set(reflect.Append(to, dest))
-			}
-		}
-	}
-	return
+// CopySliceTo 将fromValue转为[]T类型并返回
+func CopySliceTo[F, T any](fromValue []F) []T {
+	var to []T
+	Copy(&to, fromValue)
+	return to
 }
 
 // 对结构体的每个字段以及字段值执行doWith回调函数, 包括匿名属性的字段
@@ -158,23 +49,6 @@ func DoWithFields(str any, doWith func(fType reflect.StructField, fValue reflect
 	return nil
 }
 
-func deepFields(reflectType reflect.Type) []reflect.StructField {
-	var fields []reflect.StructField
-
-	if reflectType = IndirectType(reflectType); reflectType.Kind() == reflect.Struct {
-		for i := 0; i < reflectType.NumField(); i++ {
-			v := reflectType.Field(i)
-			if v.Anonymous {
-				fields = append(fields, deepFields(v.Type)...)
-			} else {
-				fields = append(fields, v)
-			}
-		}
-	}
-
-	return fields
-}
-
 func Indirect(reflectValue reflect.Value) reflect.Value {
 	for reflectValue.Kind() == reflect.Ptr {
 		reflectValue = reflectValue.Elem()
@@ -189,35 +63,6 @@ func IndirectType(reflectType reflect.Type) reflect.Type {
 	return reflectType
 }
 
-func set(to, from reflect.Value) bool {
-	if from.IsValid() {
-		if to.Kind() == reflect.Ptr {
-			//set `to` to nil if from is nil
-			if from.Kind() == reflect.Ptr && from.IsNil() {
-				to.Set(reflect.Zero(to.Type()))
-				return true
-			} else if to.IsNil() {
-				to.Set(reflect.New(to.Type().Elem()))
-			}
-			to = to.Elem()
-		}
-
-		if from.Type().ConvertibleTo(to.Type()) {
-			to.Set(from.Convert(to.Type()))
-		} else if scanner, ok := to.Addr().Interface().(sql.Scanner); ok {
-			err := scanner.Scan(from.Interface())
-			if err != nil {
-				return false
-			}
-		} else if from.Kind() == reflect.Ptr {
-			return set(to, from.Elem())
-		} else {
-			return false
-		}
-	}
-	return true
-}
-
 func Map2Struct(m map[string]any, s any) error {
 	toValue := Indirect(reflect.ValueOf(s))
 	if !toValue.CanAddr() {