352 lines
12 KiB
Go
352 lines
12 KiB
Go
// Package api provides primitives to interact with the openapi HTTP API.
|
|
//
|
|
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version 2.5.0 DO NOT EDIT.
|
|
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"strings"
|
|
|
|
"github.com/getkin/kin-openapi/openapi3"
|
|
"github.com/gin-gonic/gin"
|
|
strictgin "github.com/oapi-codegen/runtime/strictmiddleware/gin"
|
|
)
|
|
|
|
// ServerInterface represents all server handlers.
|
|
type ServerInterface interface {
|
|
// Sign in with email and password
|
|
// (POST /signin/email-password)
|
|
SignInEmailPassword(c *gin.Context)
|
|
// Change user email
|
|
// (POST /user/email/change)
|
|
ChangeUserEmail(c *gin.Context)
|
|
}
|
|
|
|
// ServerInterfaceWrapper converts contexts to parameters.
|
|
type ServerInterfaceWrapper struct {
|
|
Handler ServerInterface
|
|
HandlerMiddlewares []MiddlewareFunc
|
|
ErrorHandler func(*gin.Context, error, int)
|
|
}
|
|
|
|
type MiddlewareFunc func(c *gin.Context)
|
|
|
|
// SignInEmailPassword operation middleware
|
|
func (siw *ServerInterfaceWrapper) SignInEmailPassword(c *gin.Context) {
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
middleware(c)
|
|
if c.IsAborted() {
|
|
return
|
|
}
|
|
}
|
|
|
|
siw.Handler.SignInEmailPassword(c)
|
|
}
|
|
|
|
// ChangeUserEmail operation middleware
|
|
func (siw *ServerInterfaceWrapper) ChangeUserEmail(c *gin.Context) {
|
|
|
|
c.Set(BearerAuthElevatedScopes, []string{})
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
middleware(c)
|
|
if c.IsAborted() {
|
|
return
|
|
}
|
|
}
|
|
|
|
siw.Handler.ChangeUserEmail(c)
|
|
}
|
|
|
|
// GinServerOptions provides options for the Gin server.
|
|
type GinServerOptions struct {
|
|
BaseURL string
|
|
Middlewares []MiddlewareFunc
|
|
ErrorHandler func(*gin.Context, error, int)
|
|
}
|
|
|
|
// RegisterHandlers creates http.Handler with routing matching OpenAPI spec.
|
|
func RegisterHandlers(router gin.IRouter, si ServerInterface) {
|
|
RegisterHandlersWithOptions(router, si, GinServerOptions{})
|
|
}
|
|
|
|
// RegisterHandlersWithOptions creates http.Handler with additional options
|
|
func RegisterHandlersWithOptions(router gin.IRouter, si ServerInterface, options GinServerOptions) {
|
|
errorHandler := options.ErrorHandler
|
|
if errorHandler == nil {
|
|
errorHandler = func(c *gin.Context, err error, statusCode int) {
|
|
c.JSON(statusCode, gin.H{"msg": err.Error()})
|
|
}
|
|
}
|
|
|
|
wrapper := ServerInterfaceWrapper{
|
|
Handler: si,
|
|
HandlerMiddlewares: options.Middlewares,
|
|
ErrorHandler: errorHandler,
|
|
}
|
|
|
|
router.POST(options.BaseURL+"/signin/email-password", wrapper.SignInEmailPassword)
|
|
router.POST(options.BaseURL+"/user/email/change", wrapper.ChangeUserEmail)
|
|
}
|
|
|
|
type SignInEmailPasswordRequestObject struct {
|
|
Body *SignInEmailPasswordJSONRequestBody
|
|
}
|
|
|
|
type SignInEmailPasswordResponseObject interface {
|
|
VisitSignInEmailPasswordResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type SignInEmailPassword200JSONResponse SignInEmailPasswordResponse
|
|
|
|
func (response SignInEmailPassword200JSONResponse) VisitSignInEmailPasswordResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type SignInEmailPassworddefaultJSONResponse struct {
|
|
Body ErrorResponse
|
|
StatusCode int
|
|
}
|
|
|
|
func (response SignInEmailPassworddefaultJSONResponse) VisitSignInEmailPasswordResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(response.StatusCode)
|
|
|
|
return json.NewEncoder(w).Encode(response.Body)
|
|
}
|
|
|
|
type ChangeUserEmailRequestObject struct {
|
|
Body *ChangeUserEmailJSONRequestBody
|
|
}
|
|
|
|
type ChangeUserEmailResponseObject interface {
|
|
VisitChangeUserEmailResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ChangeUserEmail200JSONResponse OKResponse
|
|
|
|
func (response ChangeUserEmail200JSONResponse) VisitChangeUserEmailResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(200)
|
|
|
|
return json.NewEncoder(w).Encode(response)
|
|
}
|
|
|
|
type ChangeUserEmaildefaultJSONResponse struct {
|
|
Body ErrorResponse
|
|
StatusCode int
|
|
}
|
|
|
|
func (response ChangeUserEmaildefaultJSONResponse) VisitChangeUserEmailResponse(w http.ResponseWriter) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(response.StatusCode)
|
|
|
|
return json.NewEncoder(w).Encode(response.Body)
|
|
}
|
|
|
|
// StrictServerInterface represents all server handlers.
|
|
type StrictServerInterface interface {
|
|
// Sign in with email and password
|
|
// (POST /signin/email-password)
|
|
SignInEmailPassword(ctx context.Context, request SignInEmailPasswordRequestObject) (SignInEmailPasswordResponseObject, error)
|
|
// Change user email
|
|
// (POST /user/email/change)
|
|
ChangeUserEmail(ctx context.Context, request ChangeUserEmailRequestObject) (ChangeUserEmailResponseObject, error)
|
|
}
|
|
|
|
type StrictHandlerFunc = strictgin.StrictGinHandlerFunc
|
|
type StrictMiddlewareFunc = strictgin.StrictGinMiddlewareFunc
|
|
|
|
func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares}
|
|
}
|
|
|
|
type strictHandler struct {
|
|
ssi StrictServerInterface
|
|
middlewares []StrictMiddlewareFunc
|
|
}
|
|
|
|
// SignInEmailPassword operation middleware
|
|
func (sh *strictHandler) SignInEmailPassword(ctx *gin.Context) {
|
|
var request SignInEmailPasswordRequestObject
|
|
|
|
var body SignInEmailPasswordJSONRequestBody
|
|
if err := ctx.ShouldBindJSON(&body); err != nil {
|
|
ctx.Status(http.StatusBadRequest)
|
|
ctx.Error(err)
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
|
|
return sh.ssi.SignInEmailPassword(ctx, request.(SignInEmailPasswordRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "SignInEmailPassword")
|
|
}
|
|
|
|
response, err := handler(ctx, request)
|
|
|
|
if err != nil {
|
|
ctx.Error(err)
|
|
ctx.Status(http.StatusInternalServerError)
|
|
} else if validResponse, ok := response.(SignInEmailPasswordResponseObject); ok {
|
|
if err := validResponse.VisitSignInEmailPasswordResponse(ctx.Writer); err != nil {
|
|
ctx.Error(err)
|
|
}
|
|
} else if response != nil {
|
|
ctx.Error(fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// ChangeUserEmail operation middleware
|
|
func (sh *strictHandler) ChangeUserEmail(ctx *gin.Context) {
|
|
var request ChangeUserEmailRequestObject
|
|
|
|
var body ChangeUserEmailJSONRequestBody
|
|
if err := ctx.ShouldBindJSON(&body); err != nil {
|
|
ctx.Status(http.StatusBadRequest)
|
|
ctx.Error(err)
|
|
return
|
|
}
|
|
request.Body = &body
|
|
|
|
handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ChangeUserEmail(ctx, request.(ChangeUserEmailRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ChangeUserEmail")
|
|
}
|
|
|
|
response, err := handler(ctx, request)
|
|
|
|
if err != nil {
|
|
ctx.Error(err)
|
|
ctx.Status(http.StatusInternalServerError)
|
|
} else if validResponse, ok := response.(ChangeUserEmailResponseObject); ok {
|
|
if err := validResponse.VisitChangeUserEmailResponse(ctx.Writer); err != nil {
|
|
ctx.Error(err)
|
|
}
|
|
} else if response != nil {
|
|
ctx.Error(fmt.Errorf("unexpected response type: %T", response))
|
|
}
|
|
}
|
|
|
|
// Base64 encoded, gzipped, json marshaled Swagger object
|
|
var swaggerSpec = []string{
|
|
|
|
"H4sIAAAAAAAC/9RYUXPbuBH+KxhcO30RJMVW0lhP9WV8rXLXS8Z22s7YfoCApYiYBHhY0IrO1X/vLEBK",
|
|
"pEQ1vs5dp32yTBCL3f2+b3fBZ65cWTkLNiCfP3NUOZQy/rzy3vlrwMpZBHogtTbBOCuLj95V4IMB5PNM",
|
|
"FggjrgGVNxWt8zm/CdJq6bX5GTQDMsR8a2nEq872Zx6X6UffRDyeKaeBGQ02mGxj7IqFHBhWoExmFJNV",
|
|
"VRglaUc6hY842Lrk8zuuIZN1EYR3BYiyxiCWIIwVsijcGnR8jnzEtUG5LEALsLpyxobusxoh2iylKYQs",
|
|
"PEi9ISN1jKP/+Am8yQxoPuKZ80ujNVghrbOb0tV0krEBvJWFQPBP4EXrsbFPsjBaJHOVRFw7rzsLHn6q",
|
|
"AcmxwilZgLAutHFQOpsdIjgnMHc+dB8aK3KzrISWQS5l9NuDNh5UuHUHlmKu+o/QrGxdiTYjfMRr20ba",
|
|
"pof+pG29aJPzlQy9UDIPmIvgHsF2ngejHqGX+jKTIrhQ8RG3Lv4SCMpD11qzHl/dVMn1zNWW3Iw7Wmyk",
|
|
"CuYJOjsxyED/O1mHxhsBKpd2BSKTJkWaFivvMlOAyCCofGDxyegBMJNnSlryCcFqgSXyhxEnR/mcY/DG",
|
|
"rvh2xEtAlCs4VsBf6lJakXkDVhebRkbt2yMOX2RZFWRrkc5kkUAsc76MOT86iYKuceCg29uPLC02p5Ds",
|
|
"ukfMptOdPaLxCjzfbolJP9XGgybBNdb3AY0aae+DdsvPoAK58uH7F1eWVtAfvh9M3w0gxjB+UYH6hOAZ",
|
|
"IUiVpakgmCwx5WyQxsZqQ8RAJq1mRHJmbMouGTmsY1IpQLyNxD5K8fu/3yZjBE/vYLtilx8XrNE49oCF",
|
|
"zft8+WdlPpj3i08/L179aBa4sNev1bvFm8Vj9Y+/vXt/MR6Ph7DueHP1pTIecDHgVlxK0QdTAnNZLLBp",
|
|
"c+OwocwoZ3XPtwtiREO1yIk3M35MEWJIFPyJtMTHlFrNgmPNu0cu9HJyps5fL99k50LNlhdi9hbOxcUf",
|
|
"30qhZ3qavdKzMzibxfoXqNryOb+/X95NxYUU2cPz2+39/VLs/p1tT/7u7np1RtuGstyNbqGP41ukzmXA",
|
|
"R9wpsF2Q/8uRHUi7S+0T1DpA+ig1Q0Xgxqzswl5R1frYtKvrptX9MjU3u4hDHWkBq5HklcoiabjTWw9m",
|
|
"EHrlGD6qEn/A1oDWHrAv0M8ut2MsTcj/ZHOHYWwc78gimR3gzc6RU0d2PN2fdhP81K5iqr6h1n4x++fv",
|
|
"qd7KLz+AXYWcz19PR7w0tv33/GvAtg7ujnsxTP/RWNhui2LojzuHxTjkMrBSbpixqqg1MLmrz86zv353",
|
|
"yVQuiwLs6niixH1L+J2HjM/5N5P9mDtpZtxJ2zkoKUdBEw4x5HdxKHgpL/uOWFhfDTPrknVa9q9AqQNc",
|
|
"dwcf40lzAKjam7C5oUQkT78F6cFf1sSaQ1/T2iFAaxNyRm2tW6nH7FNTy3s6bJsbLVTeBVCB7gXNwI3U",
|
|
"wCIo5OcynraPMA+hIkD2Hl4V8CQD6Jd6GqnUZAcZNLtZBb40kQHYuE2sRLBoaFhkBGQ0gHsyNlbYngOs",
|
|
"TSYrQWJNJ2CtciaReVBgw4E3Y/ad80xDkKZAhgCMAsT5ZKKdwnEL+aTyTtcq4IS2T1qnRcfpryeNsKaJ",
|
|
"hc9tXRQj7iqwsjJ8zs/H0/E09ZI84j+hOd/YycEdZP7MK5dof8DfLrwyDUeRESEH4wdK7phdQ6g9DVN7",
|
|
"IUdKHumZmYyFtROZVMEdoWmQgY1XBKLNDiTqvkOViidhAIZvnd5QIDTegU1S3t8fJ58xVYxUHb5aO063",
|
|
"rpj2gWlTeYjTgCxwX/96OToIlXc1HXwNUeSpgkbQzqbT3zagpsgPRHR5MDrXsQhkdTFmiyzCucdpxGQH",
|
|
"3LUpCrakmkB0AM2MxQBS0+y5o8aYxxPjDf5XC7H/QWMoqOYrAnNK1d6DZuvcFEAli6JrPz/4HdAjjnVZ",
|
|
"Sr9puEezclTBwMhBb09IJ0ljk3TZPK2wzkyTXk1jcUd36U5yOJ+M2SVLF/T2w0hcbdOOVJKCi8YsrNtd",
|
|
"8RhnM+PLuJSOJNH+u7J5JMDULHe98zcS34nePIDoj7DuZydi4qqmdrcfQtin6x86mmyg+W/Kr3MfHgjj",
|
|
"quNWSz/QY3a5RzfkTPZxL4x9ZLlEtgSwp3D/v9FZ02X5/O55cBS4e9g+dOWYqJEa025mkiuk6Sh+tnrY",
|
|
"brfbfwUAAP//3ciGL/8UAAA=",
|
|
}
|
|
|
|
// 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: %w", err)
|
|
}
|
|
zr, err := gzip.NewReader(bytes.NewReader(zipped))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %w", err)
|
|
}
|
|
var buf bytes.Buffer
|
|
_, err = buf.ReadFrom(zr)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error decompressing spec: %w", 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) {
|
|
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) {
|
|
resolvePath := PathToRawSpec("")
|
|
|
|
loader := openapi3.NewLoader()
|
|
loader.IsExternalRefsAllowed = true
|
|
loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
|
|
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
|
|
}
|