nyanimedb/api/api.gen.go

// Package oapi provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.5.0 DO NOT EDIT.
package oapi

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/oapi-codegen/runtime"
	strictgin "github.com/oapi-codegen/runtime/strictmiddleware/gin"
	openapi_types "github.com/oapi-codegen/runtime/types"
)

// Defines values for ReleaseSeason.
const (
	Fall   ReleaseSeason = "fall"
	Spring ReleaseSeason = "spring"
	Summer ReleaseSeason = "summer"
	Winter ReleaseSeason = "winter"
)

// Defines values for TitleStatus.
const (
	Finished TitleStatus = "finished"
	Ongoing  TitleStatus = "ongoing"
	Planned  TitleStatus = "planned"
)

// ReleaseSeason Title release season
type ReleaseSeason string

// Title defines model for Title.
type Title struct {
	EpisodesAired *int32              `json:"episodes_aired,omitempty"`
	EpisodesAll   *int32              `json:"episodes_all,omitempty"`
	EpisodesLen   *map[string]float64 `json:"episodes_len,omitempty"`

	// Id Unique title ID (primary key)
	Id          *int64   `json:"id,omitempty"`
	PosterId    *int64   `json:"poster_id,omitempty"`
	Rating      *float64 `json:"rating,omitempty"`
	RatingCount *int32   `json:"rating_count,omitempty"`

	// ReleaseSeason Title release season
	ReleaseSeason *ReleaseSeason `json:"release_season,omitempty"`
	ReleaseYear   *int32         `json:"release_year,omitempty"`
	StudioId      *int64         `json:"studio_id,omitempty"`

	// TitleNames Localized titles. Key = language (ISO 639-1), value = list of names
	TitleNames *map[string][]string `json:"title_names,omitempty"`

	// TitleStatus Title status
	TitleStatus          *TitleStatus           `json:"title_status,omitempty"`
	AdditionalProperties map[string]interface{} `json:"-"`
}

// TitleStatus Title status
type TitleStatus string

// User defines model for User.
type User struct {
	// AvatarId ID of the user avatar (references images table)
	AvatarId *int64 `json:"avatar_id"`

	// CreationDate Timestamp when the user was created
	CreationDate *time.Time `json:"creation_date,omitempty"`

	// DispName Display name
	DispName *string `json:"disp_name,omitempty"`

	// Id Unique user ID (primary key)
	Id *int64 `json:"id,omitempty"`

	// Mail User email
	Mail *openapi_types.Email `json:"mail,omitempty"`

	// Nickname Username (alphanumeric + _ or -)
	Nickname string `json:"nickname"`

	// UserDesc User description
	UserDesc *string `json:"user_desc,omitempty"`
}

// GetTitleParams defines parameters for GetTitle.
type GetTitleParams struct {
	Word          *string        `form:"word,omitempty" json:"word,omitempty"`
	Status        *TitleStatus   `form:"status,omitempty" json:"status,omitempty"`
	Rating        *float64       `form:"rating,omitempty" json:"rating,omitempty"`
	ReleaseYear   *int32         `form:"release_year,omitempty" json:"release_year,omitempty"`
	ReleaseSeason *ReleaseSeason `form:"release_season,omitempty" json:"release_season,omitempty"`
	Limit         *int           `form:"limit,omitempty" json:"limit,omitempty"`
	Offset        *int           `form:"offset,omitempty" json:"offset,omitempty"`
	Fields        *string        `form:"fields,omitempty" json:"fields,omitempty"`
}

// GetUsersUserIdParams defines parameters for GetUsersUserId.
type GetUsersUserIdParams struct {
	Fields *string `form:"fields,omitempty" json:"fields,omitempty"`
}

// Getter for additional properties for Title. Returns the specified
// element and whether it was found
func (a Title) Get(fieldName string) (value interface{}, found bool) {
	if a.AdditionalProperties != nil {
		value, found = a.AdditionalProperties[fieldName]
	}
	return
}

// Setter for additional properties for Title
func (a *Title) Set(fieldName string, value interface{}) {
	if a.AdditionalProperties == nil {
		a.AdditionalProperties = make(map[string]interface{})
	}
	a.AdditionalProperties[fieldName] = value
}

