schedules

type Artifact struct {
	Path        string
	ContentType string
	Filename    string
	Content     []byte
}

type ArtifactStore interface {
	Save(ctx context.Context, schedule, runID string, artifact Artifact) (Artifact, error)
}

type Deliverer interface {
	Deliver(ctx dbcontext.Context, schedule Schedule, artifact Artifact) ([]DeliveryResult, error)
}

type DelivererOptions struct {
	// BaseURL is the externally reachable root of this server, used to build
	// the artifact links non-SMTP channels receive.
	BaseURL string
}

type DeliveryResult struct {
	Connection string    `json:"connection"`
	Channel    string    `json:"channel,omitempty"`
	Sent       bool      `json:"sent"`
	Attached   bool      `json:"attached,omitempty"`
	Error      string    `json:"error,omitempty"`
	At         time.Time `json:"at"`
}

type DeliverySpec struct {
	Connection string `json:"connection" yaml:"connection"`

	Title   string `json:"title,omitempty" yaml:"title,omitempty"`
	Message string `json:"message,omitempty" yaml:"message,omitempty"`

	// Attach embeds the rendered report in the message. Only SMTP carries
	// attachments; every other channel gets a link to the stored artifact, and
	// asking for an attachment on one is refused rather than silently dropped.
	Attach bool `json:"attach,omitempty" yaml:"attach,omitempty"`

	// Properties are per-channel overrides, using the same `channel.key` prefix
	// convention the notification senders read.
	Properties map[string]string `json:"properties,omitempty" yaml:"properties,omitempty"`
}

type Duration time.Duration

