protocol

type AuditGroup []*AuditReport

type AuditPublisher interface {
	PublishAuditResult(audit *job.Audit, auditResult []*AuditReport) error
	Close(ctx context.Context) error
}

type AuditReport struct {
	AuditID        string
	Partition      string
	GroupValue     string
	TableURN       string
	FieldID        string
	MetricName     metric.Type
	MetricValue    float64
	Condition      string
	Metadata       map[string]interface{}
	ToleranceRules []ToleranceRule
	PassFlag       bool
	EventTimestamp time.Time
}

type AuditResult struct {
	Audit        *job.Audit
	AuditReports []*AuditReport
}

type AuditResultStore interface {
	StoreResults(results []*AuditReport) error
}

type AuditService interface {
	//RunAudit start audit service
	RunAudit(profileID string) (*AuditResult, error)
}

type AuditStore interface {
	CreateAudit(audit *job.Audit) (*job.Audit, error)
	UpdateAudit(audit *job.Audit) error
}

type AuditSummary struct {
	IsPass  bool
	Message string
}

type AuditSummaryFactory interface {
	Create(auditResults []*AuditReport, auditJob *job.Audit) (*AuditSummary, error)
}

type Auditor interface {
	Audit(audit *job.Audit) ([]*AuditReport, error)
}

type BigqueryJob struct {
	ID        string
	ProfileID string

	//BqID is bigquery job ID provided by query execution
	BqID string

	CreatedAt time.Time
}

type BigqueryJobStore interface {
	Store(bigqueryJob *BigqueryJob) error
}

type Comparator string

type ConstraintStore interface {
	FetchConstraints(tableID string) ([]string, error)
}

type Entity struct {
	ID            string
	Name          string
	Environment   string
	GitURL        string
	GcpProjectIDs []string
	CreatedAt     time.Time
	UpdatedAt     time.Time
}

type EntityFinder []*Entity

type EntityStore interface {
	Save(entity *Entity) (*Entity, error)
	Create(entity *Entity) (*Entity, error)
	Get(ID string) (*Entity, error)
	GetEntityByGitURL(gitURL string) (*Entity, error)
	GetEntityByProjectID(gcpProjectID string) (*Entity, error)
	GetAll() ([]*Entity, error)
	Update(entity *Entity) (*Entity, error)
}

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

type ErrSpecInvalid struct {
	URN    string
	Errors []error
}

type ErrUploadSpecValidation struct {
	Errors []error
}

type File struct {
	Path    string
	Content []byte
}

type FileStore interface {
	Get(filePath string) (*File, error)
	GetAll() ([]*File, error)
	GetPaths() ([]string, error)
	Create(file *File) error
	Delete(filePath string) error
}

type FileStoreFactory interface {
	Create(URL string) (FileStore, error)
}

type GitAuth interface {
	transport.AuthMethod
}

type GitInfo struct {

	//URL is a git url it must comply GitSshUrlPattern pattern format
	//this will be used to do git clone using ssh protocol
	URL string

	//CommitID is commit id that will be to be checked out
	//empty string means checking out latest revision
	CommitID string

	//PathPrefix is path prefix on git repository where the predator spec root directory structure is located
	//for example using Default directory structure, the files is flatly placed on a folder
	//if git url is git@github.com:username/project.git then in the repository the spec files placed under PathPrefix/ dir
	PathPrefix string
}

type GitRepository interface {
	Checkout(commit string) (FileStore, error)
}

type GitRepositoryFactory interface {
	Create(url string) GitRepository
	CreateWithPrefix(url string, pathPrefix string) GitRepository
}

type Label struct {
	Project string
	Dataset string
	Table   string
}

type Message struct {
	Key   proto.Message
	Value proto.Message
}

type MessageProvider interface {
	Get() (*Message, error)
}

type MessageProviderFactory interface {
	CreateProfileMessage(profile *job.Profile, metrics []*metric.Metric) []MessageProvider
	CreateAuditMessage(audit *job.Audit, auditResult []*AuditReport) []MessageProvider
}

type MetadataStore interface {
	//GetMetadata to fetch metadata as requirement for profiling
	GetMetadata(tableID string) (*meta.TableSpec, error)
	//GetUniqueConstraints to fetch unique constraints to calculate duplication metric
	GetUniqueConstraints(tableID string) ([]string, error)
}

type MetricGenerator interface {
	//Generate metrics
	Generate(entry Entry, config *job.Profile) ([]*metric.Metric, error)
}

type MetricProfiler interface {
	Profile(entry Entry, profile *job.Profile, metricSpecs []*metric.Spec) ([]*metric.Metric, error)
}

type MetricQuery struct {
	ProfileID   string
	Partition   string
	MetricTypes []metric.Type
	URN         string
}

type MetricResultIdentifier struct {
	TableURN  string
	StartDate string
	EndDate   string
}