// Override default JSON handling for Title to handle AdditionalProperties
func (a *Title) UnmarshalJSON(b []byte) error {
	object := make(map[string]json.RawMessage)
	err := json.Unmarshal(b, &object)
	if err != nil {
		return err
	}

	if raw, found := object["episodes_aired"]; found {
		err = json.Unmarshal(raw, &a.EpisodesAired)
		if err != nil {
			return fmt.Errorf("error reading 'episodes_aired': %w", err)
		}
		delete(object, "episodes_aired")
	}

	if raw, found := object["episodes_all"]; found {
		err = json.Unmarshal(raw, &a.EpisodesAll)
		if err != nil {
			return fmt.Errorf("error reading 'episodes_all': %w", err)
		}
		delete(object, "episodes_all")
	}

	if raw, found := object["episodes_len"]; found {
		err = json.Unmarshal(raw, &a.EpisodesLen)
		if err != nil {
			return fmt.Errorf("error reading 'episodes_len': %w", err)
		}
		delete(object, "episodes_len")
	}

	if raw, found := object["id"]; found {
		err = json.Unmarshal(raw, &a.Id)
		if err != nil {
			return fmt.Errorf("error reading 'id': %w", err)
		}
		delete(object, "id")
	}

	if raw, found := object["poster_id"]; found {
		err = json.Unmarshal(raw, &a.PosterId)
		if err != nil {
			return fmt.Errorf("error reading 'poster_id': %w", err)
		}
		delete(object, "poster_id")
	}

	if raw, found := object["rating"]; found {
		err = json.Unmarshal(raw, &a.Rating)
		if err != nil {
			return fmt.Errorf("error reading 'rating': %w", err)
		}
		delete(object, "rating")
	}

	if raw, found := object["rating_count"]; found {
		err = json.Unmarshal(raw, &a.RatingCount)
		if err != nil {
			return fmt.Errorf("error reading 'rating_count': %w", err)
		}
		delete(object, "rating_count")
	}

	if raw, found := object["release_season"]; found {
		err = json.Unmarshal(raw, &a.ReleaseSeason)
		if err != nil {
			return fmt.Errorf("error reading 'release_season': %w", err)
		}
		delete(object, "release_season")
	}

	if raw, found := object["release_year"]; found {
		err = json.Unmarshal(raw, &a.ReleaseYear)
		if err != nil {
			return fmt.Errorf("error reading 'release_year': %w", err)
		}
		delete(object, "release_year")
	}

	if raw, found := object["studio_id"]; found {
		err = json.Unmarshal(raw, &a.StudioId)
		if err != nil {
			return fmt.Errorf("error reading 'studio_id': %w", err)
		}
		delete(object, "studio_id")
	}

	if raw, found := object["title_names"]; found {
		err = json.Unmarshal(raw, &a.TitleNames)
		if err != nil {
			return fmt.Errorf("error reading 'title_names': %w", err)
		}
		delete(object, "title_names")
	}

	if raw, found := object["title_status"]; found {
		err = json.Unmarshal(raw, &a.TitleStatus)
		if err != nil {
			return fmt.Errorf("error reading 'title_status': %w", err)
		}
		delete(object, "title_status")
	}

	if len(object) != 0 {
		a.AdditionalProperties = make(map[string]interface{})
		for fieldName, fieldBuf := range object {
			var fieldVal interface{}
			err := json.Unmarshal(fieldBuf, &fieldVal)
			if err != nil {
				return fmt.Errorf("error unmarshaling field %s: %w", fieldName, err)
			}
			a.AdditionalProperties[fieldName] = fieldVal
		}
	}
	return nil
}

