models

type ApiKey struct {
	Id           string `json:"Id" redis:"Id"`
	FriendlyName string `json:"FriendlyName" redis:"FriendlyName"`
	LastUsed     int64  `json:"LastUsed" redis:"LastUsed"`
	Permissions  uint8  `json:"Permissions" redis:"Permissions"`
	Expiry       int64  `json:"Expiry" redis:"Expiry"` // Does not expire if 0
	IsSystemKey  bool   `json:"IsSystemKey" redis:"IsSystemKey"`
}

type ApiKeyOutput struct {
	Result string
	Id     string
}

type AuthenticationConfig struct {
	Method               int      `json:"Method"`
	SaltAdmin            string   `json:"SaltAdmin"`
	SaltFiles            string   `json:"SaltFiles"`
	Username             string   `json:"Username"`
	Password             string   `json:"Password"`
	HeaderKey            string   `json:"HeaderKey"`
	OAuthProvider        string   `json:"OauthProvider"`
	OAuthClientId        string   `json:"OAuthClientId"`
	OAuthClientSecret    string   `json:"OAuthClientSecret"`
	OAuthUserScope       string   `json:"OauthUserScope"`
	OAuthGroupScope      string   `json:"OauthGroupScope"`
	OAuthRecheckInterval int      `json:"OAuthRecheckInterval"`
	HeaderUsers          []string `json:"HeaderUsers"`
	OAuthGroups          []string `json:"OAuthGroups"`
	OAuthUsers           []string `json:"OauthUsers"`
}

type AwsConfig struct {
	Bucket        string `yaml:"Bucket"`
	Region        string `yaml:"Region"`
	KeyId         string `yaml:"KeyId"`
	KeySecret     string `yaml:"KeySecret"`
	Endpoint      string `yaml:"Endpoint"`
	ProxyDownload bool   `yaml:"ProxyDownload"`
}

type Configuration struct {
	Authentication      AuthenticationConfig `json:"Authentication"`
	Port                string               `json:"Port"`
	ServerUrl           string               `json:"ServerUrl"`
	RedirectUrl         string               `json:"RedirectUrl"`
	PublicName          string               `json:"PublicName"`
	DataDir             string               `json:"DataDir"`
	DatabaseUrl         string               `json:"DatabaseUrl"`
	ConfigVersion       int                  `json:"ConfigVersion"`
	LengthId            int                  `json:"LengthId"`
	MaxFileSizeMB       int                  `json:"MaxFileSizeMB"`
	MaxMemory           int                  `json:"MaxMemory"`
	ChunkSize           int                  `json:"ChunkSize"`
	MaxParallelUploads  int                  `json:"MaxParallelUploads"`
	Encryption          Encryption           `json:"Encryption"`
	UseSsl              bool                 `json:"UseSsl"`
	PicturesAlwaysLocal bool                 `json:"PicturesAlwaysLocal"`
	SaveIp              bool                 `json:"SaveIp"`
	IncludeFilename     bool                 `json:"IncludeFilename"`
}

type DbConnection struct {
	HostUrl     string
	RedisPrefix string
	Username    string
	Password    string
	RedisUseSsl bool
	Type        int
}

type DownloadStatus struct {
	Id       string
	FileId   string
	ExpireAt int64
}

type E2EFile struct {
	Uuid     string `json:"uuid"`
	Id       string `json:"id"`
	Filename string `json:"filename"`
	Cipher   []byte `json:"cipher"`
}

type E2EHashContent struct {
	Filename string `json:"f"`
	Cipher   string `json:"c"`
}

type E2EInfoEncrypted struct {
	// Version of the E2E used, must be at least 1
	Version int `json:"version" redis:"version"`
	// Nonce used for encryption
	Nonce []byte `json:"nonce" redis:"nonce"`
	// Content that is encrypted
	Content []byte `json:"content" redis:"content"`
	// AvailableFiles contains a list of all files on the webserver and will be populated
	// when reading from the database, but will not be saved to the database
	AvailableFiles []string `json:"availablefiles" redis:"-"`
}

type E2EInfoPlainText struct {
	Files []E2EFile `json:"files"`
}

type Encryption struct {
	Level        int
	Cipher       []byte
	Salt         string
	Checksum     string
	ChecksumSalt string
}

type EncryptionInfo struct {
	IsEncrypted         bool   `json:"IsEncrypted" redis:"IsEncrypted"`
	IsEndToEndEncrypted bool   `json:"IsEndToEndEncrypted" redis:"IsEndToEndEncrypted"`
	DecryptionKey       []byte `json:"DecryptionKey" redis:"DecryptionKey"`
	Nonce               []byte `json:"Nonce" redis:"Nonce"`
}

