feat(notifications): add suppress-for notification-uri config option

Author: sentriz

cmd/internal/wrtagflag/wrtagflag.go

@@ -161,15 +161,28 @@ func (r researchLinkParser) String() string {
 type notificationsParser struct{ *notifications.Notifications }
 
 func (n *notificationsParser) Set(value string) error {
-	eventsRaw, uri, ok := strings.Cut(value, " ")
-	if !ok {
-		return errors.New("invalid notification uri format. expected eg \"ev1,ev2 uri\"")
+	parts := strings.Fields(value)
+	if len(parts) < 2 {
+		return errors.New("invalid notification uri format. expected eg \"ev1,ev2 uri [suppress-for 30s]\"")
+	}
+	eventsRaw, uri := parts[0], parts[1]
+
+	var suppressFor time.Duration
+	if len(parts) >= 4 && parts[2] == "suppress-for" {
+		var err error
+		suppressFor, err = time.ParseDuration(parts[3])
+		if err != nil {
+			return fmt.Errorf("parse suppress duration: %w", err)
+		}
 	}
+
 	var lineErrs []error
 	for ev := range strings.SplitSeq(eventsRaw, ",") {
-		ev, uri = strings.TrimSpace(ev), strings.TrimSpace(uri)
-		err := n.AddURI(ev, uri)
-		lineErrs = append(lineErrs, err)
+		ev = strings.TrimSpace(ev)
+		if err := n.AddDestination(ev, uri, suppressFor); err != nil {
+			lineErrs = append(lineErrs, err)
+			continue
+		}
 	}
 	return errors.Join(lineErrs...)
 }
@@ -178,10 +191,14 @@ func (n notificationsParser) String() string {
 		return ""
 	}
 	var parts []string
-	n.Notifications.IterMappings(func(e string, uri string) {
-		url, _ := url.Parse(uri)
-		parts = append(parts, fmt.Sprintf("%s: %s://%s/...", e, url.Scheme, url.Host))
-	})
+	for ev, dest := range n.Notifications.Destinations() {
+		uri, _ := url.Parse(dest.URI)
+		part := fmt.Sprintf("%s: %s://%s/...", ev, uri.Scheme, uri.Host)
+		if dest.SuppressFor > 0 {
+			part += fmt.Sprintf(" (suppress for %s)", dest.SuppressFor)
+		}
+		parts = append(parts, part)
+	}
 	return strings.Join(parts, ", ")
 }
 

config.example

@@ -36,8 +36,9 @@
 # add notification uri that are triggered by various events
 # see all available services here https://containrrr.dev/shoutrrr/v0.8/services/generic/
 # possible events are complete, needs-input, sync-complete, sync-error
+# optional "suppress-for" prevents notifications for specified duration after manual actions
 
-#notification-uri complete,needs-input,sync-error smtp://username:password@host:port/?from=from@example.com&to=recipient@example.com
+#notification-uri complete,needs-input,sync-error smtp://username:password@host:port/?from=from@example.com&to=recipient@example.com suppress-for 30s
 #notification-uri complete,sync-complete          generic+https://my.subsonic.com/rest/startScan.view?c=wrtag&v=1.16&u=user&p=password
 
 # set a list of files to keep when moving or copying

notifications/notifications.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"iter"
 	"log/slog"
+	"maps"
 	"net/url"
 	"time"
 
@@ -16,42 +18,63 @@ var (
 	ErrInvalidURI = errors.New("invalid URI")
 )
 
+type Destination struct {
+	URI         string
+	SuppressFor time.Duration // wait this long after manual actions before sending
+}
+
 type Notifications struct {
-	mappings map[string][]string
+	mappings map[string][]Destination
 }
 
-func (n *Notifications) AddURI(event string, uri string) error {
+func (n *Notifications) AddDestination(event string, uri string, suppressFor time.Duration) error {
 	if n.mappings == nil {
-		n.mappings = map[string][]string{}
+		n.mappings = map[string][]Destination{}
 	}
 	if _, err := url.Parse(uri); err != nil {
 		return fmt.Errorf("parse uri: %w", err)
 	}
-	n.mappings[event] = append(n.mappings[event], uri)
+	n.mappings[event] = append(n.mappings[event], Destination{URI: uri, SuppressFor: suppressFor})
 	return nil
 }
 
-func (n *Notifications) IterMappings(f func(string, string)) {
-	for event, uris := range n.mappings {
-		for _, uri := range uris {
-			f(event, uri)
+func (n *Notifications) Destinations() iter.Seq2[string, Destination] {
+	mappings := maps.Clone(n.mappings)
+
+	return func(yield func(string, Destination) bool) {
+		for event, destinations := range mappings {
+			for _, destination := range destinations {
+				if !yield(event, destination) {
+					return
+				}
+			}
 		}
 	}
 }
+
 func (n *Notifications) Sendf(ctx context.Context, event string, f string, a ...any) {
 	n.Send(ctx, event, fmt.Sprintf(f, a...))
 }
 
 // Send a simple string for now, maybe later message could instead be a type which
 // implements a notifications.Bodyer or something so that notifiers can send rich notifications.
 func (n *Notifications) Send(ctx context.Context, event string, message string) {
-	if actionTime, ok := ctx.Value(actionKey{}).(time.Time); ok && time.Since(actionTime) < 30*time.Second {
-		slog.DebugContext(ctx, "suppressing notification for recent manual action",
-			"event", event, "since_manual", time.Since(actionTime))
+	destinations := n.mappings[event]
+	if len(destinations) == 0 {
 		return
 	}
 
-	uris := n.mappings[event]
+	var timeSinceAction time.Duration
+	if actionTime, ok := ctx.Value(actionKey{}).(time.Time); ok {
+		timeSinceAction = time.Since(actionTime)
+	}
+
+	var uris []string
+	for _, dest := range destinations {
+		if timeSinceAction == 0 || timeSinceAction >= dest.SuppressFor {
+			uris = append(uris, dest.URI)
+		}
+	}
 	if len(uris) == 0 {
 		return
 	}