notification

type AlertService interface {
	UpdateSilenceStatus(ctx context.Context, alertIDs []int64, hasSilenced bool, hasNonSilenced bool) error
}

type Config struct {
	Queue          queues.Config `mapstructure:"queue" yaml:"queue"`
	MessageHandler HandlerConfig `mapstructure:"message_handler" yaml:"message_handler"`
	DLQHandler     HandlerConfig `mapstructure:"dlq_handler" yaml:"dlq_handler"`
}

type Deps struct {
	IdempotencyRepository     IdempotencyRepository
	LogService                LogService
	ReceiverService           ReceiverService
	SubscriptionService       SubscriptionService
	SilenceService            SilenceService
	AlertService              AlertService
	DispatchReceiverService   Dispatcher
	DispatchSubscriberService Dispatcher
}

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

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

type Dispatcher interface {
	PrepareMessage(ctx context.Context, n Notification) ([]Message, []log.Notification, bool, error)
}

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
	Scope     string
	Key       string
	Success   bool
	CreatedAt time.Time
	UpdatedAt time.Time
}

type IdempotencyFilter struct {
	TTL time.Duration
}

type IdempotencyRepository interface {
	InsertOnConflictReturning(context.Context, string, string) (*Idempotency, error)
	UpdateSuccess(context.Context, uint64, bool) error
	Delete(context.Context, IdempotencyFilter) error
}

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

type Message struct {
	ID           string
	Status       MessageStatus
	ReceiverType string
	Configs      map[string]interface{} // the datasource to build vendor-specific configs
	Details      map[string]interface{} // 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 MessageOption func(*Message)

type MessageStatus string

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

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

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

type Queuer interface {
	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
	Type() string
	Cleanup(ctx context.Context, filter queues.FilterCleanup) error
	Stop(ctx context.Context) error
}

type ReceiverService interface {
	Get(ctx context.Context, id uint64, gopts ...receiver.GetOption) (*receiver.Receiver, error)
}

type Repository interface {
	Create(context.Context, Notification) (Notification, error)
}

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

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

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