mirror of https://github.com/0xERR0R/blocky.git
661 lines
20 KiB
Go
661 lines
20 KiB
Go
// Package api provides primitives to interact with the openapi HTTP API.
|
|
//
|
|
// Code generated by github.com/deepmap/oapi-codegen version v1.16.2 DO NOT EDIT.
|
|
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/oapi-codegen/runtime"
|
|
strictnethttp "github.com/oapi-codegen/runtime/strictmiddleware/nethttp"
|
|
)
|
|
|
|
// ServerInterface represents all server handlers.
|
|
type ServerInterface interface {
|
|
// Disable blocking
|
|
// (GET /blocking/disable)
|
|
DisableBlocking(w http.ResponseWriter, r *http.Request, params DisableBlockingParams)
|
|
// Enable blocking
|
|
// (GET /blocking/enable)
|
|
EnableBlocking(w http.ResponseWriter, r *http.Request)
|
|
// Blocking status
|
|
// (GET /blocking/status)
|
|
BlockingStatus(w http.ResponseWriter, r *http.Request)
|
|
// Clears the DNS response cache
|
|
// (POST /cache/flush)
|
|
CacheFlush(w http.ResponseWriter, r *http.Request)
|
|
// List refresh
|
|
// (POST /lists/refresh)
|
|
ListRefresh(w http.ResponseWriter, r *http.Request)
|
|
// Performs DNS query
|
|
// (POST /query)
|
|
Query(w http.ResponseWriter, r *http.Request)
|
|
}
|
|
|
|
// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.
|
|
|
|
type Unimplemented struct{}
|
|
|
|
// Disable blocking
|
|
// (GET /blocking/disable)
|
|
func (_ Unimplemented) DisableBlocking(w http.ResponseWriter, r *http.Request, params DisableBlockingParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Enable blocking
|
|
// (GET /blocking/enable)
|
|
func (_ Unimplemented) EnableBlocking(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Blocking status
|
|
// (GET /blocking/status)
|
|
func (_ Unimplemented) BlockingStatus(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Clears the DNS response cache
|
|
// (POST /cache/flush)
|
|
func (_ Unimplemented) CacheFlush(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// List refresh
|
|
// (POST /lists/refresh)
|
|
func (_ Unimplemented) ListRefresh(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Performs DNS query
|
|
// (POST /query)
|
|
func (_ Unimplemented) Query(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// ServerInterfaceWrapper converts contexts to parameters.
|
|
type ServerInterfaceWrapper struct {
|
|
Handler ServerInterface
|
|
HandlerMiddlewares []MiddlewareFunc
|
|
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
type MiddlewareFunc func(http.Handler) http.Handler
|
|
|
|
// DisableBlocking operation middleware
|
|
func (siw *ServerInterfaceWrapper) DisableBlocking(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params DisableBlockingParams
|
|
|
|
// ------------- Optional query parameter "duration" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "duration", r.URL.Query(), ¶ms.Duration)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "duration", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "groups" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "groups", r.URL.Query(), ¶ms.Groups)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "groups", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.DisableBlocking(w, r, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// EnableBlocking operation middleware
|
|
func (siw *ServerInterfaceWrapper) EnableBlocking(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.EnableBlocking(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// BlockingStatus operation middleware
|
|
func (siw *ServerInterfaceWrapper) BlockingStatus(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.BlockingStatus(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// CacheFlush operation middleware
|
|
func (siw *ServerInterfaceWrapper) CacheFlush(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CacheFlush(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// ListRefresh operation middleware
|
|
func (siw *ServerInterfaceWrapper) ListRefresh(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.ListRefresh(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// Query operation middleware
|
|
func (siw *ServerInterfaceWrapper) Query(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.Query(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
type UnescapedCookieParamError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *UnescapedCookieParamError) Error() string {
|
|
return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
|
|
}
|
|
|
|
func (e *UnescapedCookieParamError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type UnmarshalingParamError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *UnmarshalingParamError) Error() string {
|
|
return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
|
|
}
|
|
|
|
func (e *UnmarshalingParamError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type RequiredParamError struct {
|
|
ParamName string
|
|
}
|
|
|
|
func (e *RequiredParamError) Error() string {
|
|
return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
|
|
}
|
|
|
|
type RequiredHeaderError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *RequiredHeaderError) Error() string {
|
|
return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
|
|
}
|
|
|
|
func (e *RequiredHeaderError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type InvalidParamFormatError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *InvalidParamFormatError) Error() string {
|
|
return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
|
|
}
|
|
|
|
func (e *InvalidParamFormatError) Unwrap() error {
|
|
return e.Err
|
|
}
|
|
|
|
type TooManyValuesForParamError struct {
|
|
ParamName string
|
|
Count int
|
|
}
|
|
|
|
func (e *TooManyValuesForParamError) Error() string {
|
|
return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
|
|
}
|
|
|
|
// Handler creates http.Handler with routing matching OpenAPI spec.
|
|
func Handler(si ServerInterface) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{})
|
|
}
|
|
|
|
type ChiServerOptions struct {
|
|
BaseURL string
|
|
BaseRouter chi.Router
|
|
Middlewares []MiddlewareFunc
|
|
ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
|
|
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{
|
|
BaseRouter: r,
|
|
})
|
|
}
|
|
|
|
func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
|
|
return HandlerWithOptions(si, ChiServerOptions{
|
|
BaseURL: baseURL,
|
|
BaseRouter: r,
|
|
})
|
|
}
|
|
|
|
// HandlerWithOptions creates http.Handler with additional options
|
|
func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler {
|
|
r := options.BaseRouter
|
|
|
|
if r == nil {
|
|
r = chi.NewRouter()
|
|
}
|
|
if options.ErrorHandlerFunc == nil {
|
|
options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
}
|
|
wrapper := ServerInterfaceWrapper{
|
|
Handler: si,
|
|
HandlerMiddlewares: options.Middlewares,
|
|
ErrorHandlerFunc: options.ErrorHandlerFunc,
|
|
}
|
|
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/blocking/disable", wrapper.DisableBlocking)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/blocking/enable", wrapper.EnableBlocking)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/blocking/status", wrapper.BlockingStatus)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/cache/flush", wrapper.CacheFlush)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/lists/refresh", wrapper.ListRefresh)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/query", wrapper.Query)
|
|
})
|
|
|
|
return r
|
|
}
|
|
|
|
type DisableBlockingRequestObject struct {
|
|
Params DisableBlockingParams
|
|
}
|
|
|
|
type DisableBlockingResponseObject interface {
|
|
VisitDisableBlockingResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type DisableBlocking200Response struct {
|
|
}
|
|
|
|
func (response DisableBlocking200Response) VisitDisableBlockingResponse(w http.ResponseWriter) error {
|
|
w.WriteHeader(200)
|
|
return nil
|
|
}
|
|
|
|
type DisableBlocking400TextResponse string
|
|
|
|
func (response DisableBlocking400TextResponse) VisitDisableBlockingResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
w.WriteHeader(400)
|
|
|
|
_, err := w.Write([]byte(response))
|
|
return err
|
|
}
|
|
|
|
type EnableBlockingRequestObject struct {
|
|
}
|
|
|
|
type EnableBlockingResponseObject interface {
|
|
VisitEnableBlockingResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type EnableBlocking200Response struct {
|
|
}
|
|
|
|
func (response EnableBlocking200Response) VisitEnableBlockingResponse(w http.ResponseWriter) error {
|
|
w.WriteHeader(200)
|
|
return nil
|
|
}
|
|
|
|
type BlockingStatusRequestObject struct {
|
|
}
|
|
|
|
type BlockingStatusResponseObject interface {
|
|
VisitBlockingStatusResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type BlockingStatus200JSONResponse ApiBlockingStatus
|
|
|
|
func (response BlockingStatus200JSONResponse) VisitBlockingStatusResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type CacheFlushRequestObject struct {
|
|
}
|
|
|
|
type CacheFlushResponseObject interface {
|
|
VisitCacheFlushResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CacheFlush200Response struct {
|
|
}
|
|
|
|
func (response CacheFlush200Response) VisitCacheFlushResponse(w http.ResponseWriter) error {
|
|
w.WriteHeader(200)
|
|
return nil
|
|
}
|
|
|
|
type ListRefreshRequestObject struct {
|
|
}
|
|
|
|
type ListRefreshResponseObject interface {
|
|
VisitListRefreshResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ListRefresh200Response struct {
|
|
}
|
|
|
|
func (response ListRefresh200Response) VisitListRefreshResponse(w http.ResponseWriter) error {
|
|
w.WriteHeader(200)
|
|
return nil
|
|
}
|
|
|
|
type ListRefresh500TextResponse string
|
|
|
|
func (response ListRefresh500TextResponse) VisitListRefreshResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
w.WriteHeader(500)
|
|
|
|
_, err := w.Write([]byte(response))
|
|
return err
|
|
}
|
|
|
|
type QueryRequestObject struct {
|
|
Body *QueryJSONRequestBody
|
|
}
|
|
|
|
type QueryResponseObject interface {
|
|
VisitQueryResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type Query200JSONResponse ApiQueryResult
|
|
|
|
func (response Query200JSONResponse) VisitQueryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type Query400TextResponse string
|
|
|
|
func (response Query400TextResponse) VisitQueryResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
w.WriteHeader(400)
|
|
|
|
_, err := w.Write([]byte(response))
|
|
return err
|
|
}
|
|
|
|
// StrictServerInterface represents all server handlers.
|
|
type StrictServerInterface interface {
|
|
// Disable blocking
|
|
// (GET /blocking/disable)
|
|
DisableBlocking(ctx context.Context, request DisableBlockingRequestObject) (DisableBlockingResponseObject, error)
|
|
// Enable blocking
|
|
// (GET /blocking/enable)
|
|
EnableBlocking(ctx context.Context, request EnableBlockingRequestObject) (EnableBlockingResponseObject, error)
|
|
// Blocking status
|
|
// (GET /blocking/status)
|
|
BlockingStatus(ctx context.Context, request BlockingStatusRequestObject) (BlockingStatusResponseObject, error)
|
|
// Clears the DNS response cache
|
|
// (POST /cache/flush)
|
|
CacheFlush(ctx context.Context, request CacheFlushRequestObject) (CacheFlushResponseObject, error)
|
|
// List refresh
|
|
// (POST /lists/refresh)
|
|
ListRefresh(ctx context.Context, request ListRefreshRequestObject) (ListRefreshResponseObject, error)
|
|
// Performs DNS query
|
|
// (POST /query)
|
|
Query(ctx context.Context, request QueryRequestObject) (QueryResponseObject, error)
|
|
}
|
|
|
|
type StrictHandlerFunc = strictnethttp.StrictHttpHandlerFunc
|
|
type StrictMiddlewareFunc = strictnethttp.StrictHttpMiddlewareFunc
|
|
|
|
type StrictHTTPServerOptions struct {
|
|
RequestErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
|
|
}
|
|
|
|
func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
|
|
RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
},
|
|
ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
},
|
|
}}
|
|
}
|
|
|
|
func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
|
|
}
|
|
|
|
type strictHandler struct {
|
|
ssi StrictServerInterface
|
|
middlewares []StrictMiddlewareFunc
|
|
options StrictHTTPServerOptions
|
|
}
|
|
|
|
// DisableBlocking operation middleware
|
|
func (sh *strictHandler) DisableBlocking(w http.ResponseWriter, r *http.Request, params DisableBlockingParams) {
|
|
var request DisableBlockingRequestObject
|
|
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.DisableBlocking(ctx, request.(DisableBlockingRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "DisableBlocking")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(DisableBlockingResponseObject); ok {
|
|
if err := validResponse.VisitDisableBlockingResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// EnableBlocking operation middleware
|
|
func (sh *strictHandler) EnableBlocking(w http.ResponseWriter, r *http.Request) {
|
|
var request EnableBlockingRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.EnableBlocking(ctx, request.(EnableBlockingRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "EnableBlocking")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(EnableBlockingResponseObject); ok {
|
|
if err := validResponse.VisitEnableBlockingResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// BlockingStatus operation middleware
|
|
func (sh *strictHandler) BlockingStatus(w http.ResponseWriter, r *http.Request) {
|
|
var request BlockingStatusRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.BlockingStatus(ctx, request.(BlockingStatusRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "BlockingStatus")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(BlockingStatusResponseObject); ok {
|
|
if err := validResponse.VisitBlockingStatusResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// CacheFlush operation middleware
|
|
func (sh *strictHandler) CacheFlush(w http.ResponseWriter, r *http.Request) {
|
|
var request CacheFlushRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.CacheFlush(ctx, request.(CacheFlushRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CacheFlush")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CacheFlushResponseObject); ok {
|
|
if err := validResponse.VisitCacheFlushResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// ListRefresh operation middleware
|
|
func (sh *strictHandler) ListRefresh(w http.ResponseWriter, r *http.Request) {
|
|
var request ListRefreshRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ListRefresh(ctx, request.(ListRefreshRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ListRefresh")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ListRefreshResponseObject); ok {
|
|
if err := validResponse.VisitListRefreshResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// Query operation middleware
|
|
func (sh *strictHandler) Query(w http.ResponseWriter, r *http.Request) {
|
|
var request QueryRequestObject
|
|
|
|
var body QueryJSONRequestBody
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
sh.options.RequestErrorHandlerFunc(w, r, fmt.Errorf("can't decode JSON body: %w", err))
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.Query(ctx, request.(QueryRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "Query")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(QueryResponseObject); ok {
|
|
if err := validResponse.VisitQueryResponse(w); err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
}
|
|
} else if response != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|