core

type BatchableOptions interface {
	GetBatchSize() int
}

type CSVStreamOptions struct {
	// CSV separator symbol
	Comma rune
	// Decoder, defaults to UTF-8
	Decoder *encoding.Decoder
	// Number of rows at the beginning of file that do not contain data
	HeaderHeight int
	// Number of colums. If a row contains different number of columns, the stream will stop with error
	// For header rows this is ignored
	NumColumns int
	// Extra HTTPClient options
	*RequestOptions
}

type ClientOptions struct {
	UserAgent  string `desc:"User agent for requests sent from scripts. Leave empty to use fake browser agent"`
	Timeout    int64  `desc:"Request timeout in seconds"`
	WithoutTLS bool   `desc:"Disable TLS for some gauges"`
	Proxy      string `desc:"HTTP client proxy (for example, you can use mitm for local development)"`
}

type CodesFilter struct {
	Codes StringSet
}

type Doc struct {
	*goquery.Document
	// contains filtered or unexported fields
}

type Error struct {
	Err error                  `json:"-"`
	Msg string                 `json:"error"`
	Ctx map[string]interface{} `json:"-"`
}

type ErrorResponse struct {
	*Error
	HTTPStatusCode int    `json:"-"`
	StatusText     string `json:"status,omitempty"` // user-level status message
	ReqID          string `json:"request_id,omitempty"`
}

type ErrorType int

type Gauge struct {
	GaugeID
	Name string `json:"name"`
	// This is webpage URL from original source
	URL string `json:"url,omitempty"`
	// Water level unit, e.g, "m"/"ft"/"cm"
	LevelUnit string `json:"levelUnit,omitempty"`
	// Water flow/discharge unit, e.g. "cfs"/"m3/s"
	FlowUnit string `json:"flowUnit,omitempty"`
	// Station location, if known
	Location *Location `json:"location,omitempty"`
}

type GaugeID struct {
	// id of script from gorge's script registry
	Script string `json:"script"`
	// unique gauge code from upstream
	// if no code is provided (ex. Georgia) script must generate it's own stable unique codes
	Code string `json:"code"`
}

type Gauges []Gauge

type HTTPClient struct {
	*http.Client
	PersistentJar *jar.Jar
	UserAgent     string
	// contains filtered or unexported fields
}

type HTime struct {
	time.Time
}

type HarvestMode int

type JobDescription struct {
	// UUID. Represents paired entity id in client's service and are generated on client side
	ID string `json:"id" structs:"id"`
	// id of script from gorge's script registry
	Script string `json:"script" structs:"script"`
	// a map with keys being gauge codes and value being pieces of json representing harvest options for that gauge
	// pass `{}` or `null` if no options are given for the gauge
	Gauges map[string]json.RawMessage `json:"gauges" structs:"codes" ts_type:"{[key: string]: any} | null"`
	// cron expression, ignored for OneByOne scripts. AllAtOnce script will run on this cron schedule
	Cron string `json:"cron" structs:"cron"`
	// harvest options for the entire script. For example, upstream credentials
	Options json.RawMessage `json:"options" structs:"options,omitempty" ts_type:"{[key: string]: any} | null"`
	// When used as input this must be nil
	Status *Status `json:"status,omitempty"`
}

type JobScheduler interface {
	Start()
	Stop()
	AddJob(description JobDescription) error
	DeleteJob(jobID string) error
	// ListNext returns map where values are times when scripts will run next time
	// If jobID is empty, ListNext lists next times for all running scripts. And map keys are script ids
	// If jobID is not empty, this will return next times for all codes of this one-by-one job, and map keys are gauge codes
	ListNext(jobID string) map[string]HTime
}

type LatestFilter struct {
	Latest map[GaugeID]Measurement
	After  time.Time
}

type Location struct {
	Latitude  float64 `json:"latitude"`
	Longitude float64 `json:"longitude"`
	Altitude  float64 `json:"altitude,omitempty"`
}

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

type Measurement struct {
	GaugeID
	Timestamp HTime `json:"timestamp" ts_type:"string"`
	// Level is null when gauge doesn't provide it or is temporary broken
	Level nulltype.NullFloat64 `json:"level" ts_type:"number | null"`
	// Flow is null when gauge doesn't provide it or is temporary broken
	Flow nulltype.NullFloat64 `json:"flow" ts_type:"number | null"`
}

type Measurements []*Measurement

type MeasurementsFactory struct {
	Time   time.Time
	Script string
	Code   string
	Value  float64
}

type MeasurementsFilter interface {
	// contains filtered or unexported methods
}

type RequestOptions struct {
	// When set to true, requests will be sent with random user-agent
	FakeAgent bool
	// Headers to set on request
	Headers map[string]string
	// Request will not save cookies
	SkipCookies bool
}

type Script interface {
	ListGauges() (Gauges, error)
	// Harvests measurements from upstream and writes them to recv channel, then closes both channels.
	// If unrecoverable error happens during this process, writes it into errs channel and closes both channels.
	// codes are set of gauge codes to harvest from upstream. It's meant to be passed to upstream. The script itself should not make use of it.
	// since is the last timestamp (usually for one-by-one scripts) that is meannt to be passed to upstream. The script itself should not make use of it.
	Harvest(ctx context.Context, recv chan<- *Measurement, errs chan<- error, codes StringSet, since int64)
	SetLogger(logger *logrus.Entry)
	GetLogger() *logrus.Entry
}

type ScriptDescriptor struct {
	Name string `json:"name"`
	// Description is human-readable name of data source, something that you can google
	Description    string             `json:"description"`
	Mode           HarvestMode        `json:"mode"`
	DefaultOptions func() interface{} `json:"-"`
	Factory        ScriptFactory      `json:"-"`
}

type ScriptFactory func(name string, options interface{}) (Script, error)

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

type Status struct {
	Success bool `json:"success"`
	// When job was executed last time (has nothing to do wuth measurements timestamps)
	Timestamp HTime `json:"timestamp" ts_type:"string"`
	// Error, if last time job failed
	Error string `json:"error,omitempty"`
	// Number of harvested measurements
	Count int `json:"count"`
	// When this job will run next time
	Next *HTime `json:"next,omitempty" ts_type:"string"`
}

type StringSet map[string]struct{}