Working version

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:
-	// 	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
+}

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 {
-	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
-}