add filtering and base repository

local/utl/common/common.go

@@ -8,8 +8,11 @@ import (
 	"net"
 	"os"
 	"os/exec"
+	"reflect"
 	"regexp"
+	"strconv"
 	"strings"
+	"time"
 
 	"github.com/gofiber/fiber/v2"
 )
@@ -82,3 +85,131 @@ func IndentJson(body []byte) ([]byte, error) {
 	}
 	return unmarshaledBody.Bytes(), nil
 }
+
+// ParseQueryFilter parses query parameters into a filter struct using reflection.
+// It supports various field types and uses struct tags to determine parsing behavior.
+// Supported tags:
+// - `query:"field_name"` - specifies the query parameter name
+// - `param:"param_name"` - specifies the path parameter name
+// - `time_format:"format"` - specifies the time format for parsing dates (default: RFC3339)
+func ParseQueryFilter(c *fiber.Ctx, filter interface{}) error {
+	val := reflect.ValueOf(filter)
+	if val.Kind() != reflect.Ptr || val.IsNil() {
+		return fmt.Errorf("filter must be a non-nil pointer")
+	}
+
+	elem := val.Elem()
+	typ := elem.Type()
+
+	for i := 0; i < elem.NumField(); i++ {
+		field := elem.Field(i)
+		fieldType := typ.Field(i)
+
+		// Skip if field cannot be set
+		if !field.CanSet() {
+			continue
+		}
+
+		// Check for param tag first (path parameters)
+		if paramName := fieldType.Tag.Get("param"); paramName != "" {
+			if err := parsePathParam(c, field, paramName); err != nil {
+				return fmt.Errorf("error parsing path parameter %s: %v", paramName, err)
+			}
+			continue
+		}
+
+		// Then check for query tag
+		queryName := fieldType.Tag.Get("query")
+		if queryName == "" {
+			queryName = ToSnakeCase(fieldType.Name) // Default to snake_case of field name
+		}
+
+		queryVal := c.Query(queryName)
+		if queryVal == "" {
+			continue // Skip empty values
+		}
+
+		if err := parseValue(field, queryVal, fieldType.Tag); err != nil {
+			return fmt.Errorf("error parsing query parameter %s: %v", queryName, err)
+		}
+	}
+
+	return nil
+}
+
+func parsePathParam(c *fiber.Ctx, field reflect.Value, paramName string) error {
+	switch field.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		val, err := c.ParamsInt(paramName)
+		if err != nil {
+			return err
+		}
+		field.SetInt(int64(val))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		val, err := c.ParamsInt(paramName)
+		if err != nil {
+			return err
+		}
+		field.SetUint(uint64(val))
+	case reflect.String:
+		field.SetString(c.Params(paramName))
+	default:
+		return fmt.Errorf("unsupported path parameter type: %v", field.Kind())
+	}
+	return nil
+}
+
+func parseValue(field reflect.Value, value string, tag reflect.StructTag) error {
+	switch field.Kind() {
+	case reflect.String:
+		field.SetString(value)
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		val, err := strconv.ParseInt(value, 10, 64)
+		if err != nil {
+			return err
+		}
+		field.SetInt(val)
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		val, err := strconv.ParseUint(value, 10, 64)
+		if err != nil {
+			return err
+		}
+		field.SetUint(val)
+
+	case reflect.Float32, reflect.Float64:
+		val, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+		field.SetFloat(val)
+
+	case reflect.Bool:
+		val, err := strconv.ParseBool(value)
+		if err != nil {
+			return err
+		}
+		field.SetBool(val)
+
+	case reflect.Struct:
+		if field.Type() == reflect.TypeOf(time.Time{}) {
+			format := tag.Get("time_format")
+			if format == "" {
+				format = time.RFC3339
+			}
+			t, err := time.Parse(format, value)
+			if err != nil {
+				return err
+			}
+			field.Set(reflect.ValueOf(t))
+		} else {
+			return fmt.Errorf("unsupported struct type: %v", field.Type())
+		}
+
+	default:
+		return fmt.Errorf("unsupported field type: %v", field.Kind())
+	}
+
+	return nil
+}