type File struct {
	Id                      string         `json:"Id" redis:"Id"`                                 // The internal ID of the file
	Name                    string         `json:"Name" redis:"Name"`                             // The filename. Will be 'Encrypted file' for end-to-end encrypted files
	Size                    string         `json:"Size" redis:"Size"`                             // Filesize in a human-readable format
	SHA1                    string         `json:"SHA1" redis:"SHA1"`                             // The hash of the file, used for deduplication
	PasswordHash            string         `json:"PasswordHash" redis:"PasswordHash"`             // The hash of the password (if the file is password protected)
	HotlinkId               string         `json:"HotlinkId" redis:"HotlinkId"`                   // If file is a picture file and can be hotlinked, this is the ID for the hotlink
	ContentType             string         `json:"ContentType" redis:"ContentType"`               // The MIME type for the file
	AwsBucket               string         `json:"AwsBucket" redis:"AwsBucket"`                   // If the file is stored in the cloud, this is the bucket that is being used
	ExpireAtString          string         `json:"ExpireAtString" redis:"ExpireAtString"`         // Time expiry in a human-readable format in local time
	ExpireAt                int64          `json:"ExpireAt" redis:"ExpireAt"`                     // "UTC timestamp of file expiry
	SizeBytes               int64          `json:"SizeBytes" redis:"SizeBytes"`                   // Filesize in bytes
	DownloadsRemaining      int            `json:"DownloadsRemaining" redis:"DownloadsRemaining"` // The remaining downloads for this file
	DownloadCount           int            `json:"DownloadCount" redis:"DownloadCount"`           // The amount of times the file has been downloaded
	Encryption              EncryptionInfo `json:"Encryption" redis:"-"`                          // If the file is encrypted, this stores all info for decrypting
	UnlimitedDownloads      bool           `json:"UnlimitedDownloads" redis:"UnlimitedDownloads"` // True if the uploader did not limit the downloads
	UnlimitedTime           bool           `json:"UnlimitedTime" redis:"UnlimitedTime"`           // True if the uploader did not limit the time
	InternalRedisEncryption []byte         `redis:"EncryptionRedis"`                              // This field is an internal field, used to store the EncryptionInfo in a Redis Hashmap
}

type FileApiOutput struct {
	Id                           string `json:"Id"`                           // The internal ID of the file
	Name                         string `json:"Name"`                         // The filename. Will be 'Encrypted file' for end-to-end encrypted files
	Size                         string `json:"Size"`                         // Filesize in a human-readable format
	HotlinkId                    string `json:"HotlinkId"`                    // If file is a picture file and can be hotlinked, this is the ID for the hotlink
	ContentType                  string `json:"ContentType"`                  // The MIME type for the file
	ExpireAtString               string `json:"ExpireAtString"`               // Time expiry in a human-readable format in local time
	UrlDownload                  string `json:"UrlDownload"`                  // The public download URL for the file
	UrlHotlink                   string `json:"UrlHotlink"`                   // The public hotlink URL for the file
	ExpireAt                     int64  `json:"ExpireAt"`                     // "UTC timestamp of file expiry
	SizeBytes                    int64  `json:"SizeBytes"`                    // Filesize in bytes
	DownloadsRemaining           int    `json:"DownloadsRemaining"`           // The remaining downloads for this file
	DownloadCount                int    `json:"DownloadCount"`                // The amount of times the file has been downloaded
	UnlimitedDownloads           bool   `json:"UnlimitedDownloads"`           // True if the uploader did not limit the downloads
	UnlimitedTime                bool   `json:"UnlimitedTime"`                // True if the uploader did not limit the time
	RequiresClientSideDecryption bool   `json:"RequiresClientSideDecryption"` // True if the file has to be decrypted client-side
	IsEncrypted                  bool   `json:"IsEncrypted"`                  // True if the file is encrypted
	IsEndToEndEncrypted          bool   `json:"IsEndToEndEncrypted"`          // True if the file is end-to-end encrypted
	IsPasswordProtected          bool   `json:"IsPasswordProtected"`          // True if a password has to be entered before downloading the file
	IsSavedOnLocalStorage        bool   `json:"IsSavedOnLocalStorage"`        // True if the file does not use cloud storage
}

type Result struct {
	Result          string        `json:"Result"`
	FileInfo        FileApiOutput `json:"FileInfo"`
	IncludeFilename bool          `json:"IncludeFilename"`
}

type Session struct {
	RenewAt    int64 `redis:"renew_at"`
	ValidUntil int64 `redis:"valid_until"`
}

type UploadRequest struct {
	AllowedDownloads    int
	Expiry              int
	ExpiryTimestamp     int64
	Password            string
	ExternalUrl         string
	MaxMemory           int
	UnlimitedDownload   bool
	UnlimitedTime       bool
	IsEndToEndEncrypted bool
	RealSize            int64
}

type UploadStatus struct {
	// ChunkId is the identifier for the chunk
	ChunkId string
	// CurrentStatus indicates if the chunk is currently being processed (e.g. encrypting or
	// hashing) or being moved/uploaded to the file storage
	// See ProcessingStatus for definition
	CurrentStatus int
	// FileId is populated, once a file has been created from a chunk
	FileId string
	// ErrorMessage is empty, unless an error occurred
	ErrorMessage string `json:"errormessage"`
	// Creation is the unix time when the status was created and is populated automatically
	Creation int64
}