// Override default JSON handling for Title to handle AdditionalProperties
func (a Title) MarshalJSON() ([]byte, error) {
	var err error
	object := make(map[string]json.RawMessage)

	if a.EpisodesAired != nil {
		object["episodes_aired"], err = json.Marshal(a.EpisodesAired)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'episodes_aired': %w", err)
		}
	}

	if a.EpisodesAll != nil {
		object["episodes_all"], err = json.Marshal(a.EpisodesAll)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'episodes_all': %w", err)
		}
	}

	if a.EpisodesLen != nil {
		object["episodes_len"], err = json.Marshal(a.EpisodesLen)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'episodes_len': %w", err)
		}
	}

	if a.Id != nil {
		object["id"], err = json.Marshal(a.Id)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'id': %w", err)
		}
	}

	if a.PosterId != nil {
		object["poster_id"], err = json.Marshal(a.PosterId)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'poster_id': %w", err)
		}
	}

	if a.Rating != nil {
		object["rating"], err = json.Marshal(a.Rating)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'rating': %w", err)
		}
	}

	if a.RatingCount != nil {
		object["rating_count"], err = json.Marshal(a.RatingCount)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'rating_count': %w", err)
		}
	}

	if a.ReleaseSeason != nil {
		object["release_season"], err = json.Marshal(a.ReleaseSeason)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'release_season': %w", err)
		}
	}

	if a.ReleaseYear != nil {
		object["release_year"], err = json.Marshal(a.ReleaseYear)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'release_year': %w", err)
		}
	}

	if a.StudioId != nil {
		object["studio_id"], err = json.Marshal(a.StudioId)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'studio_id': %w", err)
		}
	}

	if a.TitleNames != nil {
		object["title_names"], err = json.Marshal(a.TitleNames)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'title_names': %w", err)
		}
	}

	if a.TitleStatus != nil {
		object["title_status"], err = json.Marshal(a.TitleStatus)
		if err != nil {
			return nil, fmt.Errorf("error marshaling 'title_status': %w", err)
		}
	}

	for fieldName, field := range a.AdditionalProperties {
		object[fieldName], err = json.Marshal(field)
		if err != nil {
			return nil, fmt.Errorf("error marshaling '%s': %w", fieldName, err)
		}
	}
	return json.Marshal(object)
}

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// Get titles
	// (GET /title)
	GetTitle(c *gin.Context, params GetTitleParams)
	// Get user info
	// (GET /users/{user_id})
	GetUsersUserId(c *gin.Context, userId string, params GetUsersUserIdParams)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandler       func(*gin.Context, error, int)
}

type MiddlewareFunc func(c *gin.Context)

// GetTitle operation middleware
func (siw *ServerInterfaceWrapper) GetTitle(c *gin.Context) {

	var err error

	// Parameter object where we will unmarshal all parameters from the context
	var params GetTitleParams

	// ------------- Optional query parameter "word" -------------

	err = runtime.BindQueryParameter("form", true, false, "word", c.Request.URL.Query(), &params.Word)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter word: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "status" -------------

	err = runtime.BindQueryParameter("form", true, false, "status", c.Request.URL.Query(), &params.Status)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter status: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "rating" -------------

	err = runtime.BindQueryParameter("form", true, false, "rating", c.Request.URL.Query(), &params.Rating)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter rating: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "release_year" -------------

	err = runtime.BindQueryParameter("form", true, false, "release_year", c.Request.URL.Query(), &params.ReleaseYear)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter release_year: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "release_season" -------------

	err = runtime.BindQueryParameter("form", true, false, "release_season", c.Request.URL.Query(), &params.ReleaseSeason)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter release_season: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "limit" -------------

	err = runtime.BindQueryParameter("form", true, false, "limit", c.Request.URL.Query(), &params.Limit)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter limit: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "offset" -------------

	err = runtime.BindQueryParameter("form", true, false, "offset", c.Request.URL.Query(), &params.Offset)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter offset: %w", err), http.StatusBadRequest)
		return
	}

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameter("form", true, false, "fields", c.Request.URL.Query(), &params.Fields)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter fields: %w", err), http.StatusBadRequest)
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
		if c.IsAborted() {
			return
		}
	}

	siw.Handler.GetTitle(c, params)
}

// GetUsersUserId operation middleware
func (siw *ServerInterfaceWrapper) GetUsersUserId(c *gin.Context) {

	var err error

	// ------------- Path parameter "user_id" -------------
	var userId string

	err = runtime.BindStyledParameterWithOptions("simple", "user_id", c.Param("user_id"), &userId, runtime.BindStyledParameterOptions{Explode: false, Required: true})
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter user_id: %w", err), http.StatusBadRequest)
		return
	}

	// Parameter object where we will unmarshal all parameters from the context
	var params GetUsersUserIdParams

	// ------------- Optional query parameter "fields" -------------

	err = runtime.BindQueryParameter("form", true, false, "fields", c.Request.URL.Query(), &params.Fields)
	if err != nil {
		siw.ErrorHandler(c, fmt.Errorf("Invalid format for parameter fields: %w", err), http.StatusBadRequest)
		return
	}

	for _, middleware := range siw.HandlerMiddlewares {
		middleware(c)
		if c.IsAborted() {
			return
		}
	}

	siw.Handler.GetUsersUserId(c, userId, params)
}

