feat(notifications): Add Gotify (#1180)

feat(notifications): Add Gotify (resolves #513)

internal/notification/gotify.go

@@ -0,0 +1,176 @@
+// Copyright (c) 2021 - 2023, Ludvig Lundgren and the autobrr contributors.
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package notification
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/autobrr/autobrr/internal/domain"
+	"github.com/autobrr/autobrr/pkg/errors"
+
+	"github.com/dustin/go-humanize"
+	"github.com/rs/zerolog"
+)
+
+type gotifyMessage struct {
+	Message string `json:"message"`
+	Title   string `json:"title"`
+}
+
+type gotifySender struct {
+	log      zerolog.Logger
+	Settings domain.Notification
+}
+
+func NewGotifySender(log zerolog.Logger, settings domain.Notification) domain.NotificationSender {
+	return &gotifySender{
+		log:      log.With().Str("sender", "gotify").Logger(),
+		Settings: settings,
+	}
+}
+
+func (s *gotifySender) Send(event domain.NotificationEvent, payload domain.NotificationPayload) error {
+	m := gotifyMessage{
+		Message: s.buildMessage(payload),
+		Title:   s.buildTitle(event),
+	}
+
+	data := url.Values{}
+	data.Set("message", m.Message)
+	data.Set("title", m.Title)
+
+	url := fmt.Sprintf("%v/message?token=%v", s.Settings.Host, s.Settings.Token);
+	req, err := http.NewRequest(http.MethodPost, url, strings.NewReader(data.Encode()))
+	if err != nil {
+		s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
+		return errors.Wrap(err, "could not create request")
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("User-Agent", "autobrr")
+
+	client := http.Client{Timeout: 30 * time.Second}
+	res, err := client.Do(req)
+	if err != nil {
+		s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
+		return errors.Wrap(err, "could not make request: %+v", req)
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		s.log.Error().Err(err).Msgf("gotify client request error: %v", event)
+		return errors.Wrap(err, "could not read data")
+	}
+
+	defer res.Body.Close()
+
+	s.log.Trace().Msgf("gotify status: %v response: %v", res.StatusCode, string(body))
+
+	if res.StatusCode != http.StatusOK {
+		s.log.Error().Err(err).Msgf("gotify client request error: %v", string(body))
+		return errors.New("bad status: %v body: %v", res.StatusCode, string(body))
+	}
+
+	s.log.Debug().Msg("notification successfully sent to gotify")
+
+	return nil
+}
+
+func (s *gotifySender) CanSend(event domain.NotificationEvent) bool {
+	if s.isEnabled() && s.isEnabledEvent(event) {
+		return true
+	}
+	return false
+}
+
+func (s *gotifySender) isEnabled() bool {
+	if s.Settings.Enabled {
+		if s.Settings.Host == "" {
+			s.log.Warn().Msg("gotify missing host")
+			return false
+		}
+
+		if s.Settings.Token == "" {
+			s.log.Warn().Msg("gotify missing application token")
+			return false
+		}
+
+		return true
+	}
+
+	return false
+}
+
+func (s *gotifySender) isEnabledEvent(event domain.NotificationEvent) bool {
+	for _, e := range s.Settings.Events {
+		if e == string(event) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (s *gotifySender) buildMessage(payload domain.NotificationPayload) string {
+	msg := ""
+
+	if payload.Subject != "" && payload.Message != "" {
+		msg += fmt.Sprintf("%v\n%v", payload.Subject, payload.Message)
+	}
+	if payload.ReleaseName != "" {
+		msg += fmt.Sprintf("\nNew release: %v", payload.ReleaseName)
+	}
+	if payload.Size > 0 {
+		msg += fmt.Sprintf("\nSize: %v", humanize.Bytes(payload.Size))
+	}
+	if payload.Status != "" {
+		msg += fmt.Sprintf("\nStatus: %v", payload.Status.String())
+	}
+	if payload.Indexer != "" {
+		msg += fmt.Sprintf("\nIndexer: %v", payload.Indexer)
+	}
+	if payload.Filter != "" {
+		msg += fmt.Sprintf("\nFilter: %v", payload.Filter)
+	}
+	if payload.Action != "" {
+		action := fmt.Sprintf("\nAction: %v Type: %v", payload.Action, payload.ActionType)
+		if payload.ActionClient != "" {
+			action += fmt.Sprintf(" Client: %v", payload.ActionClient)
+		}
+		msg += action
+	}
+	if len(payload.Rejections) > 0 {
+		msg += fmt.Sprintf("\nRejections: %v", strings.Join(payload.Rejections, ", "))
+	}
+
+	return msg
+}
+
+func (s *gotifySender) buildTitle(event domain.NotificationEvent) string {
+	title := ""
+
+	switch event {
+	case domain.NotificationEventAppUpdateAvailable:
+		title = "Autobrr update available"
+	case domain.NotificationEventPushApproved:
+		title = "Push Approved"
+	case domain.NotificationEventPushRejected:
+		title = "Push Rejected"
+	case domain.NotificationEventPushError:
+		title = "Error"
+	case domain.NotificationEventIRCDisconnected:
+		title = "IRC Disconnected"
+	case domain.NotificationEventIRCReconnected:
+		title = "IRC Reconnected"
+	case domain.NotificationEventTest:
+		title = "Test"
+	}
+
+	return title
+}

internal/notification/service.go

@@ -130,6 +130,8 @@ func (s *service) registerSenders() {
 				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))
 			}
 		}
 	}
@@ -243,6 +245,8 @@ func (s *service) Test(ctx context.Context, notification domain.Notification) er
 		agent = NewTelegramSender(s.log, notification)
 	case domain.NotificationTypePushover:
 		agent = NewPushoverSender(s.log, notification)
+	case domain.NotificationTypeGotify:
+		agent = NewGotifySender(s.log, notification)
 	default:
 		s.log.Error().Msgf("unsupported notification type: %v", notification.Type)
 		return errors.New("unsupported notification type")