sdk

type API struct {
	APIConfig
	logrus.FieldLogger
	SleepingTimeBetweenAttempts time.Duration
}

type APIConfig interface {
	// APIName should return the name of the for example "misp" or "generic"
	APIName() string
	// GetURL should return URL of the API
	GetURL() string
	// GetCert should return the name of the certificate used for this datasource (if applicable, otherwise "")
	GetCert() string
}

type DBManager struct {
	DBManagerConfig
	sync.Mutex
	// contains filtered or unexported fields
}

type DBManagerConfig struct {
	MaxConnectionAttempts              int `yaml:"db-max-conn-attempts" default:"3"`
	SleepingTimeBetweenAttemptsSeconds int `yaml:"db-sleeping-time" default:"4"`
}

type DataObject struct {
	// OutputName is the output name of the DataObject.
	OutputName OutputDataObjectName

	// SharedID is the DataObjectSharedID that this DataObject should have.
	SharedID models.DataObjectSharedID

	// the ones not being used should be left to nil
	IntValue  *int64
	IntVector []int64
	IntMatrix [][]int64

	FloatValue  *float64
	FloatVector []float64
	FloatMatrix [][]float64

	Columns []string
}

type DataSource interface {
	SetID(id models.DataSourceID)
	GetID() models.DataSourceID

	SetContext(ctx *context.Context)
	GetContext() *context.Context

	// GetDataSourceCore returns the DataSourceCore of the DataSource.
	GetDataSourceCore() *DataSourceCore

	// SetDataSourceConfig sets the DataSource configuration, i.e. DataSource specific  metadata not contained in DataSourceCore.
	SetDataSourceConfig(map[string]interface{}) error
	// GetDataSourceConfig returns the DataSource configuration, i.e. DataSource specific  metadata not contained in DataSourceCore.
	GetDataSourceConfig() map[string]interface{}

	// Data must return all the DataSource data to be stored in the TI Note object storage.
	// Implementations should just call the DataImpl() function provided by the package.
	Data() map[string]interface{}

	// Config configures the DataSource. It must be called after DataSourceFactory.
	Config(logger logrus.FieldLogger, config map[string]interface{}) error

	// ConfigFromDB configures the DataSource with the info stored in the DB. It must be called after DataSourceFactory if the DataSource has been retrieved from the DB.
	ConfigFromDB(logger logrus.FieldLogger) error

	// Query data source with a specific operation. (the possible operations are defined by the data source)
	//  - userID is the ID of the user who is querying the data source (e.g. the username)
	//  - params are the query parameters. Typically two keys are "operation" (const QueryOperation) for the type of operation
	// 	  and "params" (const QueryParams) for serialized JSON payloads.
	//  - resultKeys are the keys of the results to be returned. If empty, the default key is "default"
	Query(userID string, params map[string]interface{}, resultKeys ...string) (results map[string]interface{}, err error)

	// Close is called to close all connections related to the DataSource or other instances.
	Close() error
}

type DataSourceCore struct {
	*MetadataDB
	*MetadataStorage
	Ctx *context.Context // For telemetry
}

type DataSourceFactory func(dsc *DataSourceCore, config map[string]interface{}, dbManager *DBManager) (ds DataSource, err error)

type DataSourceType string

type Database struct {
	DatabaseConfig
	logrus.FieldLogger
	*sql.DB
	MaxConnectionAttempts       int
	SleepingTimeBetweenAttempts time.Duration
}

type DatabaseConfig interface {
	// DriverName should return the name of the driver for example "postgres" or "sqlite3"
	DriverName() string
	// DataSourceName should return the connection string to the db: postgres example "host=localhost port=5432 user=test password=test dbname=test sslmode=disable"
	DataSourceName() string
	// Driver Should return the database driver
	Driver() driver.Driver
	// Name should return the name of the connected database
	Name() string
}

type DatabaseError struct {
	Err error
}

type GenericAPIConfig struct {
	URL   string `yaml:"api-url" json:"api-url" default:"localhost"`
	Token string `yaml:"api-token" json:"api-token" default:""`
	Cert  string `yaml:"cert" json:"cert" default:""`
}

type MetadataDB struct {
	gorm.Model
	ID                      models.DataSourceID      `gorm:"primaryKey"`
	Name                    string                   `gorm:"uniqueIndex:udx_name;not null"`
	Type                    DataSourceType           `gorm:"not null"`
	CredentialsProviderType credentials.ProviderType `gorm:"not null"`
	Owner                   string                   `gorm:"not null"`
	AccessScope             string
	AuthorizedUsers         pq.StringArray `gorm:"type:text[]"`
	DeletedAt               gorm.DeletedAt `gorm:"uniqueIndex:udx_name"`
}

type MetadataStorage struct {
	CredentialsProvider credentials.Provider
	Attributes          []string
	ConsentType         models.DataSourceConsentType
}

type OutputDataObjectName string

type PostgresConfig struct {
	Host     string `yaml:"db-host" default:"localhost"`
	Port     int    `yaml:"db-port" default:"5432"`
	Database string `yaml:"db-database" default:"test"`
	User     string `yaml:"db-user" default:"postgres"`
	Password string `yaml:"db-pwd" default:"password"`
}

type SQLiteConfig struct {
	Database  string `yaml:"db-database" default:"test"`
	Directory string `yaml:"db-directory" default:"db/"`
}