autobrr/internal/notification/service.go
soup a89a1a55d9
feat(notifications): add LunaSea support (#1284)
* feat(notifications): add lunasea

* fix(web): truncate overflow in PasswordFieldWide

* refactor(notifications): centralize msg building

Left the building logic in discord.go and notifiarr.go as is because of their unique structure.

* refactor: moved components and swapped to outline

- Refactored the iconComponentMap to use a single iconStyle variable.

* upped size from 4 to 5

* rename NotificationBuilder function
2023-12-15 23:13:44 +01:00

292 lines
8.2 KiB
Go

// Copyright (c) 2021 - 2023, Ludvig Lundgren and the autobrr contributors.
// SPDX-License-Identifier: GPL-2.0-or-later
package notification
import (
"context"
"time"
"golang.org/x/sync/errgroup"
"github.com/autobrr/autobrr/internal/domain"
"github.com/autobrr/autobrr/internal/logger"
"github.com/autobrr/autobrr/pkg/errors"
"github.com/rs/zerolog"
)
type Service interface {
Find(ctx context.Context, params domain.NotificationQueryParams) ([]domain.Notification, int, error)
FindByID(ctx context.Context, id int) (*domain.Notification, error)
Store(ctx context.Context, n domain.Notification) (*domain.Notification, error)
Update(ctx context.Context, n domain.Notification) (*domain.Notification, error)
Delete(ctx context.Context, id int) error
Send(event domain.NotificationEvent, payload domain.NotificationPayload)
Test(ctx context.Context, notification domain.Notification) error
}
type service struct {
log zerolog.Logger
repo domain.NotificationRepo
senders []domain.NotificationSender
}
func NewService(log logger.Logger, repo domain.NotificationRepo) Service {
s := &service{
log: log.With().Str("module", "notification").Logger(),
repo: repo,
senders: []domain.NotificationSender{},
}
s.registerSenders()
return s
}
func (s *service) Find(ctx context.Context, params domain.NotificationQueryParams) ([]domain.Notification, int, error) {
n, count, err := s.repo.Find(ctx, params)
if err != nil {
s.log.Error().Err(err).Msgf("could not find notification with params: %+v", params)
return nil, 0, err
}
return n, count, err
}
func (s *service) FindByID(ctx context.Context, id int) (*domain.Notification, error) {
n, err := s.repo.FindByID(ctx, id)
if err != nil {
s.log.Error().Err(err).Msgf("could not find notification by id: %v", id)
return nil, err
}
return n, err
}
func (s *service) Store(ctx context.Context, n domain.Notification) (*domain.Notification, error) {
_, err := s.repo.Store(ctx, n)
if err != nil {
s.log.Error().Err(err).Msgf("could not store notification: %+v", n)
return nil, err
}
// reset senders
s.senders = []domain.NotificationSender{}
// re register senders
s.registerSenders()
return nil, nil
}
func (s *service) Update(ctx context.Context, n domain.Notification) (*domain.Notification, error) {
_, err := s.repo.Update(ctx, n)
if err != nil {
s.log.Error().Err(err).Msgf("could not update notification: %+v", n)
return nil, err
}
// reset senders
s.senders = []domain.NotificationSender{}
// re register senders
s.registerSenders()
return nil, nil
}
func (s *service) Delete(ctx context.Context, id int) error {
err := s.repo.Delete(ctx, id)
if err != nil {
s.log.Error().Err(err).Msgf("could not delete notification: %v", id)
return err
}
// reset senders
s.senders = []domain.NotificationSender{}
// re register senders
s.registerSenders()
return nil
}
func (s *service) registerSenders() {
senders, err := s.repo.List(context.Background())
if err != nil {
s.log.Error().Err(err).Msg("could not find notifications")
return
}
for _, n := range senders {
if n.Enabled {
switch n.Type {
case domain.NotificationTypeDiscord:
s.senders = append(s.senders, NewDiscordSender(s.log, n))
case domain.NotificationTypeNotifiarr:
s.senders = append(s.senders, NewNotifiarrSender(s.log, n))
case domain.NotificationTypeTelegram:
s.senders = append(s.senders, NewTelegramSender(s.log, n))
case domain.NotificationTypePushover:
s.senders = append(s.senders, NewPushoverSender(s.log, n))
case domain.NotificationTypeGotify:
s.senders = append(s.senders, NewGotifySender(s.log, n))
case domain.NotificationTypeLunaSea:
s.senders = append(s.senders, NewLunaSeaSender(s.log, n))
}
}
}
return
}
// Send notifications
func (s *service) Send(event domain.NotificationEvent, payload domain.NotificationPayload) {
if len(s.senders) > 0 {
s.log.Debug().Msgf("sending notification for %v", string(event))
}
go func() {
for _, sender := range s.senders {
// check if sender is active and have notification types
if sender.CanSend(event) {
sender.Send(event, payload)
}
}
}()
return
}
func (s *service) Test(ctx context.Context, notification domain.Notification) error {
var agent domain.NotificationSender
// send test events
events := []domain.NotificationPayload{
{
Subject: "Test Notification",
Message: "autobrr goes brr!!",
Event: domain.NotificationEventTest,
Timestamp: time.Now(),
},
{
Subject: "New release!",
Message: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Event: domain.NotificationEventPushApproved,
ReleaseName: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Filter: "TV",
Indexer: "MockIndexer",
Status: domain.ReleasePushStatusApproved,
Action: "Send to qBittorrent",
ActionType: domain.ActionTypeQbittorrent,
ActionClient: "qBittorrent",
Rejections: nil,
Protocol: domain.ReleaseProtocolTorrent,
Implementation: domain.ReleaseImplementationIRC,
Timestamp: time.Now(),
},
{
Subject: "New release!",
Message: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Event: domain.NotificationEventPushRejected,
ReleaseName: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Filter: "TV",
Indexer: "MockIndexer",
Status: domain.ReleasePushStatusRejected,
Action: "Send to Sonarr",
ActionType: domain.ActionTypeSonarr,
ActionClient: "Sonarr",
Rejections: []string{"Unknown Series"},
Protocol: domain.ReleaseProtocolTorrent,
Implementation: domain.ReleaseImplementationIRC,
Timestamp: time.Now(),
},
{
Subject: "New release!",
Message: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Event: domain.NotificationEventPushError,
ReleaseName: "Best.Show.Ever.S18E21.1080p.AMZN.WEB-DL.DDP2.0.H.264-GROUP",
Filter: "TV",
Indexer: "MockIndexer",
Status: domain.ReleasePushStatusErr,
Action: "Send to Sonarr",
ActionType: domain.ActionTypeSonarr,
ActionClient: "Sonarr",
Rejections: []string{"error pushing to client"},
Protocol: domain.ReleaseProtocolTorrent,
Implementation: domain.ReleaseImplementationIRC,
Timestamp: time.Now(),
},
{
Subject: "IRC Disconnected unexpectedly",
Message: "Network: P2P-Network",
Event: domain.NotificationEventIRCDisconnected,
Timestamp: time.Now(),
},
{
Subject: "IRC Reconnected",
Message: "Network: P2P-Network",
Event: domain.NotificationEventIRCReconnected,
Timestamp: time.Now(),
},
{
Subject: "New update available!",
Message: "v1.6.0",
Event: domain.NotificationEventAppUpdateAvailable,
Timestamp: time.Now(),
},
}
switch notification.Type {
case domain.NotificationTypeDiscord:
agent = NewDiscordSender(s.log, notification)
case domain.NotificationTypeNotifiarr:
agent = NewNotifiarrSender(s.log, notification)
case domain.NotificationTypeTelegram:
agent = NewTelegramSender(s.log, notification)
case domain.NotificationTypePushover:
agent = NewPushoverSender(s.log, notification)
case domain.NotificationTypeGotify:
agent = NewGotifySender(s.log, notification)
case domain.NotificationTypeLunaSea:
agent = NewLunaSeaSender(s.log, notification)
default:
s.log.Error().Msgf("unsupported notification type: %v", notification.Type)
return errors.New("unsupported notification type")
}
g, _ := errgroup.WithContext(ctx)
for _, event := range events {
e := event
if !enabledEvent(notification.Events, e.Event) {
continue
}
if err := agent.Send(e.Event, e); err != nil {
s.log.Error().Err(err).Msgf("error sending test notification: %#v", notification)
return err
}
time.Sleep(1 * time.Second)
}
if err := g.Wait(); err != nil {
s.log.Error().Err(err).Msgf("Something went wrong sending test notifications to %v", notification.Type)
return err
}
return nil
}
func enabledEvent(events []string, e domain.NotificationEvent) bool {
for _, v := range events {
if v == string(e) {
return true
}
}
return false
}