adminapi

type ChannelStatus struct {
	// Known is false until the channel was probed once.
	Known     bool
	Reachable bool
	Since     time.Time
	RTT       time.Duration
	LastError string
}

type ClientDownloads interface {
	Release(ctx context.Context) clientdl.Result
	Open(ctx context.Context, id string) (*os.File, clientdl.Asset, error)
}

type CommandAudit struct {
	Store *store.Store
	Log   *slog.Logger
}

type Deps struct {
	Log     *slog.Logger
	Config  *config.Config
	Store   *store.Store
	AEAD    *crypto.AEAD
	JWT     *auth.ClientJWT
	Hasher  *auth.Hasher
	Limiter auth.Limiter
	Metrics prometheus.Registerer

	// LDAP manages directory synchronization and corporate authentication (nil: disabled).
	LDAP *ldap.Service
	// WebSessions issues web client session ids bound to panel users (nil: none).
	WebSessions *websessions.Registry
	// OIDC runs provider flows (nil disables OIDC login/linking).
	OIDC *oidc.Service
	// TOTP verifies second factors (default: NewTOTPService(Store, AEAD)).
	TOTP *TOTPService
	// Mail sends e-mail codes and reset links (default: mailauth.New over
	// Store, AEAD and Config).
	Mail *mailauth.Service
	// LoginEvents records login attempts (default: loginlog.DB on Store).
	LoginEvents loginlog.Recorder
	// Telemetry counts login attempts (nil: no metrics).
	Telemetry *metrics.Panel

	// Presence reads live device presence (nil: hbbs integration disabled,
	// presence falls back to "heartbeat within 45 s").
	Presence PresenceReader
	// Servers reports the hbbs/hbbr admin channels (nil: unknown).
	Servers ServerStatusReader
	// Kicks queues heartbeat "disconnect" requests (clientapi.KickQueue).
	Kicks DeviceKicker
	// Events publishes live events such as device.updated (nil: none).
	Events EventPublisher
	// DeviceRate is the effective per-IP limit of the unauthenticated device
	// endpoints (shown read-only in /settings).
	DeviceRate DeviceRateInfo
	// ---- stream B2b: address books, audit, server (hbbs/hbbr) ----
	// PresenceSrc is the live device presence (nil: devices report offline and
	// /server/health reports the heartbeat fallback).
	PresenceSrc PresenceSource
	// Control is the hbbs/hbbr admin channel (nil: hbbs-backed /server/*
	// endpoints answer 503 server_unavailable).
	Control ServerControl
	// Reconciler owns the desired hbbs/hbbr settings (nil: /server/settings 503).
	Reconciler SettingsReconciler
	// Relays manages relays and relay agents (nil: /relays/* answer 503).
	Relays RelayManager
	// Federation manages peering and federated relays (nil: /federation/* answer 503).
	Federation *federation.Service
	// ClientOptions are the client options pushed in heartbeats (default:
	// clientopts.New over Store and AEAD; the app shares one with clientapi).
	ClientOptions *clientopts.Service
	// ConsoleLimit caps raw console commands per admin per minute (default 30).
	ConsoleLimit int
	// Logs is the recent log lines buffer behind /server/logs* (nil or
	// capacity 0: the endpoints report the buffer as disabled).
	Logs *logs.Buffer
	// LogSources are the sources the Logs page always lists (with 0 lines).
	LogSources []string
	// LogCapture is LogCaptureFiles or LogCapturePanel (default).
	LogCapture string

	// ---- About page (GET /about) ----
	// StartedAt is the process start (uptime); zero = when Register ran.
	StartedAt time.Time
	// Schema reports the applied and the newest embedded migration (nil: unknown).
	Schema SchemaInfo
	// Updates looks up the latest release (nil: the update check is disabled).
	Updates UpdateChecker

	// Clients backs the "Install client" page (nil: client downloads are
	// disabled; the page then offers only the settings).
	Clients ClientDownloads
}

type DeviceKicker interface {
	Kick(rustdeskID string, connIDs ...int32)
}

