在 Go Huma 中添加过滤查询参数

parameters: []*huma.param{{
            name: "filters",
            in:   "query",
            description: "filter properties by various fields. separate filters by comma.\n\n" +
                "format: field:operator:value\n\n" +
                "supported fields:\n" +
                "- postcode (operator: eq)\n" +
                "- created (operators: gt, lt, gte, lte)\n",
            schema: &huma.schema{
                type: "string",
                items: &huma.schema{
                    type:    "string",
                    pattern: "^[a-za-z_]+:(eq|neq|gt|lt|gte|lte):[a-za-z0-9-:.]+$",
                },
                examples: []any{
                    "postcode:eq:rm7 8ex",
                    "created:gt:2024-01-01",
                },
            },
            required: false,
        }},

type filterparam struct {
    field    string
    operator string
    value    interface{}
}

type propertyfilterparams struct {
    items []filterparam
}

func (s *propertyfilterparams) unmarshaltext(text []byte) error {
    equalityfields := []string{"postcode"}
    greatersmallerfields := []string{}
    datefields := []string{"created"}

    for _, item := range strings.split(string(text), ",") {
        filterparam, err := parseandvalidatefilteritem(item, equalityfields, greatersmallerfields, datefields)
        if err != nil {
            return err
        }
        s.items = append(s.items, filterparam)
    }

    return nil
}

func (s *propertyfilterparams) schema(registry huma.registry) *huma.schema {
    return &huma.schema{
        type: huma.typestring,
    }
}

func parseandvalidatefilteritem(item string, equalityfields []string, greatersmallerfields []string, datefields []string) (filterparam, error) {
    parts := strings.splitn(item, ":", 3)

    field := parts[0]
    operator := parts[1]
    value := parts[2]

    if contains(equalityfields, field) {
        if operator != "eq" && operator != "neq" {
            return filterparam{}, fmt.errorf("unsupported operator %s for field %s. only 'eq' and 'neq' are supported.", operator, field)
        }
    } else if contains(greatersmallerfields, field) {
        if !validation.isvalidcomparegreatersmalleroperator(operator) {
            return filterparam{}, fmt.errorf("unsupported operator %s for field %s. supported operators: eq, neq, gt, lt, gte, lte.", operator, field)
        }
    } else if contains(datefields, field) {
        if !validation.isvalidcomparegreatersmalleroperator(operator) {
            return filterparam{}, fmt.errorf("unsupported operator %s for field %s. supported operators: eq, neq, gt, lt, gte, lte.", operator, field)
        }
        if !validation.isvaliddate(value) {
            return filterparam{}, fmt.errorf("invalid date format: %s. expected: yyyy-mm-dd", value)
        }
    } else {
        return filterparam{}, fmt.errorf("unsupported filter field: %s", field)
    }

    return filterparam{field: field, operator: operator, value: value}, nil
}

type propertyqueryparams struct {
    paginationparams
    filter propertyfilterparams `query:"filters" doc:"filter properties by various fields"`
    sort   propertysortparams   `query:"sorts" doc:"sort properties by various fields"`
}

huma.Register(api, getAllPropertyOperation(schema, "get-properties", "/properties", []string{"Properties"}),
        func(ctx context.Context, input *struct {
            models.Headers
            models.PropertyQueryParams
        }) (*models.MultiplePropertyOutput, error) {

            for _, filter := range input.Filter.Items {
                fmt.Println(filter)
            }

            return mockMultiplePropertyResponse(), err
        })
}