// 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.GET(options.BaseURL+"/title", wrapper.GetTitle)
	router.GET(options.BaseURL+"/users/:user_id", wrapper.GetUsersUserId)
}

type GetTitleRequestObject struct {
	Params GetTitleParams
}

type GetTitleResponseObject interface {
	VisitGetTitleResponse(w http.ResponseWriter) error
}

type GetTitle200JSONResponse []Title

func (response GetTitle200JSONResponse) VisitGetTitleResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetTitle204Response struct {
}

func (response GetTitle204Response) VisitGetTitleResponse(w http.ResponseWriter) error {
	w.WriteHeader(204)
	return nil
}

type GetTitle400Response struct {
}

func (response GetTitle400Response) VisitGetTitleResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type GetTitle500Response struct {
}

func (response GetTitle500Response) VisitGetTitleResponse(w http.ResponseWriter) error {
	w.WriteHeader(500)
	return nil
}

type GetUsersUserIdRequestObject struct {
	UserId string `json:"user_id"`
	Params GetUsersUserIdParams
}

type GetUsersUserIdResponseObject interface {
	VisitGetUsersUserIdResponse(w http.ResponseWriter) error
}

type GetUsersUserId200JSONResponse User

func (response GetUsersUserId200JSONResponse) VisitGetUsersUserIdResponse(w http.ResponseWriter) error {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)

	return json.NewEncoder(w).Encode(response)
}

type GetUsersUserId400Response struct {
}

func (response GetUsersUserId400Response) VisitGetUsersUserIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(400)
	return nil
}

type GetUsersUserId404Response struct {
}

func (response GetUsersUserId404Response) VisitGetUsersUserIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(404)
	return nil
}

type GetUsersUserId500Response struct {
}

func (response GetUsersUserId500Response) VisitGetUsersUserIdResponse(w http.ResponseWriter) error {
	w.WriteHeader(500)
	return nil
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// Get titles
	// (GET /title)
	GetTitle(ctx context.Context, request GetTitleRequestObject) (GetTitleResponseObject, error)
	// Get user info
	// (GET /users/{user_id})
	GetUsersUserId(ctx context.Context, request GetUsersUserIdRequestObject) (GetUsersUserIdResponseObject, 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
}

// GetTitle operation middleware
func (sh *strictHandler) GetTitle(ctx *gin.Context, params GetTitleParams) {
	var request GetTitleRequestObject

	request.Params = params

	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetTitle(ctx, request.(GetTitleRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetTitle")
	}

	response, err := handler(ctx, request)

	if err != nil {
		ctx.Error(err)
		ctx.Status(http.StatusInternalServerError)
	} else if validResponse, ok := response.(GetTitleResponseObject); ok {
		if err := validResponse.VisitGetTitleResponse(ctx.Writer); err != nil {
			ctx.Error(err)
		}
	} else if response != nil {
		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
	}
}

// GetUsersUserId operation middleware
func (sh *strictHandler) GetUsersUserId(ctx *gin.Context, userId string, params GetUsersUserIdParams) {
	var request GetUsersUserIdRequestObject

	request.UserId = userId
	request.Params = params

	handler := func(ctx *gin.Context, request interface{}) (interface{}, error) {
		return sh.ssi.GetUsersUserId(ctx, request.(GetUsersUserIdRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetUsersUserId")
	}

	response, err := handler(ctx, request)

	if err != nil {
		ctx.Error(err)
		ctx.Status(http.StatusInternalServerError)
	} else if validResponse, ok := response.(GetUsersUserIdResponseObject); ok {
		if err := validResponse.VisitGetUsersUserIdResponse(ctx.Writer); err != nil {
			ctx.Error(err)
		}
	} else if response != nil {
		ctx.Error(fmt.Errorf("unexpected response type: %T", response))
	}
}