worker

type Check struct {
	ID          string
	AccountID   int64
	Folder      string
	Since       int64   // 0 = all mail
	Limit       int     // 0 = no limit
	RuleIDs     []int64 // the rules the check was limited to; nil = every enabled rule (MAI-43)
	RouteOnly   []int64 // the unpicked rules a sender rule routed to as the check began
	Fingerprint string
	StartedAt   int64
	// contains filtered or unexported fields
}

type CheckFunc func(ctx context.Context, report func(composer.CheckProgress)) ([]composer.CheckRow, error)

type CheckState struct {
	ID          string
	AccountID   int64
	Folder      string
	Since       int64
	Limit       int
	RuleIDs     []int64 // nil = every enabled rule
	RouteOnly   []int64 // the unpicked rules a sender rule routed to as the check began
	Fingerprint string
	Status      string
	Done        int
	Total       int
	Matched     int // emails in the chosen range before the limit; more than Total when it cut the range
	ModelCalls  int
	Tokens      int
	CostUSD     float64
	Error       string
	Rows        []composer.CheckRow
	// Exclude is the saved selection: the unticked selectable row indices, ascending. It
	// lives only as long as the check (MAI-44) and is never written anywhere else.
	Exclude []int
}

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

type Cleanup struct {
	AccountID int64
	Folder    string
	Since     time.Time // only mail received from this time on; zero = all of it
	Limit     int       // only the newest Limit emails; 0 = no limit
	// RuleIDs limits the check to these rules, checked in their usual order; nil = every
	// enabled rule. Sender rules apply either way (MAI-43).
	RuleIDs []int64
	// RouteOnly are the rules outside RuleIDs that a sender rule routed mail to when the
	// check began; nil when every rule is checked. A check stays in step with their content.
	RouteOnly []int64
}

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

type PlanEnd struct {
	Store *store.Store
	// Stop stops an account's supervisor and waits until it has; stopping one that is not
	// running does nothing. Start starts one again, for a mailbox stopped as a plan was
	// bought at that moment (ext.Host.SetPlan starts them once the plan is stored, which may
	// be just before the job stopped them).
	Stop  func(accountID int64)
	Start func(store.Account)
	Hub   *events.Hub // tells the tenant's open screens its mailboxes lost their secrets; may be nil
	// Sender sends the warnings (the summary email's mail server); the daemon does not start
	// a build that sells plans without one. A warning that reaches no member is not recorded
	// and is tried again next tick, so no deletion comes before a warning was delivered.
	Sender    mailer.Sender
	PublicURL string           // where links in the warnings lead (MAILRULES_PUBLIC_URL)
	Now       func() time.Time // nil = time.Now
	Every     time.Duration    // 0 = every minute
}

type Removal struct {
	Store *store.Store
	// Stop stops an account's supervisor and waits until it has; Start starts one again,
	// for a mailbox whose removal did not happen after all (the person signed in again
	// between the two).
	Stop  func(accountID int64)
	Start func(store.Account)
	Hub   *events.Hub      // tells the team's open screens when its rules were rewritten; may be nil
	Now   func() time.Time // nil = time.Now
	Every time.Duration    // 0 = hourly
}

type Retention struct {
	Store *store.Store
	Days  func(ctx context.Context, tenantID int64) int // the tenant's retention_days setting in force
	Now   func() time.Time                              // nil = time.Now
	Every time.Duration                                 // 0 = hourly
}

type SortRun struct {
	AccountID int64
	Folder    string
	Since     int64 // only mail received from this time on; 0 = all of it. Recorded on the batch.
	// Limit and Matched are the check's: the most emails it covered and how many the range
	// held before that cut. Recorded on the batch, so it can say what it covered (MAI-48).
	Limit, Matched int
	Rows           []composer.CheckRow
}

type Supervisor struct {
	Account store.Account
	Store   *store.Store
	Hub     *events.Hub
	// Open connects to the account's server. It is called again after a failure.
	Open func(ctx context.Context) (mail.Mailbox, error)
	// Pipeline is the template for the account's pipeline; the supervisor fills in
	// Mailbox, Account and Rediscover.
	Pipeline pipeline.Pipeline
	// Moves, when set, looks through the account's filed mail for emails the person moved
	// outside MailRules (moved.Watcher.Sweep), every MovesEvery, on the account's connection
	// and between two emails, like the retry job. nil (the free build) = never.
	Moves      func(ctx context.Context, mb mail.Mailbox, acct store.Account) error
	MovesEvery time.Duration // 0 = 10 minutes

	// Timers. Zero means the default; tests shrink them.
	RetryEvery    time.Duration // the retry job (pipeline.RetryEvery)
	ContactsEvery time.Duration // the Sent-folder rescan (6 h)
	DrainTimeout  time.Duration // how long queued mail may take to finish at shutdown (10 s)
	BackoffMin    time.Duration // first reconnect delay (1 s), doubling up to BackoffMax (5 min)
	BackoffMax    time.Duration
	// contains filtered or unexported fields
}