userroutes

type AdminRoutes struct {
	UserModel interface {
		GetAll() ([]domain.User, error)
		IsAdmin(userID domain.UserID) bool
		GetAllAdmins() ([]domain.UserID, error)
	} `checkinject:"required"`
	SettingsModel interface {
		Get() (domain.Settings, error)
		Set(domain.Settings) error
	} `checkinject:"required"`
	UserInvitationModel interface {
		GetAll() ([]domain.UserInvitation, error)
		Get(email string) (domain.UserInvitation, error)
		Create(email string) error
		Delete(email string) error
	} `checkinject:"required"`
}

type AppCommitResp struct {
	AppID   domain.AppID   `json:"app_id"`
	Version domain.Version `json:"version"`
}

type ApplicationMeta struct {
	AppID    int           `json:"app_id"`
	AppName  string        `json:"name"`
	Created  time.Time     `json:"created_dt"`
	Versions []VersionMeta `json:"versions"`
}

type ApplicationRoutes struct {
	AppGetter interface {
		FromRaw(userID domain.UserID, fileData *map[string][]byte, appIDs ...domain.AppID) (domain.AppGetKey, error)
		GetUser(key domain.AppGetKey) (domain.UserID, bool)
		GetLocationKey(key domain.AppGetKey) (string, bool)
		GetLastEvent(key domain.AppGetKey) (domain.AppGetEvent, bool)
		GetResults(domain.AppGetKey) (domain.AppGetMeta, bool)
		Commit(domain.AppGetKey) (domain.AppID, domain.Version, error)
		Delete(domain.AppGetKey)
	} `checkinject:"required"`
	DeleteApp interface {
		Delete(appID domain.AppID) error
		DeleteVersion(appID domain.AppID, version domain.Version) error
	} `checkinject:"required"`
	AppModel interface {
		GetFromID(domain.AppID) (*domain.App, error)
		GetForOwner(domain.UserID) ([]*domain.App, error)
		GetVersion(domain.AppID, domain.Version) (*domain.AppVersion, error)
		GetVersionsForApp(domain.AppID) ([]*domain.AppVersion, error)
	} `checkinject:"required"`
	AppLogger interface {
		Get(locationKey string) domain.LoggerI
	} `checkinject:"required"`
}

type AppspaceBackupRoutes struct {
	Config             *domain.RuntimeConfig `checkinject:"required"`
	AppspaceFilesModel interface {
		GetBackups(locationKey string) ([]string, error)
		DeleteBackup(locationKey string, filename string) error
	} `checkinject:"required"`
	BackupAppspace interface {
		CreateBackup(appspaceID domain.AppspaceID) (string, error)
	} `checkinject:"required"`
}

type AppspaceLoginRoutes struct {
	Config        *domain.RuntimeConfig `checkinject:"required"`
	AppspaceModel interface {
		GetFromDomain(dom string) (*domain.Appspace, error)
	} `checkinject:"required"`
	RemoteAppspaceModel interface {
		Get(userID domain.UserID, domainName string) (domain.RemoteAppspace, error)
	} `checkinject:"required"`
	DS2DS interface {
		GetRemoteAPIVersion(domainName string) (int, error)
	} `checkinject:"required"`
	V0RequestToken interface {
		RequestToken(ctx context.Context, userID domain.UserID, appspaceDomain string, sessionID string) (string, error)
	} `checkinject:"required"`
	V0TokenManager interface {
		GetForOwner(appspaceID domain.AppspaceID, dropID string) (string, error)
	} `checkinject:"required"`
}

type AppspaceMeta struct {
	AppspaceID int            `json:"appspace_id"`
	AppID      int            `json:"app_id"`
	AppVersion domain.Version `json:"app_version"`
	DomainName string         `json:"domain_name"`
	NoTLS      bool           `json:"no_tls"`
	PortString string         `json:"port_string"`
	DropID     string         `json:"dropid"`
	Created    time.Time      `json:"created_dt"`
	Paused     bool           `json:"paused"`
	Upgrade    *VersionMeta   `json:"upgrade,omitempty"`
}

type AppspaceRestoreRoutes struct {
	RestoreAppspace interface {
		Prepare(reader io.Reader) (string, error)
		PrepareBackup(appspaceID domain.AppspaceID, backupFile string) (string, error)
		CheckAppspaceDataValid(tok string) error
		GetMetaInfo(tok string) (domain.AppspaceMetaInfo, error)
		ReplaceData(tok string, appspaceID domain.AppspaceID) error
	} `checkinject:"required"`
}