type MetricSpecGenerator interface {
	Generate(tableSpec *meta.TableSpec, tolerances []*Tolerance) ([]*metric.Spec, error)
	GenerateMetricSpec(urn string) ([]*metric.Spec, error)
}

type MetricStore interface {
	Store(profile *job.Profile, metrics []*metric.Metric) error
	GetMetricsByProfileID(ID string) ([]*metric.Metric, error)
}

type PartitionScanner interface {
	GetAffectedPartition(tableURN string, lastModifiedTimestamp time.Time) ([]string, error)
}

type PathResolver interface {
	GetPath(urn string) (string, error)
	GetURN(filePath string) (string, error)
}

type PathType string

type ProfileBQLogger interface {
	Log(entry Entry, bqJobID string) error
}

type ProfileConfig struct {
	ProfileID   string
	TableSpec   *meta.TableSpec
	MetricSpecs []*metric.Spec
	Partition   string
}

type ProfileGroup []*ProfileMetric

type ProfileMetric struct {
	ID             string
	ProfileID      string
	TableURN       string
	Partition      string
	FieldID        string
	OwnerType      metric.Owner
	Category       metric.Category
	Condition      string
	MetricName     metric.Type
	MetricValue    float64
	EventTimestamp time.Time
}

type ProfilePublisher interface {
	Publish(profileJob *job.Profile, metrics []*metric.Metric) error
	Close(context.Context) error
}

type ProfileService interface {
	//CreateProfile create profile job
	CreateProfile(detail *job.Profile) (*job.Profile, error)
	Get(ID string) (*job.Profile, error)
	WaitAll(ctx context.Context) error
	GetLog(ID string) ([]*Status, error)
}

type ProfileStatisticGenerator interface {
	Generate(profile *job.Profile) error
}

type ProfileStore interface {
	Create(profile *job.Profile) (*job.Profile, error)
	Update(profile *job.Profile) error
	Get(ID string) (*job.Profile, error)
}

type ProtoBuilder interface {
	Build() (proto.Message, error)
}

type Publisher interface {
	Publish(provider MessageProvider) error
	Close(ctx context.Context) error
}

type PublisherType string

type QueryExecutor interface {
	Run(profile *job.Profile, query string, queryType job.QueryType) ([]Row, error)
}

type Row map[string]interface{}

type SQLExpressionFactory interface {
	CreatePartitionExpression(urn string) (string, error)
}

type Sink interface {
	Sink(message *Message) error
	Close(ctx context.Context) error
}

type SinkConfig struct {
	Type   PublisherType
	Broker []string
	Topic  string
}

type SinkFactory interface {
	Create(config *SinkConfig) Sink
}

type SpecValidator interface {
	//Validate content of data quality spec should return error ErrSpecInvalid when field or table not found
	Validate(spec *ToleranceSpec) error
}

type Status struct {
	ID             string
	JobID          string
	JobType        job.Type
	Status         string
	Message        string
	EventTimestamp time.Time
}

type StatusLogger interface {
	Log(entry Entry, message string) error
}

type StatusStore interface {
	Store(status *Status) error
	GetLatestStatusByIDandType(jobID string, jobType job.Type) (*Status, error)
	GetStatusLogByIDandType(jobID string, jobType job.Type) ([]*Status, error)
}

type Task interface {
	Run() (interface{}, error)
}

type Tolerance struct {
	ID             string
	TableURN       string
	FieldID        string
	MetricName     metric.Type
	Condition      string //condition for invalid_pct metric
	Metadata       map[string]interface{}
	ToleranceRules []ToleranceRule
	CreatedAt      time.Time
	UpdatedAt      time.Time
}

type ToleranceRule struct {
	Comparator Comparator `json:"comparator"`
	Value      float64    `json:"value"`
}

type ToleranceSpec struct {
	URN        string
	Tolerances []*Tolerance
}

type ToleranceSpecStateStore interface {
	SaveTolerances(profileID string, tolerances []*Tolerance) error
	GetTolerancesByProfileID(profileID string) ([]*Tolerance, error)
}

type ToleranceStore interface {
	Create(spec *ToleranceSpec) error
	GetByTableID(tableID string) (*ToleranceSpec, error)
	Delete(tableID string) error
	GetAll() ([]*ToleranceSpec, error)
	GetByProjectID(projectID string) ([]*ToleranceSpec, error)

	//GetResourceNames provide information all of tableID in the stored specs
	GetResourceNames() ([]string, error)
}

type ToleranceStoreFactory interface {
	Create(URL string, multiTenancyEnabled bool) (ToleranceStore, error)
	CreateWithOptions(store FileStore, pathType PathType) (ToleranceStore, error)
}

type UploadFactory interface {
	Create(gitRepo *GitInfo) (Task, error)
}

type ValidatedMetric struct {
	Metric         *metric.Metric
	ToleranceRules []ToleranceRule
	PassFlag       bool
}