diff --git a/app/inheritance/inheritance.go b/app/inheritance/inheritance.go new file mode 100644 index 0000000..2f0ca61 --- /dev/null +++ b/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() +} diff --git a/app/inheritance/methods.go b/app/inheritance/methods.go new file mode 100644 index 0000000..3a46116 --- /dev/null +++ b/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) +} diff --git a/app/main.go b/app/main.go index 1693148..e0c86b5 100644 --- a/app/main.go +++ b/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]{ - // Alive: &FALSE, - // Id: &id, + filter := smartfilter.CertFilter{ + Alive: &FALSE, + // Id: &id, // SerialNumber: &serialNumber, // SerialNumberContains: &serialNumberContains, - // IssuerContains: &issuer, - CreatedAt_Lt: &createdTime, + Ids: &ids, + 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) - - fmt.Println("Running...") + // doMagic(db) + // doList(db) + // doGet(db) + doExists(db) + // inheritance.DoInheritanceTest() } diff --git a/app/repository/methods.go b/app/repository/methods.go new file mode 100644 index 0000000..bf1c68a --- /dev/null +++ b/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 +} diff --git a/app/repository/repository.go b/app/repository/repository.go new file mode 100644 index 0000000..16a30bd --- /dev/null +++ b/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) +} diff --git a/app/repository/smartfilter/filterfield.go b/app/repository/smartfilter/filterfield.go index f82874d..96455c0 100644 --- a/app/repository/smartfilter/filterfield.go +++ b/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: - // return newSliceEncoder(t) - // case reflect.Array: - // return newArrayEncoder(t) + case reflect.Slice: + return newSliceGetter(t) + case reflect.Array: + 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 +} diff --git a/app/repository/smartfilter/filters.go b/app/repository/smartfilter/filters.go index 39a6acd..7cc77e1 100644 --- a/app/repository/smartfilter/filters.go +++ b/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) +} diff --git a/app/repository/smartfilter/handlers.go b/app/repository/smartfilter/handlers.go new file mode 100644 index 0000000..68ce695 --- /dev/null +++ b/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 +} diff --git a/app/repository/smartfilter/smartfilter.go b/app/repository/smartfilter/smartfilter.go index cf87c7d..53e68cd 100644 --- a/app/repository/smartfilter/smartfilter.go +++ b/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 { - Model T +type CertFilter struct { 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) { - tableName := f.Model.TableName() +type ReflectedStructField struct { + name string + value reflect.Value + tagValue string +} - fmt.Printf("Table name: %s\n", tableName) - // fmt.Printf("%+v\n", f) +func getFilterFields(filter interface{}) []ReflectedStructField { + res := make([]ReflectedStructField, 0) - st := reflect.TypeOf(f) - modelName := st.Name() - reflectValue := reflect.ValueOf(f) + st := reflect.TypeOf(filter) + reflectValue := reflect.ValueOf(filter) 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() - fmt.Printf(">>> %+v --- %+v\n", field, t) + res = append(res, ReflectedStructField{ + 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 -}