workerapi

type CheckLoginPayload struct {
	Login Login `json:"login"`
}

type CheckLoginResult struct {
	LoginOK bool   `json:"login_ok"`
	Message string `json:"message,omitempty"`
}

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

type Completion struct {
	// Outcome is "ok", "retry" (a temporary problem) or "fail" (a permanent one).
	Outcome string          `json:"outcome"`
	Result  json.RawMessage `json:"result,omitempty"`
	// Error is a short sentence for the administrator and, for some kinds, the person. It must not
	// contain a credential.
	Error string `json:"error,omitempty"`
	// RetryAfterSeconds is the provider's own request to wait (Retry-After); the backend never
	// retries sooner than its own backoff, and never later than its cap.
	RetryAfterSeconds int `json:"retry_after_seconds,omitempty"`
}

type Config struct {
	Generation int64 `json:"generation"`
	// LeaseSeconds is how long a lease lasts without a heartbeat; the worker renews at a third of it.
	LeaseSeconds int `json:"lease_seconds"`
	// Kinds holds the settings of each kind. A kind that is missing is disabled.
	Kinds map[string]KindConfig `json:"kinds"`
}

type ConnectPayload struct {
	App  OAuthApp `json:"app"`
	Code string   `json:"code"`
}

type Credentials struct {
	Data json.RawMessage `json:"data"`
}

type ExportEntry struct {
	Day      string   `json:"day"` // YYYY-MM-DD
	WeightKg float64  `json:"weight_kg"`
	FatPct   *float64 `json:"fat_pct,omitempty"` // nil when the day has no body fat estimate
}

type ExportPayload struct {
	Login Login `json:"login"`
	// Entries are the days to send, newest first.
	Entries []ExportEntry `json:"entries"`
	// Since limits a sync to entries from this day on (YYYY-MM-DD; empty: all of them).
	Since string `json:"since,omitempty"`
	// Update also changes days that exist at the service with other values. Without it they are
	// left as they are. Nothing is ever deleted.
	Update bool `json:"update,omitempty"`
}

type ExportProgress struct {
	Done  int `json:"done"`
	Total int `json:"total"`
}

type ExportResult struct {
	Added     int `json:"added"`
	Updated   int `json:"updated"`
	Unchanged int `json:"unchanged"` // already at the service with the same values (or left alone)
	Failed    int `json:"failed"`    // days that could not be written
	// FailedMessages are a few of the reasons, for the log.
	FailedMessages []string `json:"failed_messages,omitempty"`
}

type Heartbeat struct {
	Progress json.RawMessage `json:"progress,omitempty"`
}

type HeartbeatAnswer struct {
	// Cancel: somebody canceled the job. Stop, and report the attempt as retry.
	Cancel bool `json:"cancel"`
}

type ImportPayload struct {
	App OAuthApp `json:"app"`
	// Credentials are what the user's connection stored, as the provider's worker wrote them (an
	// OAuth token pair for example). They are opaque to the backend. A worker that renews them hands
	// the new ones over with SaveCredentials before it uses them.
	Credentials json.RawMessage `json:"credentials"`
	// Since limits a bulk import to measurements at or after this time (zero: everything).
	Since time.Time `json:"since,omitempty"`
	// Day, when set (YYYY-MM-DD), asks for exactly that calendar day in the user's time zone Zone.
	Day string `json:"day,omitempty"`
	// Zone is the user's IANA time zone; it decides where a calendar day begins and ends.
	Zone string `json:"zone,omitempty"`
}

type ImportResult struct {
	// Readings are the measurements, with Source set to the provider's name and ExternalID to the
	// provider's id of the measurement, which makes repeated imports idempotent.
	Readings []models.ScaleReading `json:"readings"`
	// Seen are the ids of every measurement the provider returned, including the ones left out of
	// Readings (a guest on the scale), so a day import never deletes a reading only because it is
	// filtered out now.
	Seen []string `json:"seen,omitempty"`
}

type Job struct {
	ID          string `json:"id"`
	Kind        string `json:"kind"`
	UserID      int64  `json:"user_id"`
	Attempt     int    `json:"attempt"`
	MaxAttempts int    `json:"max_attempts"`
	// Payload is what the handler of the kind needs: its parameters and the credentials the
	// backend decided to hand over for this one job. Never log it.
	Payload json.RawMessage `json:"payload"`
}

type KindConfig struct {
	Enabled bool `json:"enabled"`
	// Options are provider specific values, such as a pause between requests. See each provider.
	Options map[string]string `json:"options,omitempty"`
}

type Lease struct {
	Job Job `json:"job"`
	// Token goes into HeaderLease of every later call about the job.
	Token string `json:"token"`
	// TimeoutSeconds is the hard limit of this attempt. The backend ends the attempt itself when
	// it passes, whatever the worker does.
	TimeoutSeconds int `json:"timeout_seconds"`
	LeaseSeconds   int `json:"lease_seconds"`
}

type LeaseRequest struct {
	Worker      string   `json:"worker"`
	Kinds       []string `json:"kinds"`
	WaitSeconds int      `json:"wait_seconds"`
}

type Login struct {
	Email    string `json:"email"`
	Password string `json:"password"`
}

type OAuthApp struct {
	ClientID     string `json:"client_id"`
	ClientSecret string `json:"client_secret"`
	RedirectURL  string `json:"redirect_url"`
}

type RegisterRequest struct {
	ID      string   `json:"id"` // unique per process, chosen by the worker
	Version string   `json:"version"`
	Kinds   []string `json:"kinds"`
}