userroutes

type AdminRoutes struct {
	UserModel interface {
		GetAll() ([]domain.User, error)
		GetFromID(domain.UserID) (domain.User, error)
		IsAdmin(userID domain.UserID) bool
		GetAllAdmins() ([]domain.UserID, error)
		CreateWithTSNet(string, string) (domain.User, error)
		UpdateTSNet(domain.UserID, string, string) error
		DeleteTSNet(domain.UserID) error
	} `checkinject:"required"`
	SettingsModel interface {
		Get() (domain.Settings, error)
		SetRegistrationOpen(bool) error
		GetTSNet() (domain.TSNetCommon, error)
		SetTSNet(domain.TSNetCommon) error
		SetTSNetConnect(bool) error
		DeleteTSNet() 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"`
	UserTSNet interface {
		Create(domain.TSNetCreateConfig) error
		Connect(bool) error
		Disconnect()
		Delete() error
		GetStatus() domain.TSNetStatus
		GetPeerUsers() []domain.TSNetPeerUser
	} `checkinject:"required"`
}

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

type ApplicationResp struct {
	domain.App
	UrlData    *domain.AppURLData  `json:"url_data,omitempty"`
	CurVer     domain.Version      `json:"cur_ver"` // CurVer is the latest locally installed version
	VesionData domain.AppVersionUI `json:"ver_data"`
}

type ApplicationRoutes struct {
	AppGetter interface {
		InstallFromURL(domain.UserID, string, domain.Version, bool) (domain.AppGetKey, error)
		InstallNewVersionFromURL(domain.UserID, domain.AppID, domain.Version) (domain.AppGetKey, error)
		InstallPackage(userID domain.UserID, locationKey string, 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"`
	RemoteAppGetter interface {
		FetchValidListing(string) (domain.AppListingFetch, error)
		RefreshAppListing(domain.AppID) error
		FetchNewVersionManifest(domain.AppID, domain.Version) (domain.AppGetMeta, error)
		FetchUrlVersionManifest(string, domain.Version) (domain.AppGetMeta, error)
		FetchChangelog(listingURL string, version domain.Version) (string, error)
		FetchIcon(string, domain.Version) ([]byte, error)
		ChangeURL(appID domain.AppID, url string) error
	} `checkinject:"required"`
	DeleteApp interface {
		Delete(appID domain.AppID) error
		DeleteVersion(appID domain.AppID, version domain.Version) error
	} `checkinject:"required"`
	AppFilesModel interface {
		SavePackage(io.Reader) (string, error)
		GetVersionChangelog(locationKey string, version domain.Version) (string, error)
		GetLinkPath(string, string) string
	} `checkinject:"required"`
	AppModel interface {
		GetFromID(domain.AppID) (domain.App, error)
		GetForOwner(domain.UserID) ([]*domain.App, error)
		GetAppUrlData(appID domain.AppID) (domain.AppURLData, error)
		GetAppUrlListing(appID domain.AppID) (domain.AppListing, domain.AppURLData, error)
		UpdateAutomatic(appID domain.AppID, auto bool) error
		GetCurrentVersion(appID domain.AppID) (domain.Version, error)
		GetVersion(domain.AppID, domain.Version) (domain.AppVersion, error) // maybe no longer necessary?
		GetVersionForUI(appID domain.AppID, version domain.Version) (domain.AppVersionUI, error)
		GetVersionsForUIForApp(domain.AppID) ([]domain.AppVersionUI, error)
	} `checkinject:"required"`
	AppLogger interface {
		Get(locationKey string) domain.LoggerI
	} `checkinject:"required"`
}

type AppspaceBackupRoutes struct {
	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"`
	AppspaceLocation2Path interface {
		Backup(string, string) string
	} `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 AppspaceResp 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"`
	Status         domain.AppspaceStatusEvent `json:"status"`
	TSNetStatus    domain.TSNetAppspaceStatus `json:"tsnet_status"`
	UpgradeVersion domain.Version             `json:"upgrade_version,omitempty"`
	AppVersionData *domain.AppVersionUI       `json:"ver_data,omitempty"`
	TSNetData      *domain.AppspaceTSNet      `json:"tsnet_data,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)
		GetVersionForUI(appID domain.AppID, version domain.Version) (domain.AppVersionUI, error)
	} `checkinject:"required"`
	AppspaceModel interface {
		GetForOwner(domain.UserID) ([]*domain.Appspace, error)
		GetFromID(domain.AppspaceID) (*domain.Appspace, error)
		GetForApp(appID domain.AppID) ([]*domain.Appspace, error)
	} `checkinject:"required"`
	AppspaceTSNetModel interface {
		Get(domain.AppspaceID) (domain.AppspaceTSNet, error)
		CreateOrUpdate(appspaceID domain.AppspaceID, backendURL string, hostname string, connect bool) error
		SetConnect(domain.AppspaceID, bool) error
		Delete(domain.AppspaceID) error
	} `checkinject:"required"`
	AppspaceStatus interface {
		Get(domain.AppspaceID) domain.AppspaceStatusEvent
	} `checkinject:"required"`
	AppspaceTSNet interface {
		Create(domain.AppspaceID, domain.TSNetCreateConfig) error
		Connect(domain.AppspaceID) error
		Disconnect(domain.AppspaceID)
		Delete(domain.AppspaceID) error
		GetStatus(domain.AppspaceID) domain.TSNetAppspaceStatus
		GetPeerUsers(domain.AppspaceID) []domain.TSNetPeerUser
	} `checkinject:"required"`
	CreateAppspace interface {
		Create(domain.DropID, domain.AppVersion, string, string) (domain.AppspaceID, domain.JobID, 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 {
		AppspaceSums(ownerID domain.UserID, appspaceID domain.AppspaceID, from time.Time, to time.Time) (domain.SandboxRunData, error)
	} `checkinject:"required"`
	DropIDModel interface {
		Get(handle string, dom string) (domain.DropID, error)
	} `checkinject:"required"`
	MigrationMinder interface {
		GetForAppspace(domain.Appspace) (domain.Version, bool, error)
	} `checkinject:"required"`
}

type AppspaceUserRoutes struct {
	AppspaceUserModel interface {
		Get(appspaceID domain.AppspaceID, proxyID domain.ProxyID) (domain.AppspaceUser, error)
		GetAll(appspaceID domain.AppspaceID) ([]domain.AppspaceUser, error)
		Create(appspaceID domain.AppspaceID, displayName string, avatar string, auths []domain.EditAppspaceUserAuth) (domain.ProxyID, error)
		Update(appspaceID domain.AppspaceID, proxyID domain.ProxyID, displayName string, avatar string, auths []domain.EditAppspaceUserAuth) error
		UpdateAuth(appspaceID domain.AppspaceID, proxyID domain.ProxyID, auth domain.EditAppspaceUserAuth) error
		UpdateAvatar(appspaceID domain.AppspaceID, proxyID domain.ProxyID, avatar 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"`
	AppspaceLocation2Path interface {
		Avatar(string, string) string
	} `checkinject:"required"`
}

type AuthRoutes struct {
	SetupKey interface {
		Has() (bool, error)
		Get() (string, error)
		Delete() error
	} `checkinject:"required"`
	Views interface {
		Login(http.ResponseWriter, domain.LoginViewData)
		Signup(http.ResponseWriter, domain.SignupViewData)
	} `checkinject:"required"`
	SettingsModel interface {
		Get() (domain.Settings, error)
	} `checkinject:"required"`
	UserModel interface {
		CreateWithEmail(email, password string) (domain.User, error)
		GetFromEmailPassword(email, password string) (domain.User, error)
		MakeAdmin(userID domain.UserID) 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 ConnectReq struct {
	Connect bool `json:"connect"`
}

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 CurrentUserData struct {
	UserData
	UsingTSNet bool `json:"using_tsnet"`
}

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 DropIDAvailableResp struct {
	Available bool `json:"available"`
}

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) 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 FromPublic struct {
	Authenticator interface {
		AccountUser(http.Handler) http.Handler
	} `checkinject:"required"`
	AuthRoutes routeGroup `checkinject:"required"`
	UserRoutes interface {
		BuildRoutes(mux *chi.Mux)
	} `checkinject:"required"`
	// contains filtered or unexported fields
}

type FromTSNet struct {
	UserModel interface {
		GetFromTSNet(string) (domain.User, error)
	} `checkinject:"required"`
	UserRoutes interface {
		BuildRoutes(mux *chi.Mux)
	} `checkinject:"required"`
	// contains filtered or unexported fields
}

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

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

type InstallAppFromURLRequest struct {
	URL                string         `json:"url"`
	Version            domain.Version `json:"version"`
	AutoRefreshListing bool           `json:"auto_refresh_listing"`
}

type InstallNewVersionFromURLRequest struct {
	Version domain.Version `json:"version"`
}

type InstanceData struct {
	DsHostVersion string `json:"ds_host_version"`
	DenoVersion   string `json:"deno_version"`
}

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 PatchDropID struct {
	DisplayName string `json:"display_name"`
}

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

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

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"`
	JobID      domain.JobID      `json:"job_id"`
}

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

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 PostAuth struct {
	Type       string `json:"type"`
	Identifier string `json:"identifier"`
	ExtraName  string `json:"extra_name"`
	Op         string `json:"op"`
}

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 UserData struct {
	domain.User
	IsAdmin bool `json:"is_admin"`
}

type UserRoutes struct {
	Config *domain.RuntimeConfig `checkinject:"required"`
	Views  interface {
		GetStaticFS() fs.FS
	} `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"`
	UserTSNetStatusEvents interface {
		Subscribe() <-chan domain.TSNetStatus
		Unsubscribe(ch <-chan domain.TSNetStatus)
	} `checkinject:"required"`
	UserTSNetPeersEvents interface {
		Subscribe() <-chan struct{}
		Unsubscribe(ch <-chan struct{})
	} `checkinject:"required"`
	AppspaceStatusEvents interface {
		SubscribeOwner(domain.UserID) <-chan domain.AppspaceStatusEvent
		Unsubscribe(ch <-chan domain.AppspaceStatusEvent)
	} `checkinject:"required"`
	AppspaceTSNetStatusEvents interface {
		SubscribeOwner(domain.UserID) <-chan domain.TSNetAppspaceStatus
		Unsubscribe(ch <-chan domain.TSNetAppspaceStatus)
	} `checkinject:"required"`
	AppspaceTSNetPeersEvents interface {
		SubscribeOwner(domain.UserID) <-chan domain.AppspaceID
		Unsubscribe(ch <-chan domain.AppspaceID)
	} `checkinject:"required"`
	MigrationJobEvents interface {
		SubscribeOwner(domain.UserID) <-chan domain.MigrationJob
		Unsubscribe(ch <-chan domain.MigrationJob)
	} `checkinject:"required"`
	AppGetterEvents interface {
		SubscribeOwner(domain.UserID) <-chan domain.AppGetEvent
		Unsubscribe(ch <-chan domain.AppGetEvent)
	} `checkinject:"required"`
	UserModel interface {
		GetFromID(userID domain.UserID) (domain.User, error)
		UpdateEmail(userID domain.UserID, email string) 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 Versions struct {
	AppVersions []domain.AppVersionUI `json:"app_versions"`
}