Working version

app/inheritance/inheritance.go

@@ -0,0 +1,74 @@
+package inheritance
+
+import "fmt"
+
+type Model struct{}
+
+type MyModel struct {
+	Model
+}
+
+type MethodInitInterface interface {
+	Init(dbConn int)
+}
+
+type RepoBase[T interface{}] struct {
+	DbConn int
+	GetMethod[T]
+	ListMethod[T]
+	methods []MethodInitInterface
+}
+
+func (b *RepoBase[T]) InitMethods(dbConn int) {
+	for _, method := range b.methods {
+		method.Init(dbConn)
+	}
+}
+
+type CRUDRepo[T interface{}] struct {
+	RepoBase[T]
+	SaveMethod[T]
+}
+
+func (m *CRUDRepo[T]) Init(dbConn int) {
+	m.methods = []MethodInitInterface{&m.GetMethod, &m.ListMethod, &m.SaveMethod}
+	m.InitMethods(dbConn)
+}
+
+func DoInheritanceTest() {
+	repo := RepoBase[MyModel]{
+		DbConn: 111,
+		// GetMethod: GetMethod{
+		// 	DbConn: 666,
+		// },
+		// ListMethod: ListMethod{
+		// 	DbConn: 777,
+		// },
+	}
+	repo.GetMethod.Init(888)
+	repo.ListMethod.Init(888)
+
+	repo.GetMethod.Get()
+	repo.List()
+
+	fmt.Printf("outside Base: %d\n", repo.DbConn)
+	fmt.Printf("outside GetMethod: %d\n", repo.GetMethod.DbConn)
+	fmt.Printf("outside ListMethod: %d\n", repo.ListMethod.DbConn)
+
+	fmt.Println("----------------")
+
+	crudRepo := CRUDRepo[MyModel]{}
+	crudRepo.Init(999)
+
+	crudRepo.Get()
+	crudRepo.List()
+	crudRepo.Save()
+
+	fmt.Printf("outside GetMethod: %d\n", crudRepo.GetMethod.DbConn)
+	fmt.Printf("outside ListMethod: %d\n", crudRepo.ListMethod.DbConn)
+	fmt.Printf("outside SaveMethod: %d\n", crudRepo.SaveMethod.DbConn)
+
+	// repo.DbConn = 123
+	// repo.SomeGetVar = 456
+	// repo.DoSomething()
+}

app/inheritance/methods.go

@@ -0,0 +1,43 @@
+package inheritance
+
+import "fmt"
+
+type GetMethod[T interface{}] struct {
+	SomeGetVar int
+	DbConn     int
+}
+
+func (m *GetMethod[T]) Init(dbConn int) {
+	m.DbConn = dbConn
+}
+
+func (m GetMethod[T]) Get() T {
+	var model T
+	fmt.Printf("Get DbConn: %d\n", m.DbConn)
+	return model
+}
+
+type ListMethod[T interface{}] struct {
+	SomeListVar int
+	DbConn      int
+}
+
+func (m *ListMethod[T]) Init(dbConn int) {
+	m.DbConn = dbConn
+}
+
+func (m ListMethod[T]) List() {
+	fmt.Printf("List DbConn: %d\n", m.DbConn)
+}
+
+type SaveMethod[T interface{}] struct {
+	DbConn int
+}
+
+func (m *SaveMethod[T]) Init(dbConn int) {
+	m.DbConn = dbConn
+}
+
+func (m SaveMethod[T]) Save() {
+	fmt.Printf("List DbConn: %d\n", m.DbConn)
+}

app/main.go

