webfmwk

type Address struct {
	Addr string     `json:"addr"`
	TLS  *TLSConfig `json:"tls,omitempty" mapstructure:"tls,omitempty"`
	Name string     `json:"name"`
}

type Context interface {
	SendResponse
	InputHandling
	ContextLogger

	// GetRequest return the holded http.Request object
	GetRequest() *http.Request

	// GetVar return the url var parameters. Empty string for none
	GetVar(key string) (val string)

	// GetQueries return the queries object
	GetQueries() map[string][]string

	// GetQuery fetch the query object key
	GetQuery(key string) (val string, ok bool)

	// GetContext fetch the previously saved context object
	GetContext() context.Context
}

type ContextLogger interface {
	// SetLogger set the logger of the ctx
	SetLogger(logger log.Log) Context

	// GetLogger return the logger of the ctx
	GetLogger() log.Log
}

type DocHandler struct {
	// H represent the doc handler to expose
	H http.HandlerFunc
	// Name is used in debug message
	Name string
	// Path hold the URI at  which the handler is exposed.
	// If one used, will be prefixed by the api base.
	Path string
}

type Error struct {
	// Status hold the error code status
	//
	// Example: 500
	Status int `json:"status" validate:"required"`

	// Message hold the error message
	//
	// Example: the impossible appened
	Message string `json:"message" example:"no such resource" validate:"required"`
	// contains filtered or unexported fields
}

type ErrorHandled interface {
	// error
	Error() string
	Unwrap() error
	GetOPCode() int
	SetStatusCode(op int) ErrorHandled
	GetContent() interface{}
	SetWrapped(err error) ErrorHandled
}

type Handler func(HandlerFunc) HandlerFunc

type HandlerFunc func(c Context) error

type Header [2]string

type IAddress interface {
	GetAddr() string
	GetTLS() *TLSConfig
	GetName() string
	IsOk() bool
}

type ITLSConfig interface {
	fmt.Stringer

	// GetCert return the full path to the server certificate file
	GetCert() string
	// GetKey return the full path to the server key file
	GetKey() string
	// GetCa return the full path to the server ca cert file
	GetCa() string

	// GetInsecure return true if the TLS Certificate shouldn't be checked
	GetInsecure() bool

	// IsEmpty return true if the config is empty
	Empty() bool
}

type InputHandling interface {
	// FetchContent extract the content from the body
	FetchContent(content interface{}) ErrorHandled

	// Validate is used to validate a content of the content params
	Validate(content interface{}) ErrorHandled

	// FetchAndValidateContent fetch the content then validate it
	FetchAndValidateContent(content interface{}) ErrorHandled

	// Decode load the query param in the content object
	DecodeQP(content interface{}) ErrorHandled
}

type JSONResponse interface {
	// JSONBlob answer the JSON content with the status code op
	JSONBlob(op int, content []byte) error

	// JSON answer the JSON content with the status code op
	JSON(op int, content interface{}) error

	// JSONOk return the interface with an http.StatusOK (200)
	JSONOk(content interface{}) error

	// JSONCreated return the interface with an http.StatusCreated (201)
	JSONCreated(content interface{}) error

	// JSONAccepted return the interface with an http.StatusAccepted (202)
	JSONAccepted(content interface{}) error

	// JSONNoContent return an empty payload an http.StatusNoContent (204)
	JSONNoContent() error

	// JSONBadRequest return the interface with an http.StatusBadRequest (400)
	JSONBadRequest(content interface{}) error

	// JSONUnauthorized return the interface with an http.StatusUnauthorized (401)
	JSONUnauthorized(content interface{}) error

	// JSONForbiden return the interface with an http.StatusForbidden (403)
	JSONForbiden(content interface{}) error

	// JSONNoContent return the interface with an http.StatusNotFound (404)
	JSONNotFound(content interface{}) error

	// JSONConflict return the interface with an http.StatusConflict (409)
	JSONConflict(content interface{}) error

	// JSONUnauthorized return the interface with an http.StatusUnprocessableEntity (422)
	JSONUnprocessable(content interface{}) error

	// JSONInternalError return the interface with an http.StatusInternalServerError (500)
	JSONInternalError(content interface{}) error

	// JSONNotImplemented return the interface with an http.StatusNotImplemented (501)
	JSONNotImplemented(content interface{}) error
}

type Option func(s *Server)

type Options []Option

type Response struct {
	// Status hold the error code status
	//
	// Example: 200
	Status int `json:"status" example:"204" validate:"required"`

	// Message hold the error message
	//
	// Example: action successfully completed
	Message string `json:"content,omitempty"`
}

type Route struct {
	Verbe   string      `json:"verbe"`
	Path    string      `json:"path"`
	Name    string      `json:"name"`
	Handler HandlerFunc `json:"-"`
}

type Routes []Route

type RoutesPerPrefix map[string]Routes

type SendResponse interface {
	JSONResponse
	XMLResponse

	// SendResponse create & send a response according to the parameters
	SendResponse(op int, content []byte, headers ...Header) error

	// SetHeader set the header of the http response
	SetHeaders(headers ...Header)

	SetHeader(k, v string)

	// IsPretty toggle the compact output mode
	IsPretty() bool
}

type Server struct {
	// contains filtered or unexported fields
}

type TLSConfig struct {
	Cert     string `json:"cert" mapstructur:"cert"`
	Key      string `json:"key" mapstructur:"key"`
	Ca       string `json:"ca" mapstructur:"ca"`
	Insecure bool   `json:"insecure" mapstructur:"insecure"`
}

type ValidationError struct {
	Status int                                    `json:"status"`
	Error  validator.ValidationErrorsTranslations `json:"message"`
}

type WorkerLauncher struct {
	// contains filtered or unexported fields
}

type XMLResponse interface {
	// JSONBlob answer the JSON content with the status code op
	XMLBlob(op int, content []byte) error
}