api_server

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

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

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

type EndpointBase struct {
	api.Operation
	generic_error.ErrorsExtenderBase
}

type EndpointHandler = func(request Request)

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 Request interface {
	auth.AuthContext
	common.WithParameters

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

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

type RequestBase struct {
	auth.TenancyUserContext
	auth.SessionBase
	// 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)

	Text() string
	SetText(text string)

	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

	// Get API version.
	ApiVersion() string

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

	// Add operation endpoint to server.
	AddEndpoint(ep Endpoint, multitenancy ...bool)

	// 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
}

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
	api.Resource

	SetSupportsMultitenancy(enable bool)
	SupportsMultitenancy() bool

	Server() Server
	AttachToServer(server Server) error

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

type ServiceBase struct {
	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
}