pufferpanel

var (
	Hash    = "unknown"
	Version = "nightly"
	Display string
)

var Engine *gin.Engine

var ErrCannotValidateToken = CreateError("could not validate access token", "ErrCannotValidateToken")

var ErrClientNotFound = CreateError("client not found", "ErrClientNotFound")

var ErrContainerRunning = CreateError("container already running", "ErrContainerRunning")

var ErrDatabaseNotAvailable = CreateError("database not available", "ErrDatabaseNotAvailable")

var ErrDockerNotSupported = CreateError("docker not supported", "ErrDockerNotSupported")

var ErrEmailNotConfigured = CreateError("email not configured", "ErrEmailNotConfigured")

var ErrFactoryError = func(operatorName string, err error) *Error {
	return CreateError("factory `${operatorName}` encountered an error: `${err}`", "ErrFactoryError").Metadata(map[string]interface{}{"operatorName": operatorName, "err": err.Error()})
}

var ErrFieldEqual = func(fieldName1, fieldName2 string) *Error {
	return CreateError("${field1} cannot be equal to ${field2}", "ErrFieldEqual").Metadata(map[string]interface{}{"field1": fieldName1, "field2": fieldName2})
}

var ErrFieldHasURICharacters = func(fieldName string) *Error {
	return CreateError("${field} must not contain characters which cannot be used in URIs", "ErrFieldHasURICharacters").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldIsInvalidHost = func(fieldName string) *Error {
	return CreateError("${field} must be a valid IP or FQDN", "ErrFieldIsInvalidHost").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldIsInvalidIP = func(fieldName string) *Error {
	return CreateError("${field} must be a valid IP", "ErrFieldIsInvalidIP").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldLength = func(fieldName string, min int, max int) *Error {
	return CreateError("${field} must be between ${min} and ${max} characters", "ErrFieldLength").Metadata(map[string]interface{}{"field": fieldName, "min": min, "max": max})
}

var ErrFieldMustBePrintable = func(fieldName string) *Error {
	return CreateError("${field} must be printable ascii characters", "ErrFieldMustBePrintable").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldNotBetween = func(fieldName string, min, max int64) *Error {
	return CreateError("${field} must be between ${min} and ${max}", "ErrFieldNotBetween").Metadata(map[string]interface{}{"field": fieldName, "min": min, "max": max})
}

var ErrFieldNotEmail = func(fieldName string) *Error {
	return CreateError("${field} is not a valid email", "ErrFieldNotEmail").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldNotEqual = func(fieldName1, fieldName2 string) *Error {
	return CreateError("${field1} is not equal to ${field2}", "ErrFieldNotEqual").Metadata(map[string]interface{}{"field1": fieldName1, "field2": fieldName2})
}

var ErrFieldRequired = func(fieldName string) *Error {
	return CreateError("${field} is required", "ErrFieldRequired").Metadata(map[string]interface{}{"field": fieldName})
}

var ErrFieldTooLarge = func(fieldName string, value int64) *Error {
	return CreateError("${field} cannot be larger than ${max}", "ErrFieldTooLarge").Metadata(map[string]interface{}{"field": fieldName, "max": value})
}

var ErrFieldTooSmall = func(fieldName string, value int64) *Error {
	return CreateError("${field} cannot be smaller than ${min}", "ErrFieldTooSmall").Metadata(map[string]interface{}{"field": fieldName, "min": value})
}

var ErrFileExists = CreateError("file exists where there should be none", "ErrFileExists")

var ErrFileNotFound = CreateError("file not found", "ErrFileNotFound")

var ErrIllegalFileAccess = CreateError("invalid file access", "ErrIllegalFileAccess")

var ErrImageDownloading = CreateError("image downloading", "ErrImageDownloading")

var ErrInvalidCredentials = CreateError("invalid credentials", "ErrInvalidCredentials")

var ErrInvalidSession = CreateError("invalid session", "ErrInvalidSession")

var ErrInvalidTokenState = CreateError("invalid token state", "ErrInvalidTokenState")

var ErrInvalidUnixTime = CreateError("time provided is not a valid UNIX time", "ErrInvalidUnixTime")

var ErrKeyNotECDSA = CreateError("key is not ECDSA key", "ErrKeyNotECDSA")

var ErrKeyNotPEM = CreateError("key is not in PEM format", "ErrKeyNotPEM")

var ErrLoginNotPermitted = CreateError("login not permitted", "ErrLoginNotPermitted")

var ErrMissingAccessToken = CreateError("access token not provided", "ErrMissingAccessToken")

var ErrMissingBinary = func(expected string) *Error {
	return CreateError("missing binary: ${expected}", "ErrMissingBinary").Metadata(map[string]interface{}{"expected": expected})
}

var ErrMissingFactory = CreateError("missing factory", "ErrMissingFactory")

var ErrMissingScope = CreateError("missing scope", "ErrMissingScope")

var ErrNoPermission = CreateError("no permission to perform action", "ErrNoPermission")

var ErrNoTemplate = func(template string) *Error {
	return CreateError("no template with name ${name}", "ErrNoTemplate").Metadata(map[string]interface{}{"template": template})
}

var ErrNodeHasServers = CreateError("node has servers associated", "ErrNodeHasServers")

var ErrNodeInvalid = CreateError("node is invalid", "ErrNodeInvalid")

var ErrNotBearerToken = CreateError("access token must be a Bearer token", "ErrNotBearerToken")

var ErrNotImplemented = CreateError("not implemented", "ErrNotImplemented")

var ErrProcessRunning = CreateError("process already running", "ErrProcessRunning")

var ErrServerAlreadyExists = CreateError("server already exists", "ErrServerAlreadyExists")

var ErrServerDisabled = CreateError("server is disabled", "ErrServerDisabled")

var ErrServerNotFound = CreateError("server not found", "ErrServerNotFound")

var ErrServerOffline = CreateError("server offline", "ErrServerOffline")

var ErrServiceInvalidProvider = func(service, provider string) *Error {
	return CreateError("{service} does not support ${provider}", "ErrServiceInvalidProvider").Metadata(map[string]interface{}{"service": service, "provider": provider})
}

var ErrServiceNotAvailable = CreateError("service not available", "ErrServiceNotAvailable")

var ErrSessionExpired = CreateError("session expired", "ErrSessionExpired")

var ErrSettingNotConfigured = func(name string) *Error {
	return CreateError("${setting} is not configured", "ErrSettingNotConfigured").Metadata(map[string]interface{}{"setting": name})
}

var ErrTaskNotFound = CreateError("task not found", "ErrTaskNotFound")

var ErrTokenInvalid = CreateError("token is invalid", "ErrTokenInvalid")

var ErrUnknownError = CreateError("unknown error", "ErrUnknownError")

var ErrUnsupportedArch = func(actual, expected string) *Error {
	return CreateError("Architecture ${actual} not supported. Supported Architectures: ${expected}", "ErrUnsupportedArch").Metadata(map[string]interface{}{"actual": actual, "expected": expected})
}

var ErrUnsupportedOS = func(actual, expected string) *Error {
	return CreateError("OS (${actual}) not supported. Supported OS: ${expected}", "ErrUnsupportedOS").Metadata(map[string]interface{}{"actual": actual, "expected": expected})
}

var ErrUserNotFound = CreateError("user not found", "ErrUserNotFound")