api_server

type AuthParameterGetter = func(r *Request, key string) string

type AuthParameterSetter = func(r *Request, key string, value string)

type CheckAccess struct{}

type CheckAccessEndpoint struct {
	EndpointBase
	CheckAccess
}

type CheckAccessResourceEndpoint struct {
	ResourceEndpoint
	CheckAccess
}

type CheckStatusEndpoint struct {
	ResourceEndpoint
}

type DynamicFieldTranslator interface {
	Tr(field *DynamicTableField, tableName ...string) (string, bool)
}

type DynamicTable struct {
	api.ResponseStub
	Columns              []*DynamicTableField `json:"columns"`
	DefaultSortColumn    string               `json:"default_sort_column"`
	DefaultSortDirection string               `json:"default_sort_direction"`
}

type DynamicTableConfig struct {
	Operation            api.Operation
	Model                interface{}
	Displays             map[string]string
	ColumnsOrder         []string
	DefaultSortField     string
	DefaultSortDirection string
	EnumGetters          map[string]EnumGetter
	Enums                FieldEnums
	VisibleColumns       []string
}

type DynamicTableEndpoint struct {
	ResourceEndpoint
	// contains filtered or unexported fields
}

type DynamicTableField struct {
	Field      string       `json:"field"`
	Type       string       `json:"type"`
	Index      bool         `json:"index"`
	Display    string       `json:"display"`
	Enum       []*EnumEntry `json:"enum,omitempty"`
	Visible    bool         `json:"visible"`
	Money      bool         `json:"money"`
	EnumGetter EnumGetter   `json:"-"`
}

type DynamicTableQuery struct {
	Path string `json:"path" validate:"required" vmessage:"Invalid table path."`
}

type DynamicTables interface {
	AddTable(table *DynamicTableConfig) error
	Table(request Request, path string) (*DynamicTable, error)
	SetTranslator(translator DynamicFieldTranslator)
}

type DynamicTablesService struct {
	ServiceBase
}

type EchoEndpoint struct {
	EndpointBase
}

type Endpoint interface {
	api.Operation
	generic_error.ErrorsExtender
	MessageHandlers

	SetMessageHandlers(handlers MessageHandlers)

	NewRequestMessage() interface{}

	// Handle request to server API.
	HandleRequest(request Request) error

	// Precheck request before some authorization methods
	PrecheckBeforeAuth(request Request, smsMessage *string, skipSms *bool) error

	IsRequestPayloadNeeded() bool

	SetRequestPreprocessor(handler EndpointHandler)
	GetRequestPreprocessor() EndpointHandler
	PreprocessBeforeAuth(request Request) error

	SetRequestPostprocessor(handler EndpointHandler)
	GetRequestPostprocessor() EndpointHandler
	Postprocess(request Request) error
}

type EndpointBase struct {
	api.Operation
	generic_error.ErrorsExtenderBase
	MessageHandlers
	// contains filtered or unexported fields
}

type EndpointHandler = func(request Request) error

type EndpointNoHandler struct{}

type EnumEntry struct {
	Value   string `json:"value"`
	Display string `json:"display"`
}

type EnumGetter func(request Request) ([]*EnumEntry, error)

type FieldEnums = map[string][]*EnumEntry

type File struct {
	Content     []byte
	ContentType string
	Name        string
}

type MessageBuilder func() interface{}

type MessageContent interface {
	BinaryContent() []byte
	SetBinaryContent([]byte)
	SetLogicMessage(interface{})
	LogicMessage() interface{}
	SetTransportMessage(interface{})
	TransportMessage() interface{}
}

type MessageConverter func(msg MessageContent) error

type MessageHandlers interface {
	NewTransportRequest(ep Endpoint) interface{}
	TransportRequestToLogic(msg MessageContent) error
	LogicResponseToTransport(msg MessageContent) error
}

type MessageHandlersConfig struct {
	RequestFromTransport    MessageConverter
	ResponseToTransport     MessageConverter
	TransportRequestBuilder MessageBuilder
}

type Request interface {
	auth.AuthContext
	common.WithParameters

	Server() Server
	Response() Response
	Endpoint() Endpoint

	ParseAndValidate(cmd interface{}) error
	FormData() map[string][]string
	FormFile() (*multipart.FileHeader, error)

	SetMessage(msg RequestMessage)
	Message() RequestMessage
}

type RequestBase struct {
	auth.TenancyUserContext
	auth.SessionBase
	// contains filtered or unexported fields
}

type RequestMessage interface {
	MessageContent
}

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

type ResourceEndpoint struct {
	api.ResourceBase
	EndpointBase
}

type ResourceEndpointI interface {
	api.Resource
	Endpoint
	// contains filtered or unexported methods
}

type Response interface {
	Message() interface{}
	SetMessage(message api.Response)
	SetStatusMessage(status string)
	SetSuccessStatusMessage()
	Request() Request
	SetRequest(request Request)

	Payload() []byte
	SetPayload(payload []byte)

	SetRedirectPath(path string)
	RedirectPath() string

	SetFile(file *File)
	File() *File
}

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

type Server interface {
	generic_error.ErrorManager
	auth.WithAuth
	app_context.WithApp

	Init(ctx app_context.Context, auth auth.Auth, tenancyManager multitenancy.Multitenancy, configPath ...string) error

	// Get API version.
	ApiVersion() string

	// Run server.
	Run(fin background_worker.Finisher)

	// Check if hateoas links are enabled.
	IsHateoas() bool

	// Get tenancy manager
	TenancyManager() multitenancy.Multitenancy

	// Check for testing mode.
	Testing() bool

	// Get dynamic tables store
	DynamicTables() DynamicTables

	// Load default server configuration from corresponding pool service
	SetConfigFromPoolService(service pool.PoolService, public ...bool)

	// Get pool service used for server configuration
	ConfigPoolService() pool.PoolService

	RegisterService(Service) error

	ListEndpoints()
}

type ServerBase struct {
	app_context.WithAppBase
}

type ServerBaseConfig struct {
	common.WithNameBaseConfig
	API_VERSION          string `validate:"required"`
	HATEOAS              bool
	OPLOG_USER_TYPE      string `default:"server_user"`
	DISABLE_MULTITENANCY bool
}

type Service interface {
	generic_error.ErrorsExtender
	common.WithName
	api.Resource

	SetSupportsMultitenancy(enable bool)
	SupportsMultitenancy() bool

	Server() Server
	AttachToServer(server Server) error

	AddDynamicTables(tables ...*DynamicTableConfig)
	DynamicTables() []*DynamicTableConfig

	Package() string
	SetPackage(string)
}

type ServiceBase struct {
	common.WithNameBase
	api.ResourceBase
	generic_error.ErrorsExtenderBase
	// contains filtered or unexported fields
}

type ServiceEachEndpointHandler = func(ep Endpoint)

type StatusResponse struct {
	api.ResponseStub
	Status string `json:"status"`
}

type StatusService struct {
	ServiceBase
}