repository

type Agent struct {
	ID primitive.ObjectID `bson:"_id,omitempty" json:"id"`

	IP          string      `bson:"ip" json:"ip"`
	AgentID     string      `bson:"agent_id" json:"agent_id"`
	Version     string      `bson:"version" json:"version"`
	LastAliveAt time.Time   `bson:"last_alive_at" json:"last_alive_at"`
	LastStat    interface{} `bson:"last_stat" json:"last_stat"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
}

type AgentRepo interface {
	Update(agent Agent) (ID, error)
	Get(id ID) (agent Agent, err error)
	Find(filter bson.M) (agents []Agent, err error)
	Delete(filter bson.M) error
	DeleteID(id ID) error
}

type AuditLog struct {
	ID primitive.ObjectID `bson:"_id,omitempty" json:"id"`

	Type    AuditLogType           `bson:"type" json:"type"`
	Context map[string]interface{} `bson:"context" json:"context"`
	Body    string                 `bson:"body" json:"body"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
}

type AuditLogRepo interface {
	Add(al AuditLog) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (al AuditLog, err error)
	Paginate(filter bson.M, offset, limit int64) (logs []AuditLog, next int64, err error)
	Delete(filter bson.M) error
	DeleteID(id primitive.ObjectID) error
}

type AuditLogType string

type DingdingRobot struct {
	ID primitive.ObjectID `bson:"_id,omitempty" json:"id"`

	Name        string `bson:"name" json:"name"`
	Description string `bson:"description" json:"description"`

	Token  string `bson:"token" json:"token"`
	Secret string `bson:"secret" json:"secret"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
}

type DingdingRobotRepo interface {
	Add(robot DingdingRobot) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (robot DingdingRobot, err error)
	Find(filter bson.M) (robots []DingdingRobot, err error)
	Paginate(filter bson.M, offset, limit int64) (robots []DingdingRobot, next int64, err error)
	DeleteID(id primitive.ObjectID) error
	Delete(filter bson.M) error
	Update(id primitive.ObjectID, robot DingdingRobot) error
	Count(filter bson.M) (int64, error)
}

type Event struct {
	ID         primitive.ObjectID   `bson:"_id,omitempty" json:"id"`
	RelationID []primitive.ObjectID `bson:"relation_ids" json:"relation_ids"`
	SeqNum     int64                `bson:"seq_num" json:"seq_num"`
	Content    string               `bson:"content" json:"content"`
	Meta       EventMeta            `bson:"meta" json:"meta"`
	Tags       []string             `bson:"tags" json:"tags"`
	Origin     string               `bson:"origin" json:"origin"`
	GroupID    []primitive.ObjectID `bson:"group_ids" json:"group_ids"`
	Type       EventType            `bson:"type" json:"type"`
	Status     EventStatus          `bson:"status" json:"status"`
	CreatedAt  time.Time            `bson:"created_at" json:"created_at"`
}

type EventByDatetimeCount struct {
	Datetime time.Time `bson:"datetime" json:"datetime"`
	Total    int64     `bson:"total" json:"total"`
}

type EventGroup struct {
	ID     primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	SeqNum int64              `bson:"seq_num" json:"seq_num"`

	// AggregateKey 与 .Rule.AggregateKey 相同，方便读取
	AggregateKey string    `bson:"aggregate_key" json:"aggregate_key"`
	Type         EventType `bson:"type" json:"type"`

	MessageCount int64          `bson:"message_count" json:"message_count"`
	Rule         EventGroupRule `bson:"rule" json:"rule"`
	Actions      []Trigger      `bson:"actions" json:"actions"`

	Status    EventGroupStatus `bson:"status" json:"status"`
	CreatedAt time.Time        `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time        `bson:"updated_at" json:"updated_at"`
}

type EventGroupAggByDatetimeCount struct {
	Datetime      time.Time `bson:"datetime" json:"datetime"`
	AggregateKey  string    `bson:"aggregate_key" json:"aggregate_key"`
	Total         int64     `bson:"total" json:"total"`
	TotalMessages int64     `bson:"total_messages" json:"total_messages"`
}

