forked from mtusi2026/mtusi2026lab2
2908 lines
82 KiB
Go
2908 lines
82 KiB
Go
// Package handler provides primitives to interact with the openapi HTTP API.
|
|
//
|
|
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.8.0 DO NOT EDIT.
|
|
package handler
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/oapi-codegen/runtime"
|
|
openapi_types "github.com/oapi-codegen/runtime/types"
|
|
)
|
|
|
|
// Defines values for ErrorErrorCode.
|
|
const (
|
|
Conflict ErrorErrorCode = "conflict"
|
|
InternalError ErrorErrorCode = "internal_error"
|
|
InvalidRequest ErrorErrorCode = "invalid_request"
|
|
NotFound ErrorErrorCode = "not_found"
|
|
PayloadTooLarge ErrorErrorCode = "payload_too_large"
|
|
RateLimited ErrorErrorCode = "rate_limited"
|
|
Unauthorized ErrorErrorCode = "unauthorized"
|
|
Unavailable ErrorErrorCode = "unavailable"
|
|
UnsupportedMediaType ErrorErrorCode = "unsupported_media_type"
|
|
)
|
|
|
|
// Valid indicates whether the value is a known member of the ErrorErrorCode enum.
|
|
func (e ErrorErrorCode) Valid() bool {
|
|
switch e {
|
|
case Conflict:
|
|
return true
|
|
case InternalError:
|
|
return true
|
|
case InvalidRequest:
|
|
return true
|
|
case NotFound:
|
|
return true
|
|
case PayloadTooLarge:
|
|
return true
|
|
case RateLimited:
|
|
return true
|
|
case Unauthorized:
|
|
return true
|
|
case Unavailable:
|
|
return true
|
|
case UnsupportedMediaType:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Defines values for HealthStatus.
|
|
const (
|
|
Ok HealthStatus = "ok"
|
|
)
|
|
|
|
// Valid indicates whether the value is a known member of the HealthStatus enum.
|
|
func (e HealthStatus) Valid() bool {
|
|
switch e {
|
|
case Ok:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Defines values for SessionTokenType.
|
|
const (
|
|
Bearer SessionTokenType = "Bearer"
|
|
)
|
|
|
|
// Valid indicates whether the value is a known member of the SessionTokenType enum.
|
|
func (e SessionTokenType) Valid() bool {
|
|
switch e {
|
|
case Bearer:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Chat Examples: {"created_at":"2026-09-01T12:00:00Z","id":"33333333-3333-4333-8333-333333333333","member_ids":["11111111-1111-4111-8111-111111111111","22222222-2222-4222-8222-222222222222"],"title":"Проект по ВНП"}
|
|
type Chat struct {
|
|
CreatedAt Timestamp `json:"created_at"`
|
|
Id openapi_types.UUID `json:"id"`
|
|
MemberIds []openapi_types.UUID `json:"member_ids"`
|
|
Title string `json:"title"`
|
|
}
|
|
|
|
// ChatPage defines model for ChatPage.
|
|
type ChatPage struct {
|
|
Items []Chat `json:"items"`
|
|
NextCursor *string `json:"next_cursor"`
|
|
}
|
|
|
|
// CreateChat Examples: {"member_ids":["11111111-1111-4111-8111-111111111111","22222222-2222-4222-8222-222222222222"],"title":"Проект по ВНП"}
|
|
type CreateChat struct {
|
|
MemberIds []openapi_types.UUID `json:"member_ids"`
|
|
Title string `json:"title"`
|
|
}
|
|
|
|
// CreateMessage Examples: {"text":"Привет, Боб!"}
|
|
type CreateMessage struct {
|
|
Text string `json:"text"`
|
|
}
|
|
|
|
// CreateUser Examples: {"display_name":"Алиса","password":"Example-only-not-a-real-secret-123","username":"alice"}
|
|
type CreateUser struct {
|
|
DisplayName string `json:"display_name"`
|
|
Password *string `json:"password,omitempty"`
|
|
Username string `json:"username"`
|
|
}
|
|
|
|
// Error Examples: {"error":{"code":"not_found","message":"Объект не найден","request_id":"example-request-id"}}
|
|
type Error struct {
|
|
Error struct {
|
|
Code ErrorErrorCode `json:"code"`
|
|
Message string `json:"message"`
|
|
RequestId string `json:"request_id"`
|
|
} `json:"error"`
|
|
}
|
|
|
|
// ErrorErrorCode defines model for Error.Error.Code.
|
|
type ErrorErrorCode string
|
|
|
|
// Health defines model for Health.
|
|
type Health struct {
|
|
Status HealthStatus `json:"status"`
|
|
}
|
|
|
|
// HealthStatus defines model for Health.Status.
|
|
type HealthStatus string
|
|
|
|
// Message Examples: {"chat_id":"33333333-3333-4333-8333-333333333333","created_at":"2026-09-01T12:00:00Z","id":"44444444-4444-4444-8444-444444444444","sender_id":"11111111-1111-4111-8111-111111111111","text":"Привет, Боб!"}
|
|
type Message struct {
|
|
ChatId openapi_types.UUID `json:"chat_id"`
|
|
CreatedAt Timestamp `json:"created_at"`
|
|
Id openapi_types.UUID `json:"id"`
|
|
SenderId openapi_types.UUID `json:"sender_id"`
|
|
Text string `json:"text"`
|
|
}
|
|
|
|
// MessagePage Examples: {"items":[{"chat_id":"33333333-3333-4333-8333-333333333333","created_at":"2026-09-01T12:00:00Z","id":"44444444-4444-4444-8444-444444444444","sender_id":"11111111-1111-4111-8111-111111111111","text":"Привет, Боб!"}],"next_cursor":null}
|
|
type MessagePage struct {
|
|
Items []Message `json:"items"`
|
|
NextCursor *string `json:"next_cursor"`
|
|
}
|
|
|
|
// Session defines model for Session.
|
|
type Session struct {
|
|
ExpiresAt Timestamp `json:"expires_at"`
|
|
Token string `json:"token"`
|
|
TokenType SessionTokenType `json:"token_type"`
|
|
|
|
// User Examples: {"created_at":"2026-09-01T12:00:00Z","display_name":"Алиса","id":"11111111-1111-4111-8111-111111111111","username":"alice"}
|
|
User User `json:"user"`
|
|
}
|
|
|
|
// SessionTokenType defines model for Session.TokenType.
|
|
type SessionTokenType string
|
|
|
|
// User Examples: {"created_at":"2026-09-01T12:00:00Z","display_name":"Алиса","id":"11111111-1111-4111-8111-111111111111","username":"alice"}
|
|
type User struct {
|
|
CreatedAt Timestamp `json:"created_at"`
|
|
DisplayName string `json:"display_name"`
|
|
Id openapi_types.UUID `json:"id"`
|
|
Username string `json:"username"`
|
|
}
|
|
|
|
// ListChatsParams defines parameters for ListChats.
|
|
type ListChatsParams struct {
|
|
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
|
|
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
|
|
}
|
|
|
|
// ListMessagesParams defines parameters for ListMessages.
|
|
type ListMessagesParams struct {
|
|
Limit *int `form:"limit,omitempty" json:"limit,omitempty"`
|
|
Cursor *string `form:"cursor,omitempty" json:"cursor,omitempty"`
|
|
}
|
|
|
|
// CreateChatJSONRequestBody defines body for CreateChat for application/json ContentType.
|
|
type CreateChatJSONRequestBody = CreateChat
|
|
|
|
// CreateMessageJSONRequestBody defines body for CreateMessage for application/json ContentType.
|
|
type CreateMessageJSONRequestBody = CreateMessage
|
|
|
|
// RegisterUserJSONRequestBody defines body for RegisterUser for application/json ContentType.
|
|
type RegisterUserJSONRequestBody = CreateUser
|
|
|
|
// ServerInterface represents all server handlers.
|
|
type ServerInterface interface {
|
|
// CreateSession Вход: Basic username:password; выдаёт сессию
|
|
// (POST /api/v1/auth/sessions)
|
|
CreateSession(w http.ResponseWriter, r *http.Request)
|
|
// RevokeSession Отозвать текущую сессию
|
|
// (DELETE /api/v1/auth/sessions/current)
|
|
RevokeSession(w http.ResponseWriter, r *http.Request)
|
|
// ListChats Чаты текущего пользователя
|
|
// (GET /api/v1/chats)
|
|
ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams)
|
|
// CreateChat Создать чат; вызывающий должен входить в member_ids
|
|
// (POST /api/v1/chats)
|
|
CreateChat(w http.ResponseWriter, r *http.Request)
|
|
// GetChat Получить доступный чат
|
|
// (GET /api/v1/chats/{chat_id})
|
|
GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID)
|
|
// ListMessages Сообщения по (created_at, id) по возрастанию
|
|
// (GET /api/v1/chats/{chat_id}/messages)
|
|
ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams)
|
|
// CreateMessage Отправить сообщение
|
|
// (POST /api/v1/chats/{chat_id}/messages)
|
|
CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID)
|
|
// RegisterUser Создать пользователя
|
|
// (POST /api/v1/users)
|
|
RegisterUser(w http.ResponseWriter, r *http.Request)
|
|
// CurrentUser Текущий пользователь
|
|
// (GET /api/v1/users/me)
|
|
CurrentUser(w http.ResponseWriter, r *http.Request)
|
|
// Liveness Процесс жив
|
|
// (GET /health/live)
|
|
Liveness(w http.ResponseWriter, r *http.Request)
|
|
// Readiness Готов принимать трафик
|
|
// (GET /health/ready)
|
|
Readiness(w http.ResponseWriter, r *http.Request)
|
|
}
|
|
|
|
// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.
|
|
|
|
type Unimplemented struct{}
|
|
|
|
// CreateSession Вход: Basic username:password; выдаёт сессию
|
|
// (POST /api/v1/auth/sessions)
|
|
func (_ Unimplemented) CreateSession(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// RevokeSession Отозвать текущую сессию
|
|
// (DELETE /api/v1/auth/sessions/current)
|
|
func (_ Unimplemented) RevokeSession(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// ListChats Чаты текущего пользователя
|
|
// (GET /api/v1/chats)
|
|
func (_ Unimplemented) ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// CreateChat Создать чат; вызывающий должен входить в member_ids
|
|
// (POST /api/v1/chats)
|
|
func (_ Unimplemented) CreateChat(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// GetChat Получить доступный чат
|
|
// (GET /api/v1/chats/{chat_id})
|
|
func (_ Unimplemented) GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// ListMessages Сообщения по (created_at, id) по возрастанию
|
|
// (GET /api/v1/chats/{chat_id}/messages)
|
|
func (_ Unimplemented) ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// CreateMessage Отправить сообщение
|
|
// (POST /api/v1/chats/{chat_id}/messages)
|
|
func (_ Unimplemented) CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// RegisterUser Создать пользователя
|
|
// (POST /api/v1/users)
|
|
func (_ Unimplemented) RegisterUser(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// CurrentUser Текущий пользователь
|
|
// (GET /api/v1/users/me)
|
|
func (_ Unimplemented) CurrentUser(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Liveness Процесс жив
|
|
// (GET /health/live)
|
|
func (_ Unimplemented) Liveness(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusNotImplemented)
|
|
}
|
|
|
|
// Readiness Готов принимать трафик
|
|
// (GET /health/ready)
|
|
func (_ Unimplemented) Readiness(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
|
|
|
|
// CreateSession operation middleware
|
|
func (siw *ServerInterfaceWrapper) CreateSession(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CreateSession(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// RevokeSession operation middleware
|
|
func (siw *ServerInterfaceWrapper) RevokeSession(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.RevokeSession(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// ListChats operation middleware
|
|
func (siw *ServerInterfaceWrapper) ListChats(w http.ResponseWriter, r *http.Request) {
|
|
|
|
var err error
|
|
_ = err
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params ListChatsParams
|
|
|
|
// ------------- Optional query parameter "limit" -------------
|
|
|
|
err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", r.URL.Query(), ¶ms.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
|
|
if err != nil {
|
|
var requiredError *runtime.RequiredParameterError
|
|
if errors.As(err, &requiredError) {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "limit"})
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
|
|
}
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "cursor" -------------
|
|
|
|
err = runtime.BindQueryParameterWithOptions("form", true, false, "cursor", r.URL.Query(), ¶ms.Cursor, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
|
|
if err != nil {
|
|
var requiredError *runtime.RequiredParameterError
|
|
if errors.As(err, &requiredError) {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "cursor"})
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "cursor", Err: err})
|
|
}
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.ListChats(w, r, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// CreateChat operation middleware
|
|
func (siw *ServerInterfaceWrapper) CreateChat(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CreateChat(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// GetChat operation middleware
|
|
func (siw *ServerInterfaceWrapper) GetChat(w http.ResponseWriter, r *http.Request) {
|
|
|
|
var err error
|
|
_ = err
|
|
|
|
// ------------- Path parameter "chat_id" -------------
|
|
var chatId openapi_types.UUID
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.GetChat(w, r, chatId)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// ListMessages operation middleware
|
|
func (siw *ServerInterfaceWrapper) ListMessages(w http.ResponseWriter, r *http.Request) {
|
|
|
|
var err error
|
|
_ = err
|
|
|
|
// ------------- Path parameter "chat_id" -------------
|
|
var chatId openapi_types.UUID
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
|
|
return
|
|
}
|
|
|
|
// Parameter object where we will unmarshal all parameters from the context
|
|
var params ListMessagesParams
|
|
|
|
// ------------- Optional query parameter "limit" -------------
|
|
|
|
err = runtime.BindQueryParameterWithOptions("form", true, false, "limit", r.URL.Query(), ¶ms.Limit, runtime.BindQueryParameterOptions{Type: "integer", Format: ""})
|
|
if err != nil {
|
|
var requiredError *runtime.RequiredParameterError
|
|
if errors.As(err, &requiredError) {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "limit"})
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "limit", Err: err})
|
|
}
|
|
return
|
|
}
|
|
|
|
// ------------- Optional query parameter "cursor" -------------
|
|
|
|
err = runtime.BindQueryParameterWithOptions("form", true, false, "cursor", r.URL.Query(), ¶ms.Cursor, runtime.BindQueryParameterOptions{Type: "string", Format: ""})
|
|
if err != nil {
|
|
var requiredError *runtime.RequiredParameterError
|
|
if errors.As(err, &requiredError) {
|
|
siw.ErrorHandlerFunc(w, r, &RequiredParamError{ParamName: "cursor"})
|
|
} else {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "cursor", Err: err})
|
|
}
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.ListMessages(w, r, chatId, params)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// CreateMessage operation middleware
|
|
func (siw *ServerInterfaceWrapper) CreateMessage(w http.ResponseWriter, r *http.Request) {
|
|
|
|
var err error
|
|
_ = err
|
|
|
|
// ------------- Path parameter "chat_id" -------------
|
|
var chatId openapi_types.UUID
|
|
|
|
err = runtime.BindStyledParameterWithOptions("simple", "chat_id", chi.URLParam(r, "chat_id"), &chatId, runtime.BindStyledParameterOptions{ParamLocation: runtime.ParamLocationPath, Explode: false, Required: true, Type: "string", Format: "uuid", ValueIsUnescaped: r.URL.RawPath == ""})
|
|
if err != nil {
|
|
siw.ErrorHandlerFunc(w, r, &InvalidParamFormatError{ParamName: "chat_id", Err: err})
|
|
return
|
|
}
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CreateMessage(w, r, chatId)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// RegisterUser operation middleware
|
|
func (siw *ServerInterfaceWrapper) RegisterUser(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.RegisterUser(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// CurrentUser operation middleware
|
|
func (siw *ServerInterfaceWrapper) CurrentUser(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.CurrentUser(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// Liveness operation middleware
|
|
func (siw *ServerInterfaceWrapper) Liveness(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.Liveness(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
// Readiness operation middleware
|
|
func (siw *ServerInterfaceWrapper) Readiness(w http.ResponseWriter, r *http.Request) {
|
|
|
|
handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
siw.Handler.Readiness(w, r)
|
|
}))
|
|
|
|
for _, middleware := range siw.HandlerMiddlewares {
|
|
handler = middleware(handler)
|
|
}
|
|
|
|
handler.ServeHTTP(w, r)
|
|
}
|
|
|
|
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.Post(options.BaseURL+"/api/v1/auth/sessions", wrapper.CreateSession)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Delete(options.BaseURL+"/api/v1/auth/sessions/current", wrapper.RevokeSession)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/api/v1/chats", wrapper.ListChats)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/api/v1/chats", wrapper.CreateChat)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/api/v1/chats/{chat_id}", wrapper.GetChat)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/api/v1/chats/{chat_id}/messages", wrapper.ListMessages)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/api/v1/chats/{chat_id}/messages", wrapper.CreateMessage)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Post(options.BaseURL+"/api/v1/users", wrapper.RegisterUser)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/api/v1/users/me", wrapper.CurrentUser)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/health/live", wrapper.Liveness)
|
|
})
|
|
r.Group(func(r chi.Router) {
|
|
r.Get(options.BaseURL+"/health/ready", wrapper.Readiness)
|
|
})
|
|
|
|
return r
|
|
}
|
|
|
|
type CreateSessionRequestObject struct {
|
|
}
|
|
|
|
type CreateSessionResponseObject interface {
|
|
VisitCreateSessionResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CreateSession201ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession201JSONResponse struct {
|
|
Body Session
|
|
Headers CreateSession201ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession201JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(201)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateSession400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession400JSONResponse struct {
|
|
Body Error
|
|
Headers CreateSession400ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession400JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateSession401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession401JSONResponse struct {
|
|
Body Error
|
|
Headers CreateSession401ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession401JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateSession429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession429JSONResponse struct {
|
|
Body Error
|
|
Headers CreateSession429ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession429JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateSession500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession500JSONResponse struct {
|
|
Body Error
|
|
Headers CreateSession500ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession500JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateSession503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateSession503JSONResponse struct {
|
|
Body Error
|
|
Headers CreateSession503ResponseHeaders
|
|
}
|
|
|
|
func (response CreateSession503JSONResponse) VisitCreateSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RevokeSessionRequestObject struct {
|
|
}
|
|
|
|
type RevokeSessionResponseObject interface {
|
|
VisitRevokeSessionResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type RevokeSession204ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RevokeSession204Response struct {
|
|
Headers RevokeSession204ResponseHeaders
|
|
}
|
|
|
|
func (response RevokeSession204Response) VisitRevokeSessionResponse(w http.ResponseWriter) error {
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(204)
|
|
return nil
|
|
}
|
|
|
|
type RevokeSession401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type RevokeSession401JSONResponse struct {
|
|
Body Error
|
|
Headers RevokeSession401ResponseHeaders
|
|
}
|
|
|
|
func (response RevokeSession401JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RevokeSession429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type RevokeSession429JSONResponse struct {
|
|
Body Error
|
|
Headers RevokeSession429ResponseHeaders
|
|
}
|
|
|
|
func (response RevokeSession429JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RevokeSession500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RevokeSession500JSONResponse struct {
|
|
Body Error
|
|
Headers RevokeSession500ResponseHeaders
|
|
}
|
|
|
|
func (response RevokeSession500JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RevokeSession503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RevokeSession503JSONResponse struct {
|
|
Body Error
|
|
Headers RevokeSession503ResponseHeaders
|
|
}
|
|
|
|
func (response RevokeSession503JSONResponse) VisitRevokeSessionResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChatsRequestObject struct {
|
|
Params ListChatsParams
|
|
}
|
|
|
|
type ListChatsResponseObject interface {
|
|
VisitListChatsResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ListChats200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats200JSONResponse struct {
|
|
Body ChatPage
|
|
Headers ListChats200ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats200JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats400JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats400ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats400JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats401JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats401ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats401JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats404JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats404ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats404JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats409JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats409ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats409JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats429JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats429ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats429JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats500JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats500ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats500JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListChats503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListChats503JSONResponse struct {
|
|
Body Error
|
|
Headers ListChats503ResponseHeaders
|
|
}
|
|
|
|
func (response ListChats503JSONResponse) VisitListChatsResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChatRequestObject struct {
|
|
Body *CreateChatJSONRequestBody
|
|
}
|
|
|
|
type CreateChatResponseObject interface {
|
|
VisitCreateChatResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CreateChat201ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat201JSONResponse struct {
|
|
Body Chat
|
|
Headers CreateChat201ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat201JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(201)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat400JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat400ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat400JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat401JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat401ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat401JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat404JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat404ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat404JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat409JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat409ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat409JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat429JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat429ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat429JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat500JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat500ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat500JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateChat503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateChat503JSONResponse struct {
|
|
Body Error
|
|
Headers CreateChat503ResponseHeaders
|
|
}
|
|
|
|
func (response CreateChat503JSONResponse) VisitCreateChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChatRequestObject struct {
|
|
ChatId openapi_types.UUID `json:"chat_id"`
|
|
}
|
|
|
|
type GetChatResponseObject interface {
|
|
VisitGetChatResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type GetChat200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat200JSONResponse struct {
|
|
Body Chat
|
|
Headers GetChat200ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat200JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat400JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat400ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat400JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat401JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat401ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat401JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat404JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat404ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat404JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat409JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat409ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat409JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat429JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat429ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat429JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat500JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat500ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat500JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type GetChat503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type GetChat503JSONResponse struct {
|
|
Body Error
|
|
Headers GetChat503ResponseHeaders
|
|
}
|
|
|
|
func (response GetChat503JSONResponse) VisitGetChatResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessagesRequestObject struct {
|
|
ChatId openapi_types.UUID `json:"chat_id"`
|
|
Params ListMessagesParams
|
|
}
|
|
|
|
type ListMessagesResponseObject interface {
|
|
VisitListMessagesResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type ListMessages200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages200JSONResponse struct {
|
|
Body MessagePage
|
|
Headers ListMessages200ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages200JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages400JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages400ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages400JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages401JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages401ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages401JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages404JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages404ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages404JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages409JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages409ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages409JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages429JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages429ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages429JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages500JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages500ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages500JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ListMessages503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type ListMessages503JSONResponse struct {
|
|
Body Error
|
|
Headers ListMessages503ResponseHeaders
|
|
}
|
|
|
|
func (response ListMessages503JSONResponse) VisitListMessagesResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessageRequestObject struct {
|
|
ChatId openapi_types.UUID `json:"chat_id"`
|
|
Body *CreateMessageJSONRequestBody
|
|
}
|
|
|
|
type CreateMessageResponseObject interface {
|
|
VisitCreateMessageResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CreateMessage201ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage201JSONResponse struct {
|
|
Body Message
|
|
Headers CreateMessage201ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage201JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(201)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage400JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage400ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage400JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage401JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage401ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage401JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage404JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage404ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage404JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage409JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage409ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage409JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage429JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage429ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage429JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage500JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage500ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage500JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CreateMessage503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CreateMessage503JSONResponse struct {
|
|
Body Error
|
|
Headers CreateMessage503ResponseHeaders
|
|
}
|
|
|
|
func (response CreateMessage503JSONResponse) VisitCreateMessageResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUserRequestObject struct {
|
|
Body *RegisterUserJSONRequestBody
|
|
}
|
|
|
|
type RegisterUserResponseObject interface {
|
|
VisitRegisterUserResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type RegisterUser201ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser201JSONResponse struct {
|
|
Body User
|
|
Headers RegisterUser201ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser201JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(201)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUser400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser400JSONResponse struct {
|
|
Body Error
|
|
Headers RegisterUser400ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser400JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUser409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser409JSONResponse struct {
|
|
Body Error
|
|
Headers RegisterUser409ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser409JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUser429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser429JSONResponse struct {
|
|
Body Error
|
|
Headers RegisterUser429ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser429JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUser500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser500JSONResponse struct {
|
|
Body Error
|
|
Headers RegisterUser500ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser500JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type RegisterUser503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type RegisterUser503JSONResponse struct {
|
|
Body Error
|
|
Headers RegisterUser503ResponseHeaders
|
|
}
|
|
|
|
func (response RegisterUser503JSONResponse) VisitRegisterUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUserRequestObject struct {
|
|
}
|
|
|
|
type CurrentUserResponseObject interface {
|
|
VisitCurrentUserResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type CurrentUser200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser200JSONResponse struct {
|
|
Body User
|
|
Headers CurrentUser200ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser200JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser400ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser400JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser400ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser400JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(400)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser401ResponseHeaders struct {
|
|
WWWAuthenticate *string
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser401JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser401ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser401JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.WWWAuthenticate != nil {
|
|
w.Header().Set("WWW-Authenticate", fmt.Sprint(*response.Headers.WWWAuthenticate))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(401)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser404ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser404JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser404ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser404JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(404)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser409ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser409JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser409ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser409JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(409)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser429ResponseHeaders struct {
|
|
RetryAfter *int
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser429JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser429ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser429JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.RetryAfter != nil {
|
|
w.Header().Set("Retry-After", fmt.Sprint(*response.Headers.RetryAfter))
|
|
}
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(429)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser500JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser500ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser500JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type CurrentUser503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type CurrentUser503JSONResponse struct {
|
|
Body Error
|
|
Headers CurrentUser503ResponseHeaders
|
|
}
|
|
|
|
func (response CurrentUser503JSONResponse) VisitCurrentUserResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type LivenessRequestObject struct {
|
|
}
|
|
|
|
type LivenessResponseObject interface {
|
|
VisitLivenessResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type Liveness200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type Liveness200JSONResponse struct {
|
|
Body Health
|
|
Headers Liveness200ResponseHeaders
|
|
}
|
|
|
|
func (response Liveness200JSONResponse) VisitLivenessResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type Liveness500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type Liveness500JSONResponse struct {
|
|
Body Error
|
|
Headers Liveness500ResponseHeaders
|
|
}
|
|
|
|
func (response Liveness500JSONResponse) VisitLivenessResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type ReadinessRequestObject struct {
|
|
}
|
|
|
|
type ReadinessResponseObject interface {
|
|
VisitReadinessResponse(w http.ResponseWriter) error
|
|
}
|
|
|
|
type Readiness200ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type Readiness200JSONResponse struct {
|
|
Body Health
|
|
Headers Readiness200ResponseHeaders
|
|
}
|
|
|
|
func (response Readiness200JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(200)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type Readiness500ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type Readiness500JSONResponse struct {
|
|
Body Error
|
|
Headers Readiness500ResponseHeaders
|
|
}
|
|
|
|
func (response Readiness500JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(500)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
type Readiness503ResponseHeaders struct {
|
|
XRequestId *string
|
|
}
|
|
|
|
type Readiness503JSONResponse struct {
|
|
Body Error
|
|
Headers Readiness503ResponseHeaders
|
|
}
|
|
|
|
func (response Readiness503JSONResponse) VisitReadinessResponse(w http.ResponseWriter) error {
|
|
|
|
var buf bytes.Buffer
|
|
if err := json.NewEncoder(&buf).Encode(response.Body); err != nil {
|
|
return err
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
if response.Headers.XRequestId != nil {
|
|
w.Header().Set("X-Request-Id", fmt.Sprint(*response.Headers.XRequestId))
|
|
}
|
|
w.WriteHeader(503)
|
|
_, err := buf.WriteTo(w)
|
|
return err
|
|
}
|
|
|
|
// StrictServerInterface represents all server handlers.
|
|
type StrictServerInterface interface {
|
|
// CreateSession Вход: Basic username:password; выдаёт сессию
|
|
// (POST /api/v1/auth/sessions)
|
|
CreateSession(ctx context.Context, request CreateSessionRequestObject) (CreateSessionResponseObject, error)
|
|
// RevokeSession Отозвать текущую сессию
|
|
// (DELETE /api/v1/auth/sessions/current)
|
|
RevokeSession(ctx context.Context, request RevokeSessionRequestObject) (RevokeSessionResponseObject, error)
|
|
// ListChats Чаты текущего пользователя
|
|
// (GET /api/v1/chats)
|
|
ListChats(ctx context.Context, request ListChatsRequestObject) (ListChatsResponseObject, error)
|
|
// CreateChat Создать чат; вызывающий должен входить в member_ids
|
|
// (POST /api/v1/chats)
|
|
CreateChat(ctx context.Context, request CreateChatRequestObject) (CreateChatResponseObject, error)
|
|
// GetChat Получить доступный чат
|
|
// (GET /api/v1/chats/{chat_id})
|
|
GetChat(ctx context.Context, request GetChatRequestObject) (GetChatResponseObject, error)
|
|
// ListMessages Сообщения по (created_at, id) по возрастанию
|
|
// (GET /api/v1/chats/{chat_id}/messages)
|
|
ListMessages(ctx context.Context, request ListMessagesRequestObject) (ListMessagesResponseObject, error)
|
|
// CreateMessage Отправить сообщение
|
|
// (POST /api/v1/chats/{chat_id}/messages)
|
|
CreateMessage(ctx context.Context, request CreateMessageRequestObject) (CreateMessageResponseObject, error)
|
|
// RegisterUser Создать пользователя
|
|
// (POST /api/v1/users)
|
|
RegisterUser(ctx context.Context, request RegisterUserRequestObject) (RegisterUserResponseObject, error)
|
|
// CurrentUser Текущий пользователь
|
|
// (GET /api/v1/users/me)
|
|
CurrentUser(ctx context.Context, request CurrentUserRequestObject) (CurrentUserResponseObject, error)
|
|
// Liveness Процесс жив
|
|
// (GET /health/live)
|
|
Liveness(ctx context.Context, request LivenessRequestObject) (LivenessResponseObject, error)
|
|
// Readiness Готов принимать трафик
|
|
// (GET /health/ready)
|
|
Readiness(ctx context.Context, request ReadinessRequestObject) (ReadinessResponseObject, error)
|
|
}
|
|
|
|
type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, 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 {
|
|
if options.RequestErrorHandlerFunc == nil {
|
|
options.RequestErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
}
|
|
}
|
|
if options.ResponseErrorHandlerFunc == nil {
|
|
options.ResponseErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
|
|
}
|
|
|
|
type strictHandler struct {
|
|
ssi StrictServerInterface
|
|
middlewares []StrictMiddlewareFunc
|
|
options StrictHTTPServerOptions
|
|
}
|
|
|
|
// CreateSession operation middleware
|
|
func (sh *strictHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
|
|
var request CreateSessionRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.CreateSession(ctx, request.(CreateSessionRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CreateSession")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CreateSessionResponseObject); ok {
|
|
if err := validResponse.VisitCreateSessionResponse(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))
|
|
}
|
|
}
|
|
|
|
// RevokeSession operation middleware
|
|
func (sh *strictHandler) RevokeSession(w http.ResponseWriter, r *http.Request) {
|
|
var request RevokeSessionRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.RevokeSession(ctx, request.(RevokeSessionRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "RevokeSession")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(RevokeSessionResponseObject); ok {
|
|
if err := validResponse.VisitRevokeSessionResponse(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))
|
|
}
|
|
}
|
|
|
|
// ListChats operation middleware
|
|
func (sh *strictHandler) ListChats(w http.ResponseWriter, r *http.Request, params ListChatsParams) {
|
|
var request ListChatsRequestObject
|
|
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ListChats(ctx, request.(ListChatsRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ListChats")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ListChatsResponseObject); ok {
|
|
if err := validResponse.VisitListChatsResponse(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))
|
|
}
|
|
}
|
|
|
|
// CreateChat operation middleware
|
|
func (sh *strictHandler) CreateChat(w http.ResponseWriter, r *http.Request) {
|
|
var request CreateChatRequestObject
|
|
|
|
var body CreateChatJSONRequestBody
|
|
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.CreateChat(ctx, request.(CreateChatRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CreateChat")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CreateChatResponseObject); ok {
|
|
if err := validResponse.VisitCreateChatResponse(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))
|
|
}
|
|
}
|
|
|
|
// GetChat operation middleware
|
|
func (sh *strictHandler) GetChat(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
|
|
var request GetChatRequestObject
|
|
|
|
request.ChatId = chatId
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.GetChat(ctx, request.(GetChatRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "GetChat")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(GetChatResponseObject); ok {
|
|
if err := validResponse.VisitGetChatResponse(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))
|
|
}
|
|
}
|
|
|
|
// ListMessages operation middleware
|
|
func (sh *strictHandler) ListMessages(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID, params ListMessagesParams) {
|
|
var request ListMessagesRequestObject
|
|
|
|
request.ChatId = chatId
|
|
request.Params = params
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.ListMessages(ctx, request.(ListMessagesRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "ListMessages")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ListMessagesResponseObject); ok {
|
|
if err := validResponse.VisitListMessagesResponse(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))
|
|
}
|
|
}
|
|
|
|
// CreateMessage operation middleware
|
|
func (sh *strictHandler) CreateMessage(w http.ResponseWriter, r *http.Request, chatId openapi_types.UUID) {
|
|
var request CreateMessageRequestObject
|
|
|
|
request.ChatId = chatId
|
|
|
|
var body CreateMessageJSONRequestBody
|
|
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.CreateMessage(ctx, request.(CreateMessageRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CreateMessage")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CreateMessageResponseObject); ok {
|
|
if err := validResponse.VisitCreateMessageResponse(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))
|
|
}
|
|
}
|
|
|
|
// RegisterUser operation middleware
|
|
func (sh *strictHandler) RegisterUser(w http.ResponseWriter, r *http.Request) {
|
|
var request RegisterUserRequestObject
|
|
|
|
var body RegisterUserJSONRequestBody
|
|
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.RegisterUser(ctx, request.(RegisterUserRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "RegisterUser")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(RegisterUserResponseObject); ok {
|
|
if err := validResponse.VisitRegisterUserResponse(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))
|
|
}
|
|
}
|
|
|
|
// CurrentUser operation middleware
|
|
func (sh *strictHandler) CurrentUser(w http.ResponseWriter, r *http.Request) {
|
|
var request CurrentUserRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.CurrentUser(ctx, request.(CurrentUserRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "CurrentUser")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(CurrentUserResponseObject); ok {
|
|
if err := validResponse.VisitCurrentUserResponse(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))
|
|
}
|
|
}
|
|
|
|
// Liveness operation middleware
|
|
func (sh *strictHandler) Liveness(w http.ResponseWriter, r *http.Request) {
|
|
var request LivenessRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.Liveness(ctx, request.(LivenessRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "Liveness")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(LivenessResponseObject); ok {
|
|
if err := validResponse.VisitLivenessResponse(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))
|
|
}
|
|
}
|
|
|
|
// Readiness operation middleware
|
|
func (sh *strictHandler) Readiness(w http.ResponseWriter, r *http.Request) {
|
|
var request ReadinessRequestObject
|
|
|
|
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
|
|
return sh.ssi.Readiness(ctx, request.(ReadinessRequestObject))
|
|
}
|
|
for _, middleware := range sh.middlewares {
|
|
handler = middleware(handler, "Readiness")
|
|
}
|
|
|
|
response, err := handler(r.Context(), w, r, request)
|
|
|
|
if err != nil {
|
|
sh.options.ResponseErrorHandlerFunc(w, r, err)
|
|
} else if validResponse, ok := response.(ReadinessResponseObject); ok {
|
|
if err := validResponse.VisitReadinessResponse(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))
|
|
}
|
|
}
|