type DeviceRateInfo struct {
	Rate  float64
	Burst int
}

type EventPublisher interface {
	Publish(t events.Type, data any, aud events.Audience)
}

type IdentityDTO struct {
	ID            int64      `json:"id"`
	ProviderID    int64      `json:"provider_id"`
	ProviderSlug  string     `json:"provider_slug"`
	ProviderKind  string     `json:"provider_kind"`
	ProviderName  string     `json:"provider_name"`
	Subject       string     `json:"subject"`
	Email         *string    `json:"email"`
	EmailVerified bool       `json:"email_verified"`
	Username      *string    `json:"username"`
	DisplayName   string     `json:"display_name"`
	AvatarURL     string     `json:"avatar_url"`
	LastLoginAt   *time.Time `json:"last_login_at"`
	CreatedAt     time.Time  `json:"created_at"`
}

type PasskeyDTO struct {
	ID             int64      `json:"id"`
	Name           string     `json:"name"`
	CreatedAt      time.Time  `json:"created_at"`
	LastUsedAt     *time.Time `json:"last_used_at"`
	BackupEligible bool       `json:"backup_eligible"`
	Synced         bool       `json:"synced"`
	CloneWarning   bool       `json:"clone_warning"`
	Transports     []string   `json:"transports"`
}

type PresenceHealth struct {
	// Polls counts poll cycles since start (0 = no observation yet).
	Polls     uint64
	Reachable bool
	// Since is when Reachable last changed.
	Since time.Time
	// LastOK is the last successful poll.
	LastOK    time.Time
	RTT       time.Duration
	LastError string
}

type PresenceReader interface {
	// OnlineIDs returns the RustDesk IDs currently online.
	OnlineIDs() []string
	// DevicePresence returns the state of one device; known is false when the
	// poller has not observed it yet.
	DevicePresence(rustdeskID string) (online bool, since time.Time, known bool)
	PresenceHealth() PresenceHealth
}

type PresenceSource interface {
	IsOnline(rustdeskID string) bool
	Health() presence.Health
}

type ProviderDTO struct {
	ID                  int64     `json:"id"`
	Slug                string    `json:"slug"`
	Kind                string    `json:"kind"`
	DisplayName         string    `json:"display_name"`
	ClientID            string    `json:"client_id"`
	HasClientSecret     bool      `json:"has_client_secret"`
	Issuer              *string   `json:"issuer"`
	Scopes              []string  `json:"scopes"`
	PKCEEnabled         bool      `json:"pkce_enabled"`
	PKCEMethod          string    `json:"pkce_method"`
	AutoRegister        bool      `json:"auto_register"`
	LinkByVerifiedEmail bool      `json:"link_by_verified_email"`
	Enabled             bool      `json:"enabled"`
	SortOrder           int       `json:"sort_order"`
	CallbackURL         string    `json:"callback_url"`
	CreatedAt           time.Time `json:"created_at"`
	UpdatedAt           time.Time `json:"updated_at"`
}

type RelayManager interface {
	List(ctx context.Context) ([]relays.View, relays.Rotation, error)
	Get(ctx context.Context, id int64) (relays.View, error)
	Observed(ctx context.Context) ([]string, error)
	Create(ctx context.Context, in relays.CreateInput) (relays.View, *relays.Enrollment, error)
	Update(ctx context.Context, id int64, p relays.Patch) (relays.View, error)
	Delete(ctx context.Context, id int64) error
	ResetEnrollment(ctx context.Context, id int64) (*relays.Enrollment, error)
	Approve(ctx context.Context, id int64, by *int64) (relays.View, error)
	Revoke(ctx context.Context, id int64) (relays.View, error)
	ProbeNow(ctx context.Context, id int64) (relays.View, error)
	Settings(ctx context.Context, id int64) (relays.SettingsView, error)
	SaveSettings(ctx context.Context, id int64, ov reconcile.Settings, by *int64) (relays.SettingsView, error)
	Usage(ctx context.Context, id int64) ([]control.RelayUsage, error)
	Traffic(ctx context.Context, id int64, since time.Time) ([]relays.TrafficSample, error)
	GetOptions(ctx context.Context) (relays.Options, error)
	SetOptions(ctx context.Context, o relays.Options, by *int64) error
	HBBSKeyFingerprint() string
	ListPrefixRules(ctx context.Context) ([]relays.PrefixRule, error)
	CreatePrefixRule(ctx context.Context, rule *relays.PrefixRule) error
	DeletePrefixRule(ctx context.Context, id int64) error
	ImportCountryRules(ctx context.Context, countryCode, relayHost, customComment string) (*relays.ImportCountryRulesResult, error)
	GeoIP() *relays.GeoIPEngine
}