type EventGroupAggCount struct {
	AggregateKey string `bson:"aggregate_key" json:"aggregate_key"`
	Total        int64  `bson:"total" json:"total"`
}

type EventGroupByDatetimeCount struct {
	Datetime      time.Time `bson:"datetime" json:"datetime"`
	Total         int64     `bson:"total" json:"total"`
	TotalMessages int64     `bson:"total_messages" json:"total_messages"`
}

type EventGroupByRuleCount struct {
	RuleID        primitive.ObjectID `bson:"rule_id" json:"rule_id"`
	RuleName      string             `bson:"rule_name" json:"rule_name"`
	Total         int64              `bson:"total" json:"total"`
	TotalMessages int64              `bson:"total_messages" json:"total_messages"`
}

type EventGroupByUserCount struct {
	UserID        primitive.ObjectID `bson:"user_id" json:"user_id"`
	UserName      string             `bson:"user_name" json:"user_name"`
	Total         int64              `bson:"total" json:"total"`
	TotalMessages int64              `bson:"total_messages" json:"total_messages"`
}

type EventGroupRepo interface {
	Add(grp EventGroup) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (grp EventGroup, err error)
	Find(filter bson.M) (grps []EventGroup, err error)
	Paginate(filter bson.M, offset, limit int64) (grps []EventGroup, next int64, err error)
	Delete(filter bson.M) error
	DeleteID(id primitive.ObjectID) error
	Traverse(filter bson.M, cb func(grp EventGroup) error) error
	UpdateID(id primitive.ObjectID, grp EventGroup) error
	Count(filter bson.M) (int64, error)

	// LastGroup get last group which match the filter in messageGroups
	LastGroup(filter bson.M) (grp EventGroup, err error)
	CollectingGroup(rule EventGroupRule) (group EventGroup, err error)

	// Statistics
	// StatByRuleCount 按照规则的维度，查询规则相关的报警次数
	StatByRuleCount(ctx context.Context, startTime, endTime time.Time) ([]EventGroupByRuleCount, error)
	StatByUserCount(ctx context.Context, startTime, endTime time.Time) ([]EventGroupByUserCount, error)
	StatByDatetimeCount(ctx context.Context, filter bson.M, startTime, endTime time.Time, hour int64) ([]EventGroupByDatetimeCount, error)
	StatByAggCountInPeriod(ctx context.Context, ruleID primitive.ObjectID, startTime, endTime time.Time, hour int64) ([]EventGroupAggByDatetimeCount, error)
	StatByAggCount(ctx context.Context, ruleID primitive.ObjectID, startTime, endTime time.Time) ([]EventGroupAggCount, error)
}

type EventGroupRule struct {
	ID   primitive.ObjectID `bson:"_id" json:"id"`
	Name string             `bson:"name" json:"name"`

	// AggregateKey 通过该 Key 对同一个规则下的 message 分组
	AggregateKey string    `bson:"aggregate_key" json:"aggregate_key"`
	Type         EventType `bson:"type" json:"type"`

	// ExpectReadyAt 预期就绪时间，当超过该时间后，Group自动关闭，发起通知
	ExpectReadyAt time.Time `bson:"expect_ready_at" json:"expect_ready_at"`
	Realtime      bool      `bson:"realtime" json:"realtime"`

	Rule            string `bson:"rule" json:"rule"`
	IgnoreRule      string `bson:"ignore_rule" json:"ignore_rule"`
	Template        string `bson:"template" json:"template"`
	SummaryTemplate string `bson:"summary_template" json:"summary_template"`

	// Report template
	ReportTemplateID primitive.ObjectID `bson:"report_template_id" json:"report_template_id"`
}

type EventGroupStatus string

type EventMeta map[string]interface{}

type EventRelation struct {
	ID            primitive.ObjectID `bson:"_id,omitempty" json:"id,omitempty"`
	MatchedRuleID primitive.ObjectID `bson:"matched_rule_id,omitempty" json:"matched_rule_id,omitempty"`
	Summary       string             `bson:"summary" json:"summary,omitempty"`
	EventCount    int64              `bson:"event_count" json:"event_count,omitempty"`
	CreatedAt     time.Time          `bson:"created_at" json:"created_at,omitempty"`
	UpdatedAt     time.Time          `bson:"updated_at" json:"updated_at,omitempty"`
}

