slovo

type Binder struct {
	*echo.DefaultBinder
}

type Config struct {
	// Langs is a list of supported languages. The last is the default.
	Langs []string `yaml:"Langs"`
	Debug bool     `yaml:"Debug"`
	// DomoveRoot is the root folder for static content and templates of parked
	// domains. Defaults to `BinDir()/domove`.
	DomoveRoot string `yaml:"DomoveRoot"`
	// DomovePrefixes is a common list of prefixes, used in parked domains to
	// create subdomains for various purposes. These prefixes are cut and then
	// the domain name is used for domain root.
	DomovePrefixes []string `yaml:DomovePrefixes`
	// GuestID is the id of the user when a guest (unauthenticated) visits the
	// site.
	GuestID int32 `yaml:"GuestID"`
	// File is the path to the configuration file in which this structure will
	// be dumped in YAML format.
	File     string   `yaml:"File"`
	Serve    Serve    `yaml:"Serve"`
	StartCGI ServeCGI `yaml:"ServeCGI"`
	// List of routes to be created by Echo
	Routes Routes `yaml:"Routes"`
	// Arguments for instantiating GledkiRenderer
	Renderer Renderer `yaml:"Renderer"`
	// StaticRoutes - folders` routes to be served by `echo` from
	// within the installation public folder. Common for all domains. If a
	// file is not found in the domain public folder, it will fall back to
	// be served from here if found. For example request to /css/site.css
	// will be served from public/css/site.css.
	// `e.Static("/css","public/css").`
	StaticRoutes []StaticRoute `yaml:"StaticRoutes"`
	// DomoveStaticFiles is a regex of file extensions. If a file, matching the
	// regex is requested, we will look into the domain specific public folder
	// and serve it if found.
	DomoveStaticFiles string `yaml:DomoveStaticFiles`
	// DB is for database configuration. For now we use sqlite3.
	DB DBConfig `yaml:"DB"`
	// Rewrite is used to pass configuration values to
	// [middleware.RewriteWithConfig].
	Rewrite Rewrite `yaml:"Rewrite"`
	// CachePages - should we cache pages or not. true means `yes` and false
	// means `no`
	CachePages bool `yaml:"CachePages"`
}

type Context struct {
	echo.Context
	// StraniciArgs contains a pointer to [m.StraniciArgs].
	StraniciArgs *m.StraniciArgs

	// DomainRoot is the root folder for static content folders and `templates`
	// folder of the domain for this HTTP request.
	DomainRoot string
	// Domain contains a pointer to a m.Domove record - the current domain.
	Domain *m.Domove
	// contains filtered or unexported fields
}

type DBConfig struct {
	DSN string `yaml:"DSN"`
}

type EchoRenderer struct {
	*gledki.Gledki
}

type Renderer struct {
	TemplateRoots []string  `yaml:"TemplateRoots"`
	Ext           string    `yaml:"Ext"`
	Tags          [2]string `yaml:"Tags"`
	LoadFiles     bool      `yaml:"LoadFiles"`
}

type Rewrite struct {
	SkipperFuncName string `yaml:"SkipperFuncName"`
	// Rules is a map of string to string in which the key is a regular
	// expression and the value is the resulting route mapping description
	Rules map[string]string `yaml:"Rules"`
}

type Route struct {
	// Method is a method name from echo.Echo.
	Method string `yaml:"Method"`
	// Handler stores a HTTP handler function name as string.
	// It is not possible to lookup a function by its name (as a string) in Go,
	// but we need to store the function names in the configuration file to
	// easily enable/disable a route. So we use a map in slovo/handlers.go `var
	// handlers = map[string]func(c echo.Context) error`
	Handler string `yaml:"Handler"`
	// Path is the REQUEST_PATH
	Path string `yaml:"Path"`
	// MiddlewareFuncs is optional
	MiddlewareFuncs []string `yaml:"MiddlewareFunc"`
	// Name is the name of the route. Used to generate URIs. See
	// https://echo.labstack.com/docs/routing#route-naming
	Name string `yaml:"Name"`
}

type Routes []Route

type Serve struct {
	// Location is descrived as f.q.d.n:port
	Location string `yaml:"Location"`
}

type ServeCGI struct {
	HTTP_HOST      string `yaml:"HTTP_HOST"`
	REQUEST_URI    string `yaml:"REQUEST_URI"`
	REQUEST_METHOD string `yaml:"REQUEST_METHOD"`
	// SERVER_PROTOCOL used in CGI environment - HTTP/1.1. Recuired variable by
	// the cgi Go module.
	SERVER_PROTOCOL     string `yaml:"SERVER_PROTOCOL"`
	HTTP_ACCEPT_CHARSET string `yaml:"HTTP_ACCEPT_CHARSET"`
	CONTENT_TYPE        string `yaml:"CONTENT_TYPE"`
}

type Stash = gledki.Stash

type StaticRoute struct {
	Prefix string `yaml:"Prefix"`
	Root   string `yaml:"Root"`
}

type StaticRoutes []StaticRoute