type FacetSpec struct {
	Connection   string   `json:"connection,omitempty" yaml:"connection,omitempty"`
	URL          string   `json:"url,omitempty" yaml:"url,omitempty"`
	Timeout      Duration `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Header       string   `json:"header,omitempty" yaml:"header,omitempty"`
	Footer       string   `json:"footer,omitempty" yaml:"footer,omitempty"`
	TimestampURL string   `json:"timestampUrl,omitempty" yaml:"timestampUrl,omitempty"`
}

type Options struct {
	Store      StoreProvider
	Scheduler  *task.Scheduler
	DecodeBody profiles.BodyDecoder

	// Runner and Deliverer power the trigger and test-delivery actions. Both
	// are optional; without them those actions refuse rather than pretend.
	Runner    *Runner
	Deliverer Deliverer

	// Context supplies the database-backed context delivery needs to resolve
	// connections and their secrets.
	Context func() dbcontext.Context
}

type PauseFlags struct{}

type QuerySpec struct {
	Profile string            `json:"profile" yaml:"profile"`
	Params  map[string]string `json:"params,omitempty" yaml:"params,omitempty"`

	// Limit caps the rows read. Zero uses the profile's own export ceiling —
	// a scheduled report has no user watching to stop a runaway read.
	Limit int `json:"limit,omitempty" yaml:"limit,omitempty"`
}

type ReconcileSpec struct {
	Profile                 string `json:"profile" yaml:"profile"`
	profiles.ReconcileFlags `yaml:",inline"`
}

type ReportSpec struct {
	Title  string `json:"title,omitempty" yaml:"title,omitempty"`
	Format string `json:"format" yaml:"format"`

	// Template selects the TSX entry file for the facet formats. Empty uses the
	// embedded default.
	Template  string            `json:"template,omitempty" yaml:"template,omitempty"`
	Variables map[string]string `json:"variables,omitempty" yaml:"variables,omitempty"`

	Facet *FacetSpec `json:"facet,omitempty" yaml:"facet,omitempty"`
}

type Reporter interface {
	Render(ctx dbcontext.Context, spec ReportSpec, result *query.Result, columns []query.ColumnDef) ([]byte, error)
}

type Run struct {
	ID           string            `json:"id" pretty:"label=ID"`
	Schedule     string            `json:"schedule,omitempty" pretty:"label=Schedule"`
	Name         string            `json:"name" pretty:"label=Name"`
	Kind         string            `json:"kind,omitempty" pretty:"label=Kind"`
	Status       string            `json:"status" pretty:"label=Status"`
	Total        int               `json:"total" pretty:"label=Tasks"`
	Completed    int               `json:"completed" pretty:"label=Completed"`
	Failed       int               `json:"failed" pretty:"label=Failed"`
	Labels       map[string]string `json:"labels,omitempty"`
	Owner        string            `json:"owner,omitempty"`
	ArtifactPath string            `json:"artifactPath,omitempty" pretty:"label=Artifact"`
	Delivery     []DeliveryResult  `json:"delivery,omitempty"`
	StartedAt    *time.Time        `json:"startedAt,omitempty" pretty:"label=Started"`
	FinishedAt   *time.Time        `json:"finishedAt,omitempty" pretty:"label=Finished"`
}

type RunFilter struct {
	Schedule string
	Kind     string
	Status   string
	Labels   map[string]string
	Limit    int
}

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

type RunnerOptions struct {
	Store     StoreProvider
	Profiles  profiles.StoreProvider
	Context   func() dbcontext.Context
	Reconcile *profiles.Service
	Reporter  Reporter
	Deliverer Deliverer
	Artifacts ArtifactStore

	// BeforeExecute, when set, prepares a scheduled query's data before it is
	// read — the same hook the profile service runs, so a scheduled read and a
	// hand-run one see the same data. The reconcile mode runs it through
	// Reconcile, the profile service's own.
	BeforeExecute profiles.BeforeExecuteFunc
}

type Schedule struct {
	Name      string `json:"name" yaml:"name" clicky:"title=Name,order=1"`
	Namespace string `json:"namespace,omitempty" yaml:"namespace,omitempty" clicky:"title=Namespace,order=2"`

	// Cron is a five-field spec or a descriptor ("@daily", "@every 30m").
	Cron     string `json:"cron" yaml:"cron" clicky:"type=cron,title=Schedule,order=3"`
	Timezone string `json:"timezone,omitempty" yaml:"timezone,omitempty" clicky:"title=Timezone,order=4"`
	Enabled  bool   `json:"enabled" yaml:"enabled" clicky:"title=Enabled,order=5"`

	// Overlap and CatchUp are per-schedule because there is no answer that is
	// right for both a cheap probe and an expensive report.
	Overlap string   `json:"overlap,omitempty" yaml:"overlap,omitempty" clicky:"title=On overlap,order=6"`
	CatchUp string   `json:"catchUp,omitempty" yaml:"catchUp,omitempty" clicky:"title=On missed runs,order=7"`
	Timeout Duration `json:"timeout,omitempty" yaml:"timeout,omitempty" clicky:"title=Timeout,order=8"`

	// Exactly one of Query and Reconcile says what the schedule runs.
	Query     *QuerySpec     `json:"query,omitempty" yaml:"query,omitempty"`
	Reconcile *ReconcileSpec `json:"reconcile,omitempty" yaml:"reconcile,omitempty"`

	Report  *ReportSpec    `json:"report,omitempty" yaml:"report,omitempty"`
	Deliver []DeliverySpec `json:"deliver,omitempty" yaml:"deliver,omitempty"`

	Labels map[string]string `json:"labels,omitempty" yaml:"labels,omitempty"`
	Owner  string            `json:"owner,omitempty" yaml:"owner,omitempty"`

	LastRun *time.Time `json:"lastRun,omitempty" yaml:"-"`
	NextRun *time.Time `json:"nextRun,omitempty" yaml:"-"`
}

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

type SnapshotFlags struct{}

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

type StoreProvider func() (*Store, error)

type TestDeliveryFlags struct {
	Message string `flag:"message" help:"Body of the test message"`
}

type TriggerFlags struct {
	Wait bool `flag:"wait" help:"Block until the run finishes instead of returning its id"`
}

type TriggerResult struct {
	Schedule string     `json:"schedule" pretty:"label=Schedule"`
	RunID    string     `json:"runId" pretty:"label=Run"`
	Status   string     `json:"status" pretty:"label=Status"`
	Rows     int        `json:"rows,omitempty" pretty:"label=Rows"`
	Artifact string     `json:"artifact,omitempty" pretty:"label=Artifact"`
	Error    string     `json:"error,omitempty" pretty:"label=Error"`
	Started  time.Time  `json:"startedAt" pretty:"label=Started"`
	Finished *time.Time `json:"finishedAt,omitempty" pretty:"label=Finished"`
}