type SchemaInfo interface {
	SchemaVersion(ctx context.Context) (int64, error)
	LatestSchemaVersion() (int64, error)
}

type ServerControl interface {
	Addr(t control.Target) string
	ExecLine(ctx context.Context, t control.Target, line string) (string, error)
	IPBlocker(ctx context.Context, start int) (control.IPBlockerPage, error)
	IPBlockerLookup(ctx context.Context, ip string, remove bool) (*control.IPBlockerEntry, error)
	IPChanges(ctx context.Context, start int) (control.IPChangesPage, error)
	IPChangesLookup(ctx context.Context, id string, remove bool) (*control.IPChange, error)
	Usage(ctx context.Context) ([]control.RelayUsage, error)
}

type ServerHealthDTO struct {
	HBBS           componentHealthDTO `json:"hbbs"`
	HBBR           componentHealthDTO `json:"hbbr"`
	Presence       presenceHealthDTO  `json:"presence"`
	SettingsInSync *bool              `json:"settings_in_sync,omitempty"`
}

type ServerStatusReader interface {
	ChannelStatus() (hbbs, hbbr ChannelStatus)
	// SettingsInSync reports whether every desired setting was applied.
	SettingsInSync(ctx context.Context) (bool, error)
}

type SessionInfo struct {
	Token *store.AuthToken
	User  *store.User
	// MFAPending: password accepted, TOTP/recovery code still owed.
	MFAPending bool
	// TOTPEnabled: the user has confirmed TOTP.
	TOTPEnabled bool
	// MustEnrollTOTP: policy requires 2FA but the user has not enrolled; only
	// the auth and "my security" endpoints are reachable.
	MustEnrollTOTP bool
	// APIToken is set when the request authenticated with a personal API
	// token (Authorization: Bearer rdp_...) instead of the session cookie.
	// Token is then a placeholder with ID 0 that matches no auth_tokens row.
	APIToken *store.APIToken
}

type SettingsReconciler interface {
	Status() reconcile.Status
	Desired(ctx context.Context) (reconcile.Settings, error)
	KeyStatus(ctx context.Context) ([]reconcile.KeyStatus, error)
	Current(ctx context.Context) (reconcile.Observed, error)
	Apply(ctx context.Context, s reconcile.Settings, updatedBy *int64) error
	Reconcile(ctx context.Context) error
}

type TOTPService struct {
	// contains filtered or unexported fields
}

type UpdateChecker interface {
	Latest(ctx context.Context) updatecheck.Result
}

type UserDTO struct {
	ID              int64      `json:"id"`
	Username        string     `json:"username"`
	Email           *string    `json:"email"`
	DisplayName     string     `json:"display_name"`
	AvatarURL       string     `json:"avatar_url"`
	Note            string     `json:"note"`
	Role            store.Role `json:"role"`
	Status          string     `json:"status"`
	UserGroupID     *int64     `json:"user_group_id"`
	HasPassword     bool       `json:"has_password"`
	TOTPEnabled     bool       `json:"totp_enabled"`
	TOTPRequired    bool       `json:"totp_required"`
	EmailVerified   bool       `json:"email_verified"`
	Email2FAEnabled bool       `json:"email_2fa_enabled"`
	IsLDAP          bool       `json:"is_ldap"`
	LastLoginAt     *time.Time `json:"last_login_at"`
	CreatedAt       time.Time  `json:"created_at"`
	UpdatedAt       time.Time  `json:"updated_at"`
}