type EventRelationNote struct {
	ID          primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	RelationID  primitive.ObjectID `bson:"relation_id,omitempty" json:"relation_id"`
	EventID     primitive.ObjectID `bson:"event_id,omitempty" json:"event_id"`
	Note        string             `bson:"note" json:"note"`
	CreatorID   primitive.ObjectID `bson:"creator_id,omitempty" json:"creator_id"`
	CreatorName string             `bson:"creator_name" json:"creator_name"`
	CreatedAt   time.Time          `bson:"created_at" json:"created_at"`
	DeletedAt   time.Time          `bson:"deleted_at" json:"deleted_at"`
}

type EventRelationNoteRepo interface {
	AddNote(ctx context.Context, note EventRelationNote) (ID, error)
	PaginateNotes(ctx context.Context, relID primitive.ObjectID, filter bson.M, offset, limit int64) (notes []EventRelationNote, next int64, err error)
	DeleteNote(ctx context.Context, relID primitive.ObjectID, filter bson.M) error
}

type EventRelationRepo interface {
	AddOrUpdateEventRelation(ctx context.Context, summary string, matchedRuleID primitive.ObjectID) (EventRelation, error)
	Get(ctx context.Context, id primitive.ObjectID) (eventRel EventRelation, err error)
	Paginate(ctx context.Context, filter interface{}, offset, limit int64) (eventRels []EventRelation, next int64, err error)
	Count(ctx context.Context, filter interface{}) (int64, error)
}

type EventRepo interface {
	AddWithContext(ctx context.Context, msg Event) (id primitive.ObjectID, err error)
	Add(msg Event) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (msg Event, err error)
	Find(filter interface{}) (messages []Event, err error)
	FindIDs(ctx context.Context, filter interface{}, limit int64) ([]primitive.ObjectID, error)
	Paginate(filter interface{}, offset, limit int64) (messages []Event, next int64, err error)
	Delete(filter interface{}) error
	DeleteID(id primitive.ObjectID) error
	Traverse(filter interface{}, cb func(msg Event) error) error
	UpdateID(id primitive.ObjectID, update Event) error
	Count(filter interface{}) (int64, error)
	CountByDatetime(ctx context.Context, filter bson.M, startTime, endTime time.Time, hour int64) ([]EventByDatetimeCount, error)
}

type EventStatus string

type EventType string

type ID string

type KV struct {
	Key       string      `json:"key" bson:"key"`
	Value     interface{} `json:"value" bson:"value"`
	ExpiredAt time.Time   `json:"expired_at" bson:"expired_at"`
	WithTTL   bool        `json:"with_ttl" bson:"with_ttl"`
	CreatedAt time.Time   `json:"created_at" bson:"created_at"`
}

type KVRepo interface {
	Set(key string, value interface{}) error
	SetWithTTL(key string, value interface{}, ttl time.Duration) error
	Get(key string) (pair KV, err error)
	Remove(key string) (removeCount int64, err error)
	All(filter bson.M) (pairs []KV, err error)
	GC() error
}

type Lock struct {
	LockID    primitive.ObjectID `bson:"lock_id" json:"lock_id"`
	Resource  string             `bson:"resource" json:"resource"`
	Acquired  bool               `bson:"acquired" json:"acquired"`
	Owner     string             `bson:"owner" json:"owner"`
	TTL       uint               `bson:"ttl" json:"ttl"`
	CreatedAt time.Time          `bson:"created_at" json:"created_at"`
	RenewedAt time.Time          `bson:"renewed_at" json:"renewed_at"`
	ExpiredAt time.Time          `bson:"expired_at" json:"expired_at"`
}

type LockRepo interface {
	Lock(resource string, owner string, ttl uint) (*Lock, error)
	Renew(lockID primitive.ObjectID, ttl uint) (*Lock, error)
	UnLock(lockID primitive.ObjectID) error
	Remove(resource string) error
}

type QueueItemStatus string