@@ -25,20 +25,22 @@ func doMagic(db *gorm.DB) {
 	// id := "6dc096ab-5c03-427e-b808-c669f7446131"
 	// serialNumber := "222"
 	// serialNumberContains := "323"
-	// issuer := "FINA"
+	issuer := "FINA"
 	location, _ := time.LoadLocation("UTC")
 	createdTime := time.Date(2024, 5, 26, 16, 8, 0, 0, location)
+	ids := []string{"eb2bcac6-5173-4dbb-93b7-e7c03b924a03", "db9fb837-3483-4736-819d-f427dc8cda23", "1fece5e7-8e8d-4828-8298-3b1f07fd29ff"}
 
-	f := smartfilter.SmartCertFilter[models.Cert]{
+	filter := smartfilter.CertFilter{
-		// Alive: &FALSE,
+		Alive: &FALSE,
-		// Id: &id,
+		// Id:    &id,
 		// SerialNumber: &serialNumber,
 		// SerialNumberContains: &serialNumberContains,
-		// IssuerContains: &issuer,
+		Ids:            &ids,
-		CreatedAt_Lt: &createdTime,
+		IssuerContains: &issuer,
+		CreatedAt_Lt:   &createdTime,
 	}
 
-	query, err = f.ToQuery(query)
+	query, err = smartfilter.ToQuery(models.Cert{}, filter, query)
 	if err != nil {
 		panic(err)
 	}
@@ -51,6 +53,58 @@ func doMagic(db *gorm.DB) {
 	}
 }
 
+func doList(db *gorm.DB) {
+	repo := repository.RepoBase[models.Cert]{}
+	repo.Init(db)
+
+	filter := smartfilter.CertFilter{
+		Alive: &TRUE,
+	}
+
+	certs, err := repo.List(filter)
+	if err != nil {
+		panic(err)
+	}
+
+	for n, cert := range *certs {
+		fmt.Printf(">> [%d] %+v  %s (alive %t)\n", n, cert.Id, cert.CreatedAt, cert.Alive)
+	}
+}
+
+func doGet(db *gorm.DB) {
+	repo := repository.RepoBase[models.Cert]{}
+	repo.Init(db)
+
+	id := "db9fb837-3483-4736-819d-f427dc8cda23"
+
+	filter := smartfilter.CertFilter{
+		Id: &id,
+	}
+
+	cert, err := repo.Get(filter)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf(">> %+v  %s (alive %t)\n", cert.Id, cert.CreatedAt, cert.Alive)
+}
+
+func doExists(db *gorm.DB) {
+	repo := repository.RepoBase[models.Cert]{}
+	repo.Init(db)
+
+	id := "db9fb837-3483-4736-819d-f427dc8cda23"
+
+	filter := smartfilter.CertFilter{
+		Id: &id,
+	}
+
+	exists, err := repo.Exists(filter)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Printf(">> EXISTS: %t\n", exists)
+}
+
 func main() {
 	cfg.Init()
 	logging.Init()
@@ -59,7 +113,9 @@ func main() {
 	db := db.InitDB()
 	repository.Dao = repository.CreateDAO(db)
 
-	doMagic(db)
+	// doMagic(db)
-
+	// doList(db)
-	fmt.Println("Running...")
+	// doGet(db)
+	doExists(db)
+	// inheritance.DoInheritanceTest()
 }

app/repository/methods.go

@@ -0,0 +1,84 @@
+package repository
+
+import (
+	"errors"
+	"repo-pattern/app/repository/smartfilter"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/schema"
+)
+
+type ListMethod[T schema.Tabler] struct {
+	DbConn *gorm.DB
+}
+
+func (m *ListMethod[T]) Init(dbConn *gorm.DB) {
+	m.DbConn = dbConn
+}
+
+func (m ListMethod[T]) List(filter interface{}) (*[]T, error) {
+	var (
+		model  T
+		models []T
+	)
+
+	query, err := smartfilter.ToQuery(model, filter, m.DbConn)
+	if err != nil {
+		return nil, err
+	}
+
+	query.Find(&models)
+	return &models, nil
+}
+
+type GetMethod[T schema.Tabler] struct {
+	DbConn *gorm.DB
+}
+
+func (m *GetMethod[T]) Init(dbConn *gorm.DB) {
+	m.DbConn = dbConn
+}
+
+func (m GetMethod[T]) Get(filter interface{}) (*T, error) {
+	var (
+		model T
+	)
+
+	query, err := smartfilter.ToQuery(model, filter, m.DbConn)
+	if err != nil {
+		return nil, err
+	}
+
+	result := query.First(&model)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+
+	return &model, nil
+}
+
+type ExistsMethod[T schema.Tabler] struct {
+	DbConn *gorm.DB
+}
+
+func (m *ExistsMethod[T]) Init(dbConn *gorm.DB) {
+	m.DbConn = dbConn
+}
+
+func (m ExistsMethod[T]) Exists(filter interface{}) (bool, error) {
+	var (
+		model T
+	)
+
+	query := m.DbConn.Model(model)
+
+	query, err := smartfilter.ToQuery(model, filter, query)
+	if err != nil {
+		return false, err
+	}
+
+	result := query.Select("*").First(&model)
+
+	exists := !errors.Is(result.Error, gorm.ErrRecordNotFound) && result.Error == nil
+	return exists, nil
+}

app/repository/repository.go

@@ -0,0 +1,29 @@
+package repository
+
+import (
+	"gorm.io/gorm"
+	"gorm.io/gorm/schema"
+)
+
+type MethodInitInterface interface {
+	Init(dbConn *gorm.DB)
+}
+
+type RepoBase[T schema.Tabler] struct {
+	DbConn int
+	ListMethod[T]
+	GetMethod[T]
+	ExistsMethod[T]
+	methods []MethodInitInterface
+}
+
+func (b *RepoBase[T]) InitMethods(dbConn *gorm.DB) {
+	for _, method := range b.methods {
+		method.Init(dbConn)
+	}
+}
+
+func (m *RepoBase[T]) Init(dbConn *gorm.DB) {
+	m.methods = []MethodInitInterface{&m.ListMethod, &m.GetMethod, &m.ExistsMethod}
+	m.InitMethods(dbConn)
+}

app/repository/smartfilter/filterfield.go

@@ -16,7 +16,6 @@ type FilterField struct {
 	uintValue  *uint64
 	floatValue *float64
 	strValue   *string
-	timeValue  *time.Time
 }
 
 func (ff *FilterField) setValueFromReflection(v reflect.Value) {
@@ -24,18 +23,6 @@ func (ff *FilterField) setValueFromReflection(v reflect.Value) {
 	fn(ff, v)
 }
 
-// func (ff *FilterField) getValueWithOperator(v reflect.Value) string {
-// 	value := ff.getValue(v)
-
-// 	switch ff.valueKind {
-// 	case reflect.Bool:
-// 		return fmt.Sprintf("IS %s", value)
-// 	case reflect.Int, reflect.Uint, reflect.Float32, reflect.Float64, reflect.String:
-// 		return fmt.Sprintf("= %s", value)
-// 	}
-// 	return "???"
-// }
-
 type valueGetterFunc func(ff *FilterField, v reflect.Value) error
 
 func boolValueGetter(ff *FilterField, v reflect.Value) error {
@@ -132,10 +119,10 @@ func newTypeGetter(t reflect.Type, allowAddr bool) valueGetterFunc {
 		}
 	// case reflect.Map:
 	// 	return newMapEncoder(t)
-	// case reflect.Slice:
+	case reflect.Slice:
-	// 	return newSliceEncoder(t)
+		return newSliceGetter(t)
-	// case reflect.Array:
+	case reflect.Array:
-	// 	return newArrayEncoder(t)
+		return newArrayGetter(t)
 	case reflect.Pointer:
 		return newPtrValueGetter(t)
 	}
@@ -155,3 +142,32 @@ func newPtrValueGetter(t reflect.Type) valueGetterFunc {
 	enc := ptrValueGetter{elemEnc: typeGetter(t.Elem())}
 	return enc.getValue
 }
+
+type arrayGetter struct {
+	elemEnc valueGetterFunc
+}
+
+func (ag arrayGetter) getValue(ff *FilterField, v reflect.Value) error {
+	ag.elemEnc(ff, v.Elem())
+	return nil
+}
+
+func newArrayGetter(t reflect.Type) valueGetterFunc {
+	enc := arrayGetter{elemEnc: typeGetter(t.Elem())}
+	return enc.getValue
+}
+
+type sliceGetter struct {
+	elemEnc valueGetterFunc
+}
+
+func (sg sliceGetter) getValue(ff *FilterField, v reflect.Value) error {
+	fmt.Printf("%+v\n", v.Slice(0, 1))
+	sg.elemEnc(ff, v.Elem())
+	return nil
+}
+
+func newSliceGetter(t reflect.Type) valueGetterFunc {
+	enc := sliceGetter{elemEnc: typeGetter(t.Elem())}
+	return enc.getValue
+}

app/repository/smartfilter/filters.go

@@ -49,3 +49,9 @@ func applyFilterLE[T bool | int64 | uint64 | float64 | string](
 ) *gorm.DB {
 	return query.Where(fmt.Sprintf("%s.%s <= ?", tableName, filterField.Name), value)
 }
+
+func applyFilterIN[T bool | int64 | uint64 | float64 | string](
+	query *gorm.DB, tableName string, filterField *FilterField, value T,
+) *gorm.DB {
+	return query.Where(fmt.Sprintf("%s.%s IN ?", tableName, filterField.Name), value)
+}

app/repository/smartfilter/handlers.go

@@ -0,0 +1,125 @@
+package smartfilter
+
+import (
+	"reflect"
+
+	"gorm.io/gorm"
+)
+
+func handleOperatorEQ(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Bool:
+		return applyFilterEQ(query, tableName, filterField, *filterField.boolValue)
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterEQ(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterEQ(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterEQ(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterEQ(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorNE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Bool:
+		return applyFilterNE(query, tableName, filterField, *filterField.boolValue)
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterNE(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterNE(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterNE(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterNE(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorLIKE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.String:
+		return applyFilterLIKE(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorILIKE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.String:
+		return applyFilterILIKE(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorGT(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterGT(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterGT(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterGT(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterGT(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorGE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterGE(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterGE(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterGE(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterGE(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorLT(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterLT(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterLT(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterLT(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterLT(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorLE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterLE(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterLE(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterLE(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterLE(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}
+
+func handleOperatorIN(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
+	switch filterField.valueKind {
+	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
+		return applyFilterIN(query, tableName, filterField, *filterField.intValue)
+	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return applyFilterIN(query, tableName, filterField, *filterField.uintValue)
+	case reflect.Float32, reflect.Float64:
+		return applyFilterIN(query, tableName, filterField, *filterField.floatValue)
+	case reflect.String:
+		return applyFilterIN(query, tableName, filterField, *filterField.strValue)
+	}
+	return nil
+}

app/repository/smartfilter/smartfilter.go

@@ -25,10 +25,10 @@ var operatorHandlers = map[Operator]handlerFunc{
 	OperatorLE:    handleOperatorLE,
 	OperatorLIKE:  handleOperatorLIKE,
 	OperatorILIKE: handleOperatorILIKE,
+	OperatorIN:    handleOperatorIN,
 }
 
-type SmartCertFilter[T schema.Tabler] struct {
+type CertFilter struct {
-	Model                T
 	Alive                *bool      `filterfield:"alive,EQ"`
 	SerialNumber         *string    `filterfield:"serial_number,NE"`
 	SerialNumberContains *string    `filterfield:"serial_number,LIKE"`
@@ -38,15 +38,17 @@ type SmartCertFilter[T schema.Tabler] struct {
 	CreatedAt_Lt         *time.Time `filterfield:"created_at,LT"`
 }
 
-func (f SmartCertFilter[T]) ToQuery(query *gorm.DB) (*gorm.DB, error) {
+type ReflectedStructField struct {
-	tableName := f.Model.TableName()
+	name     string
+	value    reflect.Value
+	tagValue string
+}
 
-	fmt.Printf("Table name: %s\n", tableName)
+func getFilterFields(filter interface{}) []ReflectedStructField {
-	// fmt.Printf("%+v\n", f)
+	res := make([]ReflectedStructField, 0)
 
-	st := reflect.TypeOf(f)
+	st := reflect.TypeOf(filter)
-	modelName := st.Name()
+	reflectValue := reflect.ValueOf(filter)
-	reflectValue := reflect.ValueOf(f)
 
 	for i := 0; i < st.NumField(); i++ {
 		field := st.Field(i)
@@ -57,23 +59,41 @@ func (f SmartCertFilter[T]) ToQuery(query *gorm.DB) (*gorm.DB, error) {
 			continue
 		}
 
-		fieldReflect := reflectValue.FieldByName(field.Name)
+		// get field value
+		fieldValue := reflectValue.FieldByName(field.Name)
 
 		// skip field if value is nil
-		if fieldReflect.IsNil() {
+		if fieldValue.IsNil() {
 			continue
 		}
 
-		t := fieldReflect.Type()
+		res = append(res, ReflectedStructField{
-		fmt.Printf(">>> %+v    --- %+v\n", field, t)
+			name:     field.Name,
+			tagValue: tagValue,
+			value:    fieldValue,
+		})
+	}
+	return res
+}
 
-		filterField, err := newFilterField(tagValue)
+func ToQuery(model schema.Tabler, filter interface{}, query *gorm.DB) (*gorm.DB, error) {
+	st := reflect.TypeOf(filter)
+
+	tableName := model.TableName()
+	modelName := st.Name()
+
+	fmt.Printf("Table name: %s\n", tableName)
+	fmt.Printf("Model name: %s\n", modelName)
+
+	fields := getFilterFields(filter)
+	for _, field := range fields {
+		filterField, err := newFilterField(field.tagValue)
 		if err != nil {
-			return nil, fmt.Errorf("%s.%s: %s", modelName, field.Name, err)
+			return nil, fmt.Errorf("%s.%s: %s", modelName, field.name, err)
 		}
 
 		// must be called!
-		filterField.setValueFromReflection(fieldReflect)
+		filterField.setValueFromReflection(field.value)
 
 		operatorHandler, ok := operatorHandlers[filterField.Operator]
 		if !ok {
@@ -106,107 +126,3 @@ func newFilterField(tagValue string) (*FilterField, error) {
 	}
 	return &f, nil
 }
-
-func handleOperatorEQ(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Bool:
-		return applyFilterEQ(query, tableName, filterField, *filterField.boolValue)
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterEQ(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterEQ(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterEQ(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterEQ(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorNE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Bool:
-		return applyFilterNE(query, tableName, filterField, *filterField.boolValue)
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterNE(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterNE(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterNE(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterNE(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorLIKE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.String:
-		return applyFilterLIKE(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorILIKE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.String:
-		return applyFilterILIKE(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorGT(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterGT(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterGT(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterGT(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterGT(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorGE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterGE(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterGE(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterGE(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterGE(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorLT(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterLT(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterLT(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterLT(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterLT(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}
-
-func handleOperatorLE(query *gorm.DB, tableName string, filterField *FilterField) *gorm.DB {
-	switch filterField.valueKind {
-	case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64:
-		return applyFilterLE(query, tableName, filterField, *filterField.intValue)
-	case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return applyFilterLE(query, tableName, filterField, *filterField.uintValue)
-	case reflect.Float32, reflect.Float64:
-		return applyFilterLE(query, tableName, filterField, *filterField.floatValue)
-	case reflect.String:
-		return applyFilterLE(query, tableName, filterField, *filterField.strValue)
-	}
-	return nil
-}