mirror of
https://github.com/navidrome/navidrome.git
synced 2025-04-05 13:37:38 +03:00
1371 lines
46 KiB
Go
1371 lines
46 KiB
Go
// Package api provides primitives to interact with the openapi HTTP API.
|
|
//
|
|
// Code generated by github.com/deepmap/oapi-codegen version v1.12.5-0.20230314231417-0cfaaa77a7d2 DO NOT EDIT.
|
|
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"strings"
|
|
|
|
"github.com/deepmap/oapi-codegen/pkg/runtime"
|
|
"github.com/getkin/kin-openapi/openapi3"
|
|
"github.com/go-chi/chi/v5"
|
|
)
|
|
|
|
// ServerInterface represents all server handlers.
|
|
type ServerInterface interface {
|
|
// Retrieve a list of albums
|
|
// (GET /albums)
|
|
GetAlbums(w http.ResponseWriter, r *http.Request, params GetAlbumsParams)
|
|
// Retrieve an individual album
|
|
// (GET /albums/{albumId})
|
|
GetAlbum(w http.ResponseWriter, r *http.Request, albumId string, params GetAlbumParams)
|
|
// Retrieve a list of artists
|
|
// (GET /artists)
|
|
GetArtists(w http.ResponseWriter, r *http.Request, params GetArtistsParams)
|
|
// Retrieve an individual artist
|
|
// (GET /artists/{artistId})
|
|
GetArtist(w http.ResponseWriter, r *http.Request, artistId string, params GetArtistParams)
|
|
// Get server's global info
|
|
// (GET /server)
|
|
GetServerInfo(w http.ResponseWriter, r *http.Request)
|
|
// Get a list of tracks
|
|
// (GET /tracks)
|
|
GetTracks(w http.ResponseWriter, r *http.Request, params GetTracksParams)
|
|
// Retrieve an individual track
|
|
// (GET /tracks/{trackId})
|
|
GetTrack(w http.ResponseWriter, r *http.Request, trackId string, params GetTrackParams)
|
|
}
|
|
|
|
// 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
|
|
|
|
// GetAlbums operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAlbums(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 GetAlbumsParams
|
|
|
|
// ------------- Optional query parameter "page[limit]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[limit]", r.URL.Query(), ¶ms.PageLimit)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[limit]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page[offset]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[offset]", r.URL.Query(), ¶ms.PageOffset)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[offset]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[equals]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[equals]", r.URL.Query(), ¶ms.FilterEquals)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[equals]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[contains]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[contains]", r.URL.Query(), ¶ms.FilterContains)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[contains]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessThan]", r.URL.Query(), ¶ms.FilterLessThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessOrEqual]", r.URL.Query(), ¶ms.FilterLessOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterThan]", r.URL.Query(), ¶ms.FilterGreaterThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterOrEqual]", r.URL.Query(), ¶ms.FilterGreaterOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[startsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[startsWith]", r.URL.Query(), ¶ms.FilterStartsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[startsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[endsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[endsWith]", r.URL.Query(), ¶ms.FilterEndsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[endsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort", r.URL.Query(), ¶ms.Sort)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAlbums(w, r, params)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetAlbum operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetAlbum(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "albumId" -------------
|
|
var albumId string
|
|
|
|
err = runtime.BindStyledParameterWithLocation("simple", false, "albumId", runtime.ParamLocationPath, chi.URLParam(r, "albumId"), &albumId)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "albumId", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetAlbumParams
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetAlbum(w, r, albumId, params)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtists operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtists(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 GetArtistsParams
|
|
|
|
// ------------- Optional query parameter "page[limit]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[limit]", r.URL.Query(), ¶ms.PageLimit)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[limit]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page[offset]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[offset]", r.URL.Query(), ¶ms.PageOffset)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[offset]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[equals]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[equals]", r.URL.Query(), ¶ms.FilterEquals)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[equals]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[contains]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[contains]", r.URL.Query(), ¶ms.FilterContains)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[contains]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessThan]", r.URL.Query(), ¶ms.FilterLessThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessOrEqual]", r.URL.Query(), ¶ms.FilterLessOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterThan]", r.URL.Query(), ¶ms.FilterGreaterThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterOrEqual]", r.URL.Query(), ¶ms.FilterGreaterOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[startsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[startsWith]", r.URL.Query(), ¶ms.FilterStartsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[startsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[endsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[endsWith]", r.URL.Query(), ¶ms.FilterEndsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[endsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort", r.URL.Query(), ¶ms.Sort)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtists(w, r, params)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetArtist operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetArtist(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "artistId" -------------
|
|
var artistId string
|
|
|
|
err = runtime.BindStyledParameterWithLocation("simple", false, "artistId", runtime.ParamLocationPath, chi.URLParam(r, "artistId"), &artistId)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "artistId", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetArtistParams
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetArtist(w, r, artistId, params)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetServerInfo operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetServerInfo(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetServerInfo(w, r)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetTracks operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetTracks(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 GetTracksParams
|
|
|
|
// ------------- Optional query parameter "page[limit]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[limit]", r.URL.Query(), ¶ms.PageLimit)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[limit]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "page[offset]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "page[offset]", r.URL.Query(), ¶ms.PageOffset)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "page[offset]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[equals]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[equals]", r.URL.Query(), ¶ms.FilterEquals)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[equals]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[contains]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[contains]", r.URL.Query(), ¶ms.FilterContains)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[contains]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessThan]", r.URL.Query(), ¶ms.FilterLessThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[lessOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[lessOrEqual]", r.URL.Query(), ¶ms.FilterLessOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[lessOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterThan]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterThan]", r.URL.Query(), ¶ms.FilterGreaterThan)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterThan]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[greaterOrEqual]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[greaterOrEqual]", r.URL.Query(), ¶ms.FilterGreaterOrEqual)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[greaterOrEqual]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[startsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[startsWith]", r.URL.Query(), ¶ms.FilterStartsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[startsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "filter[endsWith]" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "filter[endsWith]", r.URL.Query(), ¶ms.FilterEndsWith)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "filter[endsWith]", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "sort" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "sort", r.URL.Query(), ¶ms.Sort)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "sort", Err: err})
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetTracks(w, r, params)
|
|
})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r.WithContext(ctx))
|
|
}
|
|
|
|
// GetTrack operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetTrack(w http.ResponseWriter, r *http.Request) {
|
|
ctx := r.Context()
|
|
|
|
var err error
|
|
|
|
// ------------- Path parameter "trackId" -------------
|
|
var trackId string
|
|
|
|
err = runtime.BindStyledParameterWithLocation("simple", false, "trackId", runtime.ParamLocationPath, chi.URLParam(r, "trackId"), &trackId)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "trackId", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params GetTrackParams
|
|
|
|
// ------------- Optional query parameter "include" -------------
|
|
|
|
err = runtime.BindQueryParameter("form", true, false, "include", r.URL.Query(), ¶ms.Include)
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "include", Err: err})
|
|
return
|
|
}
|
|
|
|
var handler http.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetTrack(w, r, trackId, params)
|
|
})
|
|
|
|
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 UnmarshallingParamError struct {
|
|
ParamName string
|
|
Err error
|
|
}
|
|
|
|
func (e *UnmarshallingParamError) Error() string {
|
|
return fmt.Sprintf("Error unmarshalling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
|
|
}
|
|
|
|
func (e *UnmarshallingParamError) 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+"/albums", wrapper.GetAlbums)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/albums/{albumId}", wrapper.GetAlbum)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/artists", wrapper.GetArtists)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/artists/{artistId}", wrapper.GetArtist)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/server", wrapper.GetServerInfo)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/tracks", wrapper.GetTracks)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/tracks/{trackId}", wrapper.GetTrack)
|
|
})
|
|
|
|
return r
|
|
}
|
|
|
|
type BadRequestJSONResponse ErrorList
|
|
|
|
type InternalServerErrorJSONResponse ErrorList
|
|
|
|
type NotAuthorizedJSONResponse ErrorList
|
|
|
|
type NotFoundJSONResponse ErrorList
|
|
|
|
type GetAlbumsRequestObject struct {
|
|
Params GetAlbumsParams
|
|
}
|
|
|
|
type GetAlbumsResponseObject interface {
|
|
VisitGetAlbumsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAlbums200JSONResponse struct {
|
|
Data []Album `json:"data"`
|
|
Links PaginationLinks `json:"links"`
|
|
Meta *PaginationMeta `json:"meta,omitempty"`
|
|
}
|
|
|
|
func (response GetAlbums200JSONResponse) VisitGetAlbumsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbums400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetAlbums400JSONResponse) VisitGetAlbumsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbums403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetAlbums403JSONResponse) VisitGetAlbumsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbums500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAlbums500JSONResponse) VisitGetAlbumsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbumRequestObject struct {
|
|
AlbumId string `json:"albumId"`
|
|
Params GetAlbumParams
|
|
}
|
|
|
|
type GetAlbumResponseObject interface {
|
|
VisitGetAlbumResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetAlbum200JSONResponse struct {
|
|
Data Album `json:"data"`
|
|
}
|
|
|
|
func (response GetAlbum200JSONResponse) VisitGetAlbumResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbum403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetAlbum403JSONResponse) VisitGetAlbumResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbum404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetAlbum404JSONResponse) VisitGetAlbumResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetAlbum500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetAlbum500JSONResponse) VisitGetAlbumResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtistsRequestObject struct {
|
|
Params GetArtistsParams
|
|
}
|
|
|
|
type GetArtistsResponseObject interface {
|
|
VisitGetArtistsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtists200JSONResponse struct {
|
|
Data []Artist `json:"data"`
|
|
Links PaginationLinks `json:"links"`
|
|
Meta *PaginationMeta `json:"meta,omitempty"`
|
|
}
|
|
|
|
func (response GetArtists200JSONResponse) VisitGetArtistsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtists400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetArtists400JSONResponse) VisitGetArtistsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtists403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetArtists403JSONResponse) VisitGetArtistsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtists500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtists500JSONResponse) VisitGetArtistsResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtistRequestObject struct {
|
|
ArtistId string `json:"artistId"`
|
|
Params GetArtistParams
|
|
}
|
|
|
|
type GetArtistResponseObject interface {
|
|
VisitGetArtistResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetArtist200JSONResponse struct {
|
|
Data Artist `json:"data"`
|
|
}
|
|
|
|
func (response GetArtist200JSONResponse) VisitGetArtistResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtist403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetArtist403JSONResponse) VisitGetArtistResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtist404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetArtist404JSONResponse) VisitGetArtistResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetArtist500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetArtist500JSONResponse) VisitGetArtistResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetServerInfoRequestObject struct {
|
|
}
|
|
|
|
type GetServerInfoResponseObject interface {
|
|
VisitGetServerInfoResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetServerInfo200JSONResponse struct {
|
|
Data ServerInfo `json:"data"`
|
|
}
|
|
|
|
func (response GetServerInfo200JSONResponse) VisitGetServerInfoResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetServerInfo403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetServerInfo403JSONResponse) VisitGetServerInfoResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetServerInfo500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetServerInfo500JSONResponse) VisitGetServerInfoResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTracksRequestObject struct {
|
|
Params GetTracksParams
|
|
}
|
|
|
|
type GetTracksResponseObject interface {
|
|
VisitGetTracksResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetTracks200JSONResponse struct {
|
|
Data []Track `json:"data"`
|
|
Links PaginationLinks `json:"links"`
|
|
Meta *PaginationMeta `json:"meta,omitempty"`
|
|
}
|
|
|
|
func (response GetTracks200JSONResponse) VisitGetTracksResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTracks400JSONResponse struct{ BadRequestJSONResponse }
|
|
|
|
func (response GetTracks400JSONResponse) VisitGetTracksResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(400)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTracks403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetTracks403JSONResponse) VisitGetTracksResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTracks500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetTracks500JSONResponse) VisitGetTracksResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTrackRequestObject struct {
|
|
TrackId string `json:"trackId"`
|
|
Params GetTrackParams
|
|
}
|
|
|
|
type GetTrackResponseObject interface {
|
|
VisitGetTrackResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetTrack200JSONResponse struct {
|
|
Data Track `json:"data"`
|
|
}
|
|
|
|
func (response GetTrack200JSONResponse) VisitGetTrackResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTrack403JSONResponse struct{ NotAuthorizedJSONResponse }
|
|
|
|
func (response GetTrack403JSONResponse) VisitGetTrackResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(403)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTrack404JSONResponse struct{ NotFoundJSONResponse }
|
|
|
|
func (response GetTrack404JSONResponse) VisitGetTrackResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(404)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type GetTrack500JSONResponse struct {
|
|
InternalServerErrorJSONResponse
|
|
}
|
|
|
|
func (response GetTrack500JSONResponse) VisitGetTrackResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/vnd.api+json")
|
|
w.WriteHeader(500)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
// StrictServerInterface represents all server handlers.
|
|
type StrictServerInterface interface {
|
|
// Retrieve a list of albums
|
|
// (GET /albums)
|
|
GetAlbums(ctx context.Context, request GetAlbumsRequestObject) (GetAlbumsResponseObject, error)
|
|
// Retrieve an individual album
|
|
// (GET /albums/{albumId})
|
|
GetAlbum(ctx context.Context, request GetAlbumRequestObject) (GetAlbumResponseObject, error)
|
|
// Retrieve a list of artists
|
|
// (GET /artists)
|
|
GetArtists(ctx context.Context, request GetArtistsRequestObject) (GetArtistsResponseObject, error)
|
|
// Retrieve an individual artist
|
|
// (GET /artists/{artistId})
|
|
GetArtist(ctx context.Context, request GetArtistRequestObject) (GetArtistResponseObject, error)
|
|
// Get server's global info
|
|
// (GET /server)
|
|
GetServerInfo(ctx context.Context, request GetServerInfoRequestObject) (GetServerInfoResponseObject, error)
|
|
// Get a list of tracks
|
|
// (GET /tracks)
|
|
GetTracks(ctx context.Context, request GetTracksRequestObject) (GetTracksResponseObject, error)
|
|
// Retrieve an individual track
|
|
// (GET /tracks/{trackId})
|
|
GetTrack(ctx context.Context, request GetTrackRequestObject) (GetTrackResponseObject, error)
|
|
}
|
|
|
|
type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, args interface{}) (interface{}, error)
|
|
|
|
type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc
|
|
|
|
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
|
|
}
|
|
|
|
// GetAlbums operation middleware
|
|
func (sh *strictHandler) GetAlbums(w http.ResponseWriter, r *http.Request, params GetAlbumsParams) {
|
|
var request GetAlbumsRequestObject
|
|
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAlbums(ctx, request.(GetAlbumsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAlbums")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAlbumsResponseObject); ok {
|
|
if err := validResponse.VisitGetAlbumsResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetAlbum operation middleware
|
|
func (sh *strictHandler) GetAlbum(w http.ResponseWriter, r *http.Request, albumId string, params GetAlbumParams) {
|
|
var request GetAlbumRequestObject
|
|
|
|
request.AlbumId = albumId
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetAlbum(ctx, request.(GetAlbumRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetAlbum")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetAlbumResponseObject); ok {
|
|
if err := validResponse.VisitGetAlbumResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetArtists operation middleware
|
|
func (sh *strictHandler) GetArtists(w http.ResponseWriter, r *http.Request, params GetArtistsParams) {
|
|
var request GetArtistsRequestObject
|
|
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtists(ctx, request.(GetArtistsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtists")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtistsResponseObject); ok {
|
|
if err := validResponse.VisitGetArtistsResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetArtist operation middleware
|
|
func (sh *strictHandler) GetArtist(w http.ResponseWriter, r *http.Request, artistId string, params GetArtistParams) {
|
|
var request GetArtistRequestObject
|
|
|
|
request.ArtistId = artistId
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetArtist(ctx, request.(GetArtistRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetArtist")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetArtistResponseObject); ok {
|
|
if err := validResponse.VisitGetArtistResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetServerInfo operation middleware
|
|
func (sh *strictHandler) GetServerInfo(w http.ResponseWriter, r *http.Request) {
|
|
var request GetServerInfoRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetServerInfo(ctx, request.(GetServerInfoRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetServerInfo")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetServerInfoResponseObject); ok {
|
|
if err := validResponse.VisitGetServerInfoResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetTracks operation middleware
|
|
func (sh *strictHandler) GetTracks(w http.ResponseWriter, r *http.Request, params GetTracksParams) {
|
|
var request GetTracksRequestObject
|
|
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetTracks(ctx, request.(GetTracksRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetTracks")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetTracksResponseObject); ok {
|
|
if err := validResponse.VisitGetTracksResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetTrack operation middleware
|
|
func (sh *strictHandler) GetTrack(w http.ResponseWriter, r *http.Request, trackId string, params GetTrackParams) {
|
|
var request GetTrackRequestObject
|
|
|
|
request.TrackId = trackId
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetTrack(ctx, request.(GetTrackRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetTrack")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetTrackResponseObject); ok {
|
|
if err := validResponse.VisitGetTrackResponse(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))
|
|
}
|
|
}
|
|
|
|
// Base64 encoded, gzipped, json marshaled Swagger object
|
|
var swaggerSpec = []string{
|
|
|
|
"H4sIAAAAAAAC/+xb724buRF/FYItcHe4PclN0n4Q0A/ONRe4iBPDcZsPiQtwd0daXnbJDcmVrRgC+hp9",
|
|
"vT5JwSH3n8SVVkqcNEa+xPaSM/Ob4XD+kMwdTWRRSgHCaDq7oyVTrAADCv+a89yA+lUKw7jALynoRPHS",
|
|
"cCnojP6G4yReESZWpFSyBGVWJHEEXCyIgVszIf/QbAEz4ti99cP6+q81xWzJ8gpoRLnl+qECtaIRFawA",
|
|
"OqObVDSiOsmgYBYPN1B44MaAsuT/evfu5ueZ/YdG1KxKy0MbxcWCrpsPTCm2out15Nk/E6l+w002WkeT",
|
|
"MUNApJrccJMF9QTP8zA9G6r70fNDxfLxK4m6MUHgliWGFMwk2ZaWyPFAHR3NvWj4XAEzoF45VfdpKqoC",
|
|
"FE9ajReO3K6vIFIRhEqMJIygYpvqL3riDjPDBu1Yc6RHmOMqY+LTbLFbf8v/KOWR8F40fwFaH+sFOWg9",
|
|
"2gXyVtBhJugS3psJjlr5Vv8dOh++5g3VvWj72jBljojiGumG47hu+B6mbYfuM0c6LpK8SmFbzUvImYGU",
|
|
"KNCyUglo67Z+NuGCmAzsWCmFhohosOnezo9t0i4Kpgc0qgV21diAuY5oyRbwghfcbAO7ysB6WQyKyDlB",
|
|
"C5ASFLEkAzLt0NvcsuubL4U5q3JDZ386iehcqoIZRGgeP6IRLbjgRVXQ2UljNy4MLEA1EF/N5xoGMEoc",
|
|
"I3OJ0LhgOLYDoCMYQHgEQC1VANprqUy9eFVutF0wKcBGp0IqqB2agw6u6oRcKJjzW2TRT+4//PIDamvl",
|
|
"gUhtzSZVCmoyoDTi2+UG64jWHoZO/pSll/ChAo1q2SoOBP7KyjLnCRp4uhTphJX859+1xGDVsv+jgjmd",
|
|
"0T9M2zp16kb19JlSUr3g2jixfZM9ZSmpBa8jeibsVmP5a1BLUEj5ZfHUAIhDQByEdURfSnNamUwq/hHS",
|
|
"L4vppTSkI9uB+U1W4ivgcGJxCzgSy/E0j+1WuaMsz1/N6eztbiGXPuy9in+HxC77HW13BrIxRvG4Mu6v",
|
|
"XaxQ8mk7Hd06RwvojJcufvd5K8O166KaCL9fAhJddjhvB/yIGsWS9wdyvrI0uxmjTh8qrqzfvW0UaORd",
|
|
"NwTSG3S99eV6HdEhTbZMlDKz11G21pAW0KUSVZ5vIscZkWO/DboG2Fv7PrAFCAXhjIBDNmnZ2MnQHwMp",
|
|
"WkEOTMPfmBlg4yeQlJktbk2OsIPBAoCbfIAvDu2Bt2Etx62POfImGLTetjt9ltXdgDa8guhdXycSoOjD",
|
|
"QoG1mB620Lhd7ORaVgdt40EbtlHkk1EdHlwGUK3HhpgBY9xLiNml+TkYNuC8e6PQpiNtgY+53N7lp0Rn",
|
|
"tvyLuVwoVmarZre7PRGIF65WC9bgrIB99OtB7B3lt7Ar6ULUfhNe2pmbxkPyYatdyqEAaAmtRrZXxam2",
|
|
"z2EEnd3Wx3VMBGEriTrL0chtUh9XrgNGHPL0z+xyX8KKBzpqW6tt4QM7NL4SQU6tzjsjhGc9CGjI8VIw",
|
|
"jOeBViSiPA1+1oaZSgeHmky7O4XuwHrRtI0vuAiF2zlXzrJN2q8UD+3inI2bJ+B21LxSwXL/vPVOnc6D",
|
|
"XptUSoEwF7aZD25SPwHb/focIpF5Donvr7fa5M3WOKJGGpaf1V4XqITs+NYhw6cIs/rsEwZemtXsSGkh",
|
|
"i2/Eiy2LO8/exlUJ/qECwlMQhs85KGzu/ckBchw+YBoXwa7s3M39wNOa7fUOZa68mIA5V2WTljpAm5jt",
|
|
"Y3ibsWxUDkZt112fibkMlGWVyS4b1Js43mRgMnDGqjQokjFNWJLgUajEzxqZTyyyW1aUNlIYVUEDI5Yy",
|
|
"ByYsjjkwU6mQ+5yS3GYpOScSP7Gc1JM7QoiuylIqo/Egpvb6nkF0YxE8tivQW6/3nh9G1EnYXyDUSOTc",
|
|
"3DAFPb2pYEueKlkEHcpR/hOU5lKEBS3dYGfDDliYnkz+cjI52dvWeK02hUf9Ze+sTMhVMd1/lTYDJe/p",
|
|
"MvbSX/YoBmppJ+n/uF3fNEW4vxpR4Npp+JurBmPIpVjY3RzyWZzNmj5zm3WpeMHUqi4z9wqZBKXsELBd",
|
|
"nJObTJISlM0hkLZSQpxjbtTg8YMfbLhXKZdkznPMxu95LmNu3Im8hkSKlPz4Pi71T5NgcozLAePHwDyX",
|
|
"govKAPnx6cX5T7VQRB7mmGRMCMj1vosDh7ueXafbXYxlUdRvGzbCsFgRlqbch+B6om0ZhDSgCYtlZYL8",
|
|
"W5unXCdhzHakBn7DTYZNSVHlhv+CQ+g2Ycxppdy1Q5ixH+1Z1VrCLZzuVhzzXLJOg+fgWBFjz7uGNS94",
|
|
"AWYwn5+fnT/rJfXW4Sbh47NEqpSLxS9FPFTanFeaJ08V4+JjuL7xLPZj1/zjAG47Et4j8cqADq/X2NO5",
|
|
"wZ1r6qQTYICr2/ejJuoMwLEkx9tx2GwrYGr34aad0ffLugGfhOve0LFkv0Gn/cBcG6vjgJ0N0wkkbTz0",
|
|
"6z2YaC7HnuV91rP36OD7gqG0PfZYP3AsgFfJrlLG51Wu0/A3fS87BV6lcjqjmTGlnk2nTek3kcqFwQ2P",
|
|
"4JroEhLivse+sG0YktOLs4jcZDzJCMtzeaOx4MYyO1byRgNhIiUFE7ZdNBlwRQrrtSTnsbIpeMkZYeTv",
|
|
"r1+9nJ1enBESMw0psZ6l5iyBCbFeaUdKJZc8BU1ApKXkNsDPa5/UkXNSHflsqyNS5mxly3ONCFxNHRFm",
|
|
"U7p/IIBoSK80m5Bfc47JI2GCKDCKw9JGDReIbbBuk0mvLfX6RP6pAQrVUpn6njfCL3UFQBj2lJroylpO",
|
|
"k0QBMzbk2Vkp5IB/NDpMyBsHmWtn8hSWkFvndkjjiueptywrS6czluAcnw5kzKBNF1g6oPrtGjoyV2tH",
|
|
"3s4IhWhgBT4ggdsSFAeRABq9WWPfVKG0wCK33fPknd3TPr7Snv/QiC7r9oKeTB5NTqwjyhIEKzmd0ccT",
|
|
"1zOUzGS4tabtRl64239rCFyds5TO6HNwx8saidpXkAMdQDtl2j57sPX/iMn+AcKI2b1He6PnNw82R1M0",
|
|
"D4UOoqhfV40m6j5GO5ToYGGd50DjLV0/Ax1BgS8hRsyr386srzdeRjw6OTnqmv1Tbm8wpQaSUV6fVe6i",
|
|
"3jzaHHlxsnF6GLwZqhGEk9TQAYrf0uuIPnG2DMFobD7tPEVBksf7SfqPM9YR/fMYQaHHJviyoSpsB4kP",
|
|
"tXySYFvKrKM6Vk3v8OdZut4btQ4OWo1XRuOOETdumPFpkI2t7csgj5V2V9edjg0/FrrfLTFiJ4y8pdz2",
|
|
"QeEb/7aYPM6fnpw8GUXln8fcgwMKwkXKlzytWO7X1/lgW58Oul5z+vg9Y37PmA8zY7q+8+GkTL9lH0jO",
|
|
"rLXpBKzpnftlX9qsDxS+TN6spYUSp4f7rWROvyM+JXX6E/QHljtbw0zbK7Yh/+tcVH61pexgOHo5rzr/",
|
|
"peC///6PJpaSvIcVKVjp2v3mStevOEk5tvdMrYiCUoG220UsejeAXzvaPAfjsfygySKXMcvxRMetb/uW",
|
|
"bmh9r9yM76XR99LogZZG7q78wVRGfkt/g4WRDVVsS482TE3v8OeegujKX6x8kXqovsUJlEMe6zdSDflN",
|
|
"cHQxVN+TPaxSyHirNE+BnC+5a6QpK/l0+Yiur9f/CwAA//8K6nqbf0AAAA==",
|
|
}
|
|
|
|
// GetSwagger returns the content of the embedded swagger specification file
|
|
// or error if failed to decode
|
|
func decodeSpec() ([]byte, error) {
|
|
zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error base64 decoding spec: %s", err)
|
|
}
|
|
zr, err := gzip.NewReader(bytes.NewReader(zipped))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %s", err)
|
|
}
|
|
var buf bytes.Buffer
|
|
_, err = buf.ReadFrom(zr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %s", err)
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
var rawSpec = decodeSpecCached()
|
|
|
|
// a naive cached of a decoded swagger spec
|
|
func decodeSpecCached() func() ([]byte, error) {
|
|
data, err := decodeSpec()
|
|
return func() ([]byte, error) {
|
|
return data, err
|
|
}
|
|
}
|
|
|
|
// Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
|
|
func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
|
|
var res = make(map[string]func() ([]byte, error))
|
|
if len(pathToFile) > 0 {
|
|
res[pathToFile] = rawSpec
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
// GetSwagger returns the Swagger specification corresponding to the generated code
|
|
// in this file. The external references of Swagger specification are resolved.
|
|
// The logic of resolving external references is tightly connected to "import-mapping" feature.
|
|
// Externally referenced files must be embedded in the corresponding golang packages.
|
|
// Urls can be supported but this task was out of the scope.
|
|
func GetSwagger() (swagger *openapi3.T, err error) {
|
|
var resolvePath = PathToRawSpec("")
|
|
|
|
loader := openapi3.NewLoader()
|
|
loader.IsExternalRefsAllowed = true
|
|
loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
|
|
var pathToFile = url.String()
|
|
pathToFile = path.Clean(pathToFile)
|
|
getSpec, ok := resolvePath[pathToFile]
|
|
if !ok {
|
|
err1 := fmt.Errorf("path not found: %s", pathToFile)
|
|
return nil, err1
|
|
}
|
|
return getSpec()
|
|
}
|
|
var specData []byte
|
|
specData, err = rawSpec()
|
|
if err != nil {
|
|
return
|
|
}
|
|
swagger, err = loader.LoadFromData(specData)
|
|
if err != nil {
|
|
return
|
|
}
|
|
return
|
|
}
|