type QueueJob struct {
	ID           primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	Name         string             `bson:"name" json:"name"`
	Payload      string             `bson:"payload" json:"payload"`
	Status       QueueItemStatus    `bson:"status" json:"status"`
	LastError    string             `bson:"last_error" json:"last_error"`
	RequeueTimes int                `bson:"requeue_times" json:"requeue_times"`

	NextExecuteAt time.Time `bson:"next_execute_at" json:"next_execute_at"`
	CreatedAt     time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt     time.Time `bson:"updated_at" json:"updated_at"`
}

type QueueRepo interface {
	// Enqueue add a item to queue
	// if the item is new(id is empty), add it to queue
	// if the item is already existed, replace it
	Enqueue(ctx context.Context, item QueueJob) (primitive.ObjectID, error)
	Dequeue(ctx context.Context) (QueueJob, error)
	UpdateID(ctx context.Context, id primitive.ObjectID, jobItem QueueJob) error
	Update(ctx context.Context, filter bson.M, item QueueJob) error
	Paginate(filter bson.M, offset, limit int64) (items []QueueJob, next int64, err error)
	Delete(filter bson.M) error
	DeleteID(id primitive.ObjectID) error
	Get(id primitive.ObjectID) (QueueJob, error)
	Count(filter bson.M) (int64, error)
}

type Recovery struct {
	RecoveryID string               `json:"recovery_id" bson:"recovery_id"`
	RecoveryAt time.Time            `json:"recovery_at" bson:"recovery_at"`
	RefIDs     []primitive.ObjectID `json:"ref_ids" bson:"ref_ids"`
	CreatedAt  time.Time            `json:"created_at" bson:"created_at"`
	UpdatedAt  time.Time            `json:"updated_at" json:"updated_at"`
}

type RecoveryRepo interface {
	Register(ctx context.Context, recoveryAt time.Time, recoveryID string, refID primitive.ObjectID) (err error)
	RecoverableEvents(ctx context.Context, deadline time.Time) ([]Recovery, error)
	Delete(ctx context.Context, recoveryID string) error
}

type Rule struct {
	ID          primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	Name        string             `bson:"name" json:"name"`
	Description string             `bson:"description" json:"description"`
	Tags        []string           `bson:"tags" json:"tags"`
	// AggregateRule 聚合规则，同一个规则匹配的事件，会按照该规则返回的值进行更加精细的分组
	AggregateRule string `bson:"aggregate_rule" json:"aggregate_rule"`
	// RelationRule 关联规则，匹配的事件会被创建关联关系
	RelationRule string `bson:"relation_rule" json:"relation_rule"`

	// ReadType 就绪类型，支持 interval/daily_time
	ReadyType  string      `bson:"ready_type" json:"ready_type"`
	Interval   int64       `bson:"interval" json:"interval"`
	DailyTimes []string    `bson:"daily_times" json:"daily_times"`
	TimeRanges []TimeRange `bson:"time_ranges" json:"time_ranges"`

	// RealtimeInterval 即时触发，当该值 > 0 时，将会采用即时触发，超过周期后，第一个发生的事件将会立即触发告警
	RealtimeInterval int64 `bson:"realtime_interval" json:"realtime_interval"`

	// Rule 用于分组匹配的规则
	Rule string `bson:"rule" json:"rule"`
	// IgnoreRule 分组匹配后，检查 message 是否应该被忽略
	IgnoreRule      string    `bson:"ignore_rule" json:"ignore_rule"`
	Template        string    `bson:"template" json:"template"`
	SummaryTemplate string    `bson:"summary_template" json:"summary_template"`
	Triggers        []Trigger `bson:"triggers" json:"triggers"`

	// ReportTemplateID 报表模板 ID
	ReportTemplateID primitive.ObjectID `bson:"report_template_id" json:"report_template_id"`

	Status RuleStatus `bson:"status" json:"status"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
}

type RuleRepo interface {
	Add(rule Rule) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (rule Rule, err error)
	Paginate(filter interface{}, offset, limit int64) (rules []Rule, next int64, err error)
	Find(filter bson.M) (rules []Rule, err error)
	Traverse(filter bson.M, cb func(rule Rule) error) error
	UpdateID(id primitive.ObjectID, rule Rule) error
	Count(filter bson.M) (int64, error)
	Delete(filter bson.M) error
	DeleteID(id primitive.ObjectID) error
	Tags(ctx context.Context) ([]Tag, error)
}

type RuleStatus string

type Sequence struct {
	Name  string `bson:"name" json:"name"`
	Value int64  `bson:"value" json:"value"`
}

type SequenceRepo interface {
	Next(name string) (seq Sequence, err error)
	Truncate(name string) error
}

type Tag struct {
	Name  string `bson:"_id" json:"name"`
	Count int64  `bson:"count" json:"count"`
}

type Template struct {
	ID          primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	Name        string             `bson:"name" json:"name"`
	Description string             `bson:"description" json:"description"`
	Content     string             `bson:"content" json:"content"`
	Type        TemplateType       `bson:"type" json:"type"`
	Predefined  bool               `bson:"predefined" json:"predefined"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
}

