notification

type AlertRepository interface {
	BulkUpdateSilence(context.Context, []int64, string) error
}

type Config struct {
	MaxNumReceiverSelectors int           `mapstructure:"max_num_receiver_selectors" yaml:"max_num_receiver_selectors" default:"10"`
	MaxMessagesReceiverFlow int           `mapstructure:"max_messages_receiver_flow" yaml:"max_messages_receiver_flow" default:"10"`
	Queue                   queues.Config `mapstructure:"queue" yaml:"queue"`
	MessageHandler          HandlerConfig `mapstructure:"message_handler" yaml:"message_handler"`
	DLQHandler              HandlerConfig `mapstructure:"dlq_handler" yaml:"dlq_handler"`
	GroupBy                 []string      `mapstructure:"group_by" yaml:"group_by"`
	Message                 MessageConfig `mapstructure:"message" yaml:"message"`
}

type Deps struct {
	Cfg                   Config
	Logger                saltlog.Logger
	Repository            Repository
	Q                     Queuer
	IdempotencyRepository IdempotencyRepository
	AlertRepository       AlertRepository
	LogService            LogService
	ReceiverService       ReceiverService
	TemplateService       TemplateService
	SubscriptionService   SubscriptionService
	SilenceService        SilenceService
}

type Dispatcher interface {
	Dispatch(ctx context.Context, ns []Notification) ([]string, error)
}

type Filter struct {
	Type             string
	Template         string
	Labels           map[string]string
	ReceiverSelector map[string]string
}

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

type HandlerConfig struct {
	Enabled       bool          `mapstructure:"enabled" yaml:"enabled" default:"true"`
	PollDuration  time.Duration `mapstructure:"poll_duration" yaml:"poll_duration" default:"5s"`
	ReceiverTypes []string      `mapstructure:"receiver_types" yaml:"receiver_types"`
	BatchSize     int           `mapstructure:"batch_size" yaml:"batch_size" default:"1"`
}

type HandlerOption func(*Handler)

type Idempotency struct {
	ID             uint64    `json:"id"`
	Scope          string    `json:"scope"`
	Key            string    `json:"key"`
	NotificationID string    `json:"notification_id"`
	CreatedAt      time.Time `json:"created_at"`
	UpdatedAt      time.Time `json:"updated_at"`
}

type IdempotencyFilter struct {
	TTL time.Duration
}

type IdempotencyRepository interface {
	Create(ctx context.Context, scope, key, notificationID string) (*Idempotency, error)
	Check(ctx context.Context, scope, key string) (*Idempotency, error)
	Delete(context.Context, IdempotencyFilter) error
}

type LogService interface {
	LogNotifications(ctx context.Context, nlogs ...log.Notification) error
}

type Message struct {
	ID              string
	NotificationIDs []string
	Status          MessageStatus
	ReceiverType    string
	Configs         map[string]any // the datasource to build vendor-specific configs
	Details         map[string]any // the datasource to build vendor-specific message
	MaxTries        int
	ExpiredAt       time.Time
	CreatedAt       time.Time
	UpdatedAt       time.Time

	LastError string
	TryCount  int
	Retryable bool
	// contains filtered or unexported fields
}

type MessageConfig struct {
	VerboseEnabled bool `mapstructure:"verbose_enabled" yaml:"verbose_enabled" default:"false"`
}

type MessageOption func(*Message)

type MessageStatus string

type MetaMessage struct {
	ReceiverID       uint64
	SubscriptionIDs  []uint64
	ReceiverType     string
	NotificationIDs  []string
	NotificationType string
	ReceiverConfigs  map[string]any
	Data             map[string]any
	ValidDuration    time.Duration
	Template         string
	Labels           map[string]string
	MergedLabels     map[string][]string
	UniqueKey        string
}

type Notification struct {
	ID                string            `json:"id"`
	NamespaceID       uint64            `json:"namespace_id"`
	Type              string            `json:"type"`
	Data              map[string]any    `json:"data"`
	Labels            map[string]string `json:"labels"`
	ValidDuration     time.Duration     `json:"valid_duration"`
	Template          string            `json:"template"`
	UniqueKey         string            `json:"unique_key"`
	ReceiverSelectors ReceiverSelectors `json:"receiver_selectors"`
	CreatedAt         time.Time         `json:"created_at"`

	// won't be stored in notification table, only to propagate this to notification_subscriber
	AlertIDs []int64
}

type Notifier interface {
	PreHookQueueTransformConfigs(ctx context.Context, notificationConfigMap map[string]any) (map[string]any, error)
	PostHookQueueTransformConfigs(ctx context.Context, notificationConfigMap map[string]any) (map[string]any, error)
	GetSystemDefaultTemplate() string
	Send(ctx context.Context, message Message) (bool, error)
	PostProcessMessage(MetaMessage, *Message) *Message
}

type Queuer interface {
	ListMessages(ctx context.Context, notificationID string) ([]Message, error)
	Enqueue(ctx context.Context, ms ...Message) error
	Dequeue(ctx context.Context, receiverTypes []string, batchSize int, handlerFn func(context.Context, []Message) error) error
	SuccessCallback(ctx context.Context, ms Message) error
	ErrorCallback(ctx context.Context, ms Message) error
	Cleanup(ctx context.Context, filter queues.FilterCleanup) error
	Stop(ctx context.Context) error
}

type ReceiverSelectors []map[string]any

type ReceiverService interface {
	List(ctx context.Context, flt receiver.Filter) ([]receiver.Receiver, error)
}

type Repository interface {
	Transactor
	BulkCreate(context.Context, []Notification) ([]Notification, error)
	Create(context.Context, Notification) (Notification, error)
	List(context.Context, Filter) ([]Notification, error)
}

type Router interface {
	PrepareMetaMessages(ctx context.Context, n Notification) (metaMessages []MetaMessage, notificationLogs []log.Notification, err error)
}

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

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

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

type SilenceService interface {
	List(ctx context.Context, filter silence.Filter) ([]silence.Silence, error)
}

type SubscriptionService interface {
	MatchByLabelsV2(ctx context.Context, namespaceID uint64, labels map[string]string) ([]subscription.ReceiverView, error)
}

type TemplateService interface {
	GetByName(ctx context.Context, name string) (*template.Template, error)
}

type Transactor interface {
	WithTransaction(ctx context.Context) context.Context
	Rollback(ctx context.Context, err error) error
	Commit(ctx context.Context) error
}