type AppspaceRoutes struct {
	Config                domain.RuntimeConfig `checkinject:"required"`
	AppspaceUserRoutes    subRoutes            `checkinject:"required"`
	AppspaceExportRoutes  subRoutes            `checkinject:"required"`
	AppspaceRestoreRoutes subRoutes            `checkinject:"required"`
	AppModel              interface {
		GetFromID(domain.AppID) (*domain.App, error)
		GetVersion(domain.AppID, domain.Version) (*domain.AppVersion, error)
	} `checkinject:"required"`
	AppspaceFilesModel interface {
		CreateLocation() (string, error)
	} `checkinject:"required"`
	AppspaceModel interface {
		GetForOwner(domain.UserID) ([]*domain.Appspace, error)
		GetFromID(domain.AppspaceID) (*domain.Appspace, error)
		GetForApp(appID domain.AppID) ([]*domain.Appspace, error)
		Create(domain.Appspace) (*domain.Appspace, error)
		GetFromDomain(string) (*domain.Appspace, error)
	} `checkinject:"required"`
	PauseAppspace interface {
		Pause(appspaceID domain.AppspaceID, pause bool) error
	} `checkinject:"required"`
	DeleteAppspace interface {
		Delete(domain.Appspace) error
	} `checkinject:"required"`
	AppspaceLogger interface {
		Open(appspaceID domain.AppspaceID) domain.LoggerI
	} `checkinject:"required"`
	SandboxRunsModel interface {
		AppsaceSums(ownerID domain.UserID, appspaceID domain.AppspaceID, from time.Time, to time.Time) (domain.SandboxRunData, error)
	} `checkinject:"required"`
	AppspaceUsersModelV0 interface {
		Create(appspaceID domain.AppspaceID, authType string, authID string) (domain.ProxyID, error)
	} `checkinject:"required"`
	DomainController interface {
		CheckAppspaceDomain(userID domain.UserID, dom string, subdomain string) (domain.DomainCheckResult, error)
	} `checkinject:"required"`
	DropIDModel interface {
		Get(handle string, dom string) (domain.DropID, error)
	} `checkinject:"required"`
	MigrationMinder interface {
		GetForAppspace(domain.Appspace) (domain.AppVersion, bool, error)
	} `checkinject:"required"`
	AppspaceMetaDB interface {
		Create(domain.AppspaceID, int) error
	} `checkinject:"required"`
	MigrationJobModel interface {
		Create(domain.UserID, domain.AppspaceID, domain.Version, bool) (*domain.MigrationJob, error)
	} `checkinject:"required"`
	MigrationJobController interface {
		WakeUp()
	} `checkinject:"required"`
}

type AppspaceUserRoutes struct {
	AppspaceUsersModelV0 interface {
		Get(appspaceID domain.AppspaceID, proxyID domain.ProxyID) (domain.AppspaceUser, error)
		GetAll(appspaceID domain.AppspaceID) ([]domain.AppspaceUser, error)
		Create(appspaceID domain.AppspaceID, authType string, authID string) (domain.ProxyID, error)
		UpdateAuth(appspaceID domain.AppspaceID, proxyID domain.ProxyID, authType string, authID string) error
		UpdateMeta(appspaceID domain.AppspaceID, proxyID domain.ProxyID, displayName string, avatar string, permissions []string) error
		Delete(appspaceID domain.AppspaceID, proxyID domain.ProxyID) error
	} `checkinject:"required"`
	Avatars interface {
		Save(locationKey string, proxyID domain.ProxyID, img io.Reader) (string, error)
		Remove(locationKey string, fn string) error
	} `checkinject:"required"`
	Config *domain.RuntimeConfig `checkinject:"required"`
}

type AuthRoutes struct {
	Views interface {
		Login(http.ResponseWriter, domain.LoginViewData)
		Signup(http.ResponseWriter, domain.SignupViewData)
	} `checkinject:"required"`
	SettingsModel interface {
		Get() (domain.Settings, error)
	} `checkinject:"required"`
	UserModel interface {
		Create(email, password string) (domain.User, error)
		GetFromEmailPassword(email, password string) (domain.User, error)
	} `checkinject:"required"`
	UserInvitationModel interface {
		Get(email string) (domain.UserInvitation, error)
	} `checkinject:"required"`
	Authenticator interface {
		SetForAccount(http.ResponseWriter, domain.UserID) error
		Unset(http.ResponseWriter, *http.Request)
	} `checkinject:"required"`
}

