dbconf

type Agent struct {
	ID               int
	UUID             uuid.UUID
	OrganizationUUID uuid.UUID
	DisplayName      string
	TsConfiguration  time.Time
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}

type Alert struct {
	ID               int
	UUID             uuid.UUID
	OrganizationUUID uuid.UUID
	ChannelUUID      uuid.UUID
	Type             string
	Configuration    map[string]interface{}
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}

type Channel struct {
	ID               int
	UUID             uuid.UUID
	OrganizationUUID uuid.UUID
	Type             string
	DisplayName      string
	Configuration    map[string]interface{}
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}

type ChannelType struct {
	Label                 string
	ConfigurationTemplate []util.Parameter
}

type ConfigurationDB interface {
	ListOrganizations(count int32, offset uint64) ([]*Organization, error)
	GetOrganization(organizationUUID uuid.UUID) (*Organization, error)
	UpdateOrganization(organization *Organization) (*Organization, error)
	CreateOrganization(organization *Organization) (*Organization, error)

	ListAgents(organizationUUID uuid.UUID, count int32, offset uint64) ([]*Agent, error)
	GetAgent(organizationUUID, agentUUID uuid.UUID) (*Agent, error)
	CreateAgent(agent *Agent) (*Agent, error)
	UpdateAgent(agent *Agent) (*Agent, error)
	DeleteAgent(organizationUUID, agentUUID uuid.UUID) error

	ListTargets(organizationUUID uuid.UUID, count int32, offset uint64) ([]*Target, error)
	GetTarget(organizationUUID, targetUUID uuid.UUID) (*Target, error)
	CreateTarget(target *Target) (*Target, error)
	UpdateTarget(target *Target) (*Target, error)
	DeleteTarget(organizationUUID, targetUUID uuid.UUID) error

	ListTargetProbes(organizationUUID uuid.UUID, targetUUIDs, probeUUIDs []uuid.UUID, count int32, offset uint64) ([]*TargetProbe, error)
	GetTargetProbe(organizationUUID, targetProbeUUID uuid.UUID) (*TargetProbe, error)
	CreateTargetProbe(targetProbe *TargetProbe) (*TargetProbe, error)
	UpdateTargetProbe(targetProbe *TargetProbe) (*TargetProbe, error)
	DeleteTargetProbe(organizationUUID, targetProbeUUID uuid.UUID) error

	ListTargetProbesByAlert(organizationUUID, alertUUID uuid.UUID, count int32, offset uint64) (targetProbes []*TargetProbe, err error)
	ListAlertsByTargetProbe(organizationUUID, targetProbeUUID uuid.UUID, count int32, offset uint64) ([]*Alert, error)
	LinkTargetProbesToAlert(force bool, organizationUUID, alertUUID uuid.UUID, targetProbes ...uuid.UUID) error

	ListTargetProbeAgents(organizationUUID, agentUUID uuid.UUID, count int32, offset uint64) ([]*TargetProbeAgent, error)
	ListTargetProbeAgentsForOrganization(organizationUUID uuid.UUID, checkUUIDs []uuid.UUID, pageSize int32, pageOffset uint64) ([]*TargetProbeAgent, error)
	ListTargetProbeAgentsAll(count int32, offset uint64) ([]*TargetProbeAgent, error)
	GetTargetProbeAgent(organizationUUID, agentUUID, targetProbeAgentUUID uuid.UUID) (*TargetProbeAgent, error)
	CreateTargetProbeAgent(targetProbeAgent *TargetProbeAgent) (*TargetProbeAgent, error)
	UpdateTargetProbeAgent(targetProbeAgent *TargetProbeAgent) (*TargetProbeAgent, error)
	DeleteTargetProbeAgent(organizationUUID, agentUUID, targetProbeAgentUUID uuid.UUID) error

	ListChannels(organizationUUID uuid.UUID, count int32, offset uint64) ([]*Channel, error)
	GetChannel(organizationUUID, channelUUID uuid.UUID) (*Channel, error)
	CreateChannel(channel *Channel) (*Channel, error)
	UpdateChannel(channel *Channel) (*Channel, error)
	DeleteChannel(organizationUUID, channelUUID uuid.UUID) error

	ListAlerts(organizationUUID uuid.UUID, count int32, offset uint64) ([]*Alert, error)
	GetAlert(organizationUUID, alertUUID uuid.UUID) (*Alert, error)
	CreateAlert(alert *Alert) (*Alert, error)
	UpdateAlert(alert *Alert) (*Alert, error)
	DeleteAlert(organizationUUID, alertUUID uuid.UUID) error

	GetUserByEmail(email string) (*User, error)
	CreateUser(user *User) (*User, error)
	UpdateUser(user *User) (*User, error)
	DeleteUser(organizationUUID, userUUID uuid.UUID) error

	ListAlertsByChannel(organizationUUID, channelUUID uuid.UUID, count int32, offset uint64) ([]*Alert, error)

	ListTags(organizationUUID uuid.UUID, count int32, offset uint64) ([]*Tag, error)
	GetTag(organizationUUID uuid.UUID, slug string) (*Tag, error)
	CreateTag(tag *Tag) (*Tag, error)
	UpdateTag(tag *Tag) (*Tag, error)
	DeleteTag(organizationUUID uuid.UUID, slug string) error

	ListTagsByTarget(organizationUUID, targetUUID uuid.UUID, pageSize int32, pageOffset uint64) ([]*Tag, error)
	ListTargetsByTag(organizationUUID uuid.UUID, tagName string, pageSize int32, pageOffset uint64) ([]*Target, error)
	LinkTagsToTarget(force bool, organizationUUID, targetUUID uuid.UUID, tagSlugs ...string) error
	UnlinkTagsFromTarget(organizationUUID, targetUUID uuid.UUID, tagSlugs ...string) error

	ListChannelTypes(count int32, offset uint64) ([]*ChannelType, error)
	GetChannelType(label string) (*ChannelType, error)

	ListProbes(count int32, offset uint64) ([]*Probe, error)
	GetProbe(probeUUID uuid.UUID) (*Probe, error)

	// Close DB connection
	Close() error
	// contains filtered or unexported methods
}

type Graphs struct {
	Graphs []struct {
		Title   string // name of the graph
		Type    string // type of graph (lines, stacked-lines)
		Format  string // unit formatter for the metrics
		Metrics []struct {
			Name  string // the name of the metric to graph
			Color string // the color to draw the metric representation
		}
		Tags []string // list of tags to group the metrics on (and to duplicate graphs)
	}
}

type MetricOptions struct {
	Accumulator bool
}

type Metrics struct {
	Metrics []struct {
		Name        string
		Type        string
		Description string
		Options     MetricOptions
	}
	Tags []struct {
		Name        string
		Description string
	}
}

type Migration struct {
	Version int64
	Name    string
}

type NullBytes struct {
	Bytes []byte
	Valid bool
}

type NullTime struct {
	Time  time.Time
	Valid bool // Valid is true if Time is not NULL
}

type Organization struct {
	ID        int
	UUID      uuid.UUID
	Name      string
	TsCreated time.Time
	TsUpdated time.Time
	TsDeleted time.Time
}

type Probe struct {
	ID                    int
	UUID                  uuid.UUID
	Label                 string
	DisplayName           string
	Description           string
	ConfigurationTemplate []util.Parameter
	Metrics               Metrics
	Graphs                Graphs
	TsCreated             time.Time
	TsUpdated             time.Time
	TsDeleted             time.Time
}

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

type Tag struct {
	ID               int
	OrganizationUUID uuid.UUID
	Slug             string
	DisplayName      string
	Note             string
	Color            string
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}

type Target struct {
	ID               int
	UUID             uuid.UUID
	OrganizationUUID uuid.UUID
	Address          string
	Note             string
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}

type TargetProbe struct {
	ID                 int
	UUID               uuid.UUID
	TargetUUID         uuid.UUID
	ProbeUUID          uuid.UUID
	OrganizationUUID   uuid.UUID
	StateType          string
	StateConfiguration map[string]interface{}
	TsCreated          time.Time
	TsUpdated          time.Time
	TsDeleted          time.Time
}

type TargetProbeAgent struct {
	UUID               uuid.UUID
	OrganizationUUID   uuid.UUID
	AgentUUID          uuid.UUID
	TargetProbeUUID    uuid.UUID
	ProbeLabel         string
	ProbeConfiguration map[string]interface{}
	Schedule           time.Duration
	TsCreated          time.Time
	TsUpdated          time.Time
	TsDeleted          time.Time
}

type User struct {
	ID               int
	UUID             uuid.UUID
	OrganizationUUID uuid.UUID
	Email            string
	PasswordSalt     util.Salt
	PasswordHash     util.Hash
	Details          map[string]interface{}
	TsCreated        time.Time
	TsUpdated        time.Time
	TsDeleted        time.Time
}