core

type ApiResourceHandler func(input *ApiResourceInput) (*ApiResourceOutput, error)

type ApiResourceInput struct {
	Params  map[string]string      // path variables
	Query   url.Values             // query string
	Body    map[string]interface{} // json body
	Request *http.Request
}

type ApiResourceOutput struct {
	Body   interface{} // response body
	Status int
	File   *OutputFile
}

type BasicRes interface {
	GetConfig(name string) string
	GetLogger() Logger
	// Deprecated: use dal instead
	GetDb() *gorm.DB
	GetDal() dal.Dal
}

type BlueprintConnectionV100 struct {
	Plugin       string                `json:"plugin" validate:"required"`
	ConnectionId uint64                `json:"connectionId" validate:"required"`
	Scope        []*BlueprintScopeV100 `json:"scope" validate:"required"`
}

type BlueprintScopeV100 struct {
	Entities       []string        `json:"entities"`
	Options        json.RawMessage `json:"options"`
	Transformation json.RawMessage `json:"transformation"`
}

type CloseablePluginTask interface {
	PluginTask
	Close(taskCtx TaskContext) error
}

type ConfigGetter interface {
	GetString(name string) string
}

type ExecContext interface {
	BasicRes
	GetName() string
	GetContext() context.Context
	GetData() interface{}
	SetProgress(current int, total int)
	IncProgress(quantity int)
}

type InjectConfigGetter interface {
	SetConfigGetter(getter ConfigGetter)
}

type InjectLogger interface {
	SetLogger(logger Logger)
}

type LogLevel logrus.Level

type Logger interface {
	IsLevelEnabled(level LogLevel) bool
	Printf(format string, a ...interface{})
	Log(level LogLevel, format string, a ...interface{})
	Debug(format string, a ...interface{})
	Info(format string, a ...interface{})
	Warn(format string, a ...interface{})
	Error(format string, a ...interface{})
	// return a new logger which output nested log
	Nested(name string) Logger
}

type Migratable interface {
	MigrationScripts() []migration.Script
}

type OutputFile struct {
	ContentType string
	Data        []byte
}

type PipelinePlan []PipelineStage

type PipelineStage []*PipelineTask

type PipelineTask struct {
	// Plugin name
	Plugin   string                 `json:"plugin" binding:"required"`
	Subtasks []string               `json:"subtasks"`
	Options  map[string]interface{} `json:"options"`
}

type PluginApi interface {
	ApiResources() map[string]map[string]ApiResourceHandler
}

type PluginBlueprintV100 interface {
	// MakePipelinePlan generates `pipeline.tasks` based on `version` and `scope`
	//
	// `version` semver from `blueprint.settings.version`
	// `scope` arbitrary json.RawMessage, depends on `version`, for v0.0.1, it is an Array of Objects
	MakePipelinePlan(connectionId uint64, scope []*BlueprintScopeV100) (PipelinePlan, error)
}

type PluginInit interface {
	Init(config *viper.Viper, logger Logger, db *gorm.DB) error
}

type PluginMeta interface {
	Description() string
	// PkgPath information lost when compiled as plugin(.so)
	RootPkgPath() string
}

type PluginTask interface {
	// return all available subtasks, framework will run them for you in order
	SubTaskMetas() []SubTaskMeta
	// based on task context and user input options, return data that shared among all subtasks
	PrepareTaskData(taskCtx TaskContext, options map[string]interface{}) (interface{}, error)
}

type ProgressType int

type RunningProgress struct {
	Type          ProgressType
	Current       int
	Total         int
	SubTaskName   string
	SubTaskNumber int
}

type SubTask interface {
	// Execute FIXME ...
	Execute() error
}

type SubTaskContext interface {
	ExecContext
	TaskContext() TaskContext
}

type SubTaskEntryPoint func(c SubTaskContext) error

type SubTaskMeta struct {
	Name       string
	EntryPoint SubTaskEntryPoint
	// Required SubTask will be executed no matter what
	Required         bool
	EnabledByDefault bool
	Description      string
	DomainTypes      []string
}

type TaskContext interface {
	ExecContext
	SetData(data interface{})
	SubTaskContext(subtask string) (SubTaskContext, error)
}