type BackupFile struct {
	Filename string `json:"filename"`
}

type ContactResp struct {
	UserID      domain.UserID    `json:"user_id"`
	ContactID   domain.ContactID `json:"contact_id"`
	Name        string           `json:"name"`
	DisplayName string           `json:"display_name"`
	Created     time.Time        `json:"created_dt"`
}

type ContactRoutes struct {
	ContactModel interface {
		Create(userID domain.UserID, name string, displayName string) (domain.Contact, error)
		Update(userID domain.UserID, contactID domain.ContactID, name string, displayName string) error
		Delete(userID domain.UserID, contactID domain.ContactID) error
		Get(contactID domain.ContactID) (domain.Contact, error)
		GetForUser(userID domain.UserID) ([]domain.Contact, error)
	} `checkinject:"required"`
}

type CreateContactPostReq struct {
	Name        string `json:"name" validate:"nonzero,max=100"`
	DisplayName string `json:"display_name" validate:"nonzero,max=100"`
}

type DomainNameRoutes struct {
	DomainController interface {
		GetDomains(userID domain.UserID) ([]domain.DomainData, error)
		CheckAppspaceDomain(userID domain.UserID, dom string, subdomain string) (domain.DomainCheckResult, error)
	} `checkinject:"required"`
}

type DropIDRoutes struct {
	DomainController interface {
		GetDropIDDomains(userID domain.UserID) ([]domain.DomainData, error)
	} `checkinject:"required"`
	DropIDModel interface {
		Create(userID domain.UserID, handle string, dom string, displayName string) (domain.DropID, error)
		Update(userID domain.UserID, handle string, dom string, displayName string) (domain.DropID, error)
		Get(handle string, dom string) (domain.DropID, error)
		GetForUser(userID domain.UserID) ([]domain.DropID, error)
	} `checkinject:"required"`
}

type FilesUploadResp struct {
	Key domain.AppGetKey `json:"app_get_key"`
}

type GetAppsResp struct {
	Apps []ApplicationMeta `json:"apps"`
}

type InProcessResp struct {
	LastEvent domain.AppGetEvent `json:"last_event"`
	Meta      domain.AppGetMeta  `json:"meta"`
}

type MigrationJobRoutes struct {
	AppModel interface {
		GetVersion(domain.AppID, domain.Version) (*domain.AppVersion, error)
	} `checkinject:"required"`
	AppspaceModel interface {
		GetFromID(domain.AppspaceID) (*domain.Appspace, error)
	} `checkinject:"required"`
	MigrationJobModel interface {
		Create(ownerID domain.UserID, appspaceID domain.AppspaceID, toVersion domain.Version, priority bool) (*domain.MigrationJob, error)
		GetJob(jobID domain.JobID) (*domain.MigrationJob, error)
		GetForAppspace(appspaceID domain.AppspaceID) ([]*domain.MigrationJob, error)
	} `checkinject:"required"`
	MigrationJobController interface {
		WakeUp()
	} `checkinject:"required"`
}

type NewAppResp struct {
	App     domain.App        `json:"app"`
	Version domain.AppVersion `json:"app_version"`
}

type PatchPasswordReq struct {
	Old string `json:"old"`
	New string `json:"new"`
}

type PostAppspacePauseReq struct {
	Pause bool `json:"pause"`
}

type PostAppspaceReq struct {
	AppID      domain.AppID   `json:"app_id"`
	Version    domain.Version `json:"app_version"`
	DomainName string         `json:"domain_name"`
	Subdomain  string         `json:"subdomain"`
	DropID     string         `json:"dropid"`
}

type PostAppspaceResp struct {
	AppspaceID domain.AppspaceID `json:"appspace_id"`
}

type PostAppspaceUser struct {
	AuthType    string   `json:"auth_type"`
	AuthID      string   `json:"auth_id"`
	DisplayName string   `json:"display_name"`
	Avatar      string   `json:"avatar"` //  "replace", any other value means no avatar is loaded
	Permissions []string `json:"permissions"`
}

type PostAppspaceVersionReq struct {
	AppspaceID domain.AppspaceID `json:"appspace_id"`
	Version    domain.Version    `json:"to_version"` // could include app_id to future proof and to verify apples-apples
}

type PostInvitation struct {
	Email string `json:"email"`
}

type RemoteAppspaceMeta struct {
	UserID      domain.UserID `json:"user_id"`
	DomainName  string        `json:"domain_name"`
	OwnerDropID string        `json:"owner_dropid"`
	UserDropID  string        `json:"dropid"`
	NoTLS       bool          `json:"no_tls"`
	PortString  string        `json:"port_string"`
	Created     time.Time     `json:"created_dt"`
}

type RemoteAppspacePost struct {
	CheckOnly  bool   `json:"check_only"`
	DomainName string `json:"domain_name"`
	UserDropID string `json:"user_dropid"`
}

type RemoteAppspacePostRet struct {
	InputsValid   bool   `json:"inputs_valid"`
	DomainMessage string `json:"domain_message"`
	RemoteMessage string `json:"remote_message"`
}

type RemoteAppspaceRoutes struct {
	Config              domain.RuntimeConfig `checkinject:"required"`
	RemoteAppspaceModel interface {
		Get(userID domain.UserID, domainName string) (domain.RemoteAppspace, error)
		GetForUser(userID domain.UserID) ([]domain.RemoteAppspace, error)
		Create(userID domain.UserID, domainName string, ownerDropID string, dropID string) error
		Delete(userID domain.UserID, domainName string) error
	} `checkinject:"required"`
	AppspaceModel interface {
		GetForOwner(domain.UserID) ([]*domain.Appspace, error)
	} `checkinject:"required"`
	DropIDModel interface {
		Get(handle string, dom string) (domain.DropID, error)
	} `checkinject:"required"`
}

type RestoreData struct {
	Token  string        `json:"token"`
	Error  *RestoreError `json:"err"`
	Schema int           `json:"schema"`
}

type RestoreError struct {
	// MissingFiles is top-level files missing from the zip file we are attempting to restore
	MissingFiles []string `json:"missing_files"`
	// ZipFiles is the set of files in the top level of the zip
	// provided for convenience to the user so they may find their mistake
	ZipFiles []string `json:"zip_files"`
}

type SelectBackup struct {
	BackupFilename string `json:"backup_file"`
}

type SettingsResp struct {
	RegistrationOpen bool `json:"registration_open"`
}

type UserData struct {
	Email   string `json:"email"`
	UserID  int    `json:"user_id"`
	IsAdmin bool   `json:"is_admin"`
}

type UserRoutes struct {
	Config        *domain.RuntimeConfig `checkinject:"required"`
	Authenticator interface {
		AccountUser(http.Handler) http.Handler
	} `checkinject:"required"`
	Views interface {
		GetStaticFS() fs.FS
	} `checkinject:"required"`
	AuthRoutes           routeGroup           `checkinject:"required"`
	AppspaceLoginRoutes  routeGroup           `checkinject:"required"`
	ApplicationRoutes    subRoutes            `checkinject:"required"`
	AppspaceRoutes       subRoutes            `checkinject:"required"`
	RemoteAppspaceRoutes subRoutes            `checkinject:"required"`
	ContactRoutes        subRoutes            `checkinject:"required"`
	DomainRoutes         subRoutes            `checkinject:"required"`
	DropIDRoutes         subRoutes            `checkinject:"required"`
	MigrationJobRoutes   subRoutes            `checkinject:"required"`
	AdminRoutes          subRoutes            `checkinject:"required"`
	AppspaceStatusTwine  domain.TwineService  `checkinject:"required"`
	MigrationJobTwine    domain.TwineService2 `checkinject:"required"`
	AppGetterTwine       domain.TwineService  `checkinject:"required"`
	UserModel            interface {
		GetFromID(userID domain.UserID) (domain.User, error)
		UpdatePassword(userID domain.UserID, password string) error
		GetFromEmailPassword(email, password string) (domain.User, error)
		IsAdmin(userID domain.UserID) bool
	} `checkinject:"required"`
	// contains filtered or unexported fields
}

type VersionMeta struct {
	AppID      domain.AppID      `json:"app_id"`
	AppName    string            `json:"app_name"`
	Version    domain.Version    `json:"version"`
	APIVersion domain.APIVersion `json:"api_version"`
	Schema     int               `json:"schema"`
	Created    time.Time         `json:"created_dt"`
}

type Versions struct {
	AppVersions []VersionMeta `json:"app_versions"`
}