type TemplateRepo interface {
	Add(temp Template) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (temp Template, err error)
	Find(filter bson.M) (templates []Template, err error)
	Paginate(filter bson.M, offset, limit int64) (templates []Template, next int64, err error)
	DeleteID(id primitive.ObjectID) error
	Delete(filter bson.M) error
	Update(id primitive.ObjectID, temp Template) error
	Count(filter bson.M) (int64, error)
}

type TemplateType string

type TimeRange struct {
	// StartTime 开始时间（包含该时间）
	StartTime string `bson:"start_time" json:"start_time"`
	// EndTime 截止时间（不包含改时间）
	EndTime  string `bson:"end_time" json:"end_time"`
	Interval int64  `bson:"interval" json:"interval"`
}

type Times []time.Time

type Trigger struct {
	ID   primitive.ObjectID `bson:"_id,omitempty" json:"id"`
	Name string             `bson:"name" json:"name"`
	// IsElseTrigger 是否是兜底的 Trigger，当所有的非 ElseTrigger 均未匹配时生效
	// IsElseTrigger 为 true 时，忽略 PreCondition 规则，全部匹配
	IsElseTrigger bool                 `bson:"is_else_trigger" json:"is_else_trigger"`
	PreCondition  string               `bson:"pre_condition" json:"pre_condition"`
	Action        string               `bson:"action" json:"action"`
	Meta          string               `bson:"meta" json:"meta"`
	UserRefs      []primitive.ObjectID `bson:"user_refs" json:"user_refs"`
	// for group actions
	Status       TriggerStatus `bson:"trigger_status,omitempty" json:"trigger_status,omitempty"`
	FailedCount  int           `bson:"failed_count" json:"failed_count"`
	FailedReason string        `bson:"failed_reason" json:"failed_reason"`
}

type TriggerStatus string

type User struct {
	ID primitive.ObjectID `bson:"_id,omitempty" json:"id"`

	Name  string `bson:"name" json:"name"`
	Email string `bson:"email" json:"email"`
	Phone string `bson:"phone" json:"phone"`

	Password string `bson:"password" json:"password"`
	Role     string `bson:"role" json:"role"`

	Metas UserMetas `bson:"metas" json:"metas"`

	Status UserStatus `bson:"status" json:"status"`

	CreatedAt time.Time `bson:"created_at" json:"created_at"`
	UpdatedAt time.Time `bson:"updated_at" json:"updated_at"`
}

type UserMeta struct {
	Key   string `bson:"key" json:"key" schema:"key"`
	Value string `bson:"value" json:"value" schema:"value"`
}

type UserMetas []UserMeta

type UserRepo interface {
	Add(user User) (id primitive.ObjectID, err error)
	Get(id primitive.ObjectID) (user User, err error)
	GetByEmail(email string) (user User, err error)
	Find(filter bson.M) (users []User, err error)
	Paginate(filter bson.M, offset, limit int64) (users []User, next int64, err error)
	DeleteID(id primitive.ObjectID) error
	Delete(filter bson.M) error
	Update(id primitive.ObjectID, user User) error
	Count(filter bson.M) (int64, error)

	GetUserMetas(queryK, queryV, field string) ([]string, error)
}

type UserStatus string