diff --git a/service/notification/dispatcher.go b/service/notification/dispatcher.go
index 78c3fd1..7c76ee6 100644
--- a/service/notification/dispatcher.go
+++ b/service/notification/dispatcher.go
@@ -8,6 +8,8 @@ import (
"net/http"
"prism/service/signal"
+
+ webpush "github.com/SherClockHolmes/webpush-go"
)
type Dispatcher struct {
@@ -24,33 +26,31 @@ func NewDispatcher(store *Store, signalClient *signal.Client, logger *slog.Logge
}
}
-func (d *Dispatcher) Send(endpoint string, notif Notification) error {
- mapping, err := d.store.GetEndpointMapping(endpoint)
+func (d *Dispatcher) Send(appName string, notif Notification) error {
+ mapping, err := d.store.GetApp(appName)
if err != nil {
- d.logger.Error("Failed to get endpoint mapping", "endpoint", endpoint, "error", err)
+ d.logger.Error("Failed to get app mapping", "app", appName, "error", err)
return fmt.Errorf("failed to get mapping: %w", err)
}
if mapping == nil {
- d.logger.Info("No mapping found for endpoint, creating new registration", "endpoint", endpoint)
+ d.logger.Info("Registering new app", "app", appName)
- d.logger.Info("Registering new endpoint", "endpoint", endpoint, "appName", endpoint, "channel", ChannelSignal)
-
- if err := d.store.Register(endpoint, endpoint, ChannelSignal, nil, nil); err != nil {
- d.logger.Error("Failed to register endpoint", "endpoint", endpoint, "error", err)
- return fmt.Errorf("failed to register endpoint: %w", err)
+ if err := d.store.RegisterDefault(appName); err != nil {
+ d.logger.Error("Failed to register app", "app", appName, "error", err)
+ return fmt.Errorf("failed to register app: %w", err)
}
- mapping, err = d.store.GetEndpointMapping(endpoint)
+ mapping, err = d.store.GetApp(appName)
if err != nil {
- d.logger.Error("Failed to get mapping after registration", "endpoint", endpoint, "error", err)
+ d.logger.Error("Failed to get mapping after registration", "app", appName, "error", err)
return fmt.Errorf("failed to get mapping after registration: %w", err)
}
}
switch mapping.Channel {
- case ChannelWebhook:
- return d.sendWebhook(mapping, notif)
+ case ChannelWebPush:
+ return d.sendWebPush(mapping, notif)
case ChannelSignal:
return d.sendSignal(mapping, notif)
default:
@@ -60,39 +60,63 @@ func (d *Dispatcher) Send(endpoint string, notif Notification) error {
}
func (d *Dispatcher) sendSignal(mapping *Mapping, notif Notification) error {
- groupID := mapping.GroupID
- if groupID == nil || *groupID == "" {
- d.logger.Info("No group ID found, creating new group", "appName", mapping.AppName)
-
- newGroupID, err := d.createGroup(mapping.AppName)
- if err != nil {
- d.logger.Error("Failed to create group", "appName", mapping.AppName, "error", err)
- return fmt.Errorf("failed to create group: %w", err)
- }
- groupID = &newGroupID
-
- d.logger.Info("Created new group", "appName", mapping.AppName, "groupID", *groupID)
-
- if err := d.store.UpdateGroupID(mapping.Endpoint, *groupID); err != nil {
- d.logger.Warn("Failed to update group ID", "error", err)
- }
+ account, err := d.signalClient.GetLinkedAccount()
+ if err != nil {
+ d.logger.Error("Failed to get linked account", "error", err)
+ return fmt.Errorf("failed to get linked account: %w", err)
+ }
+ if account == nil {
+ d.logger.Error("No linked Signal account found")
+ return fmt.Errorf("no linked Signal account")
}
- if err := d.sendGroupMessage(*groupID, notif); err != nil {
- d.logger.Error("Failed to send group message", "groupID", *groupID, "error", err)
- return fmt.Errorf("failed to send group message: %w", err)
+ var signalGroupID string
+ needsNewGroup := mapping.Signal == nil || mapping.Signal.GroupID == ""
+
+ if !needsNewGroup && mapping.Signal.Account != account.Number {
+ d.logger.Info("Signal account changed, recreating group",
+ "app", mapping.AppName,
+ "oldAccount", mapping.Signal.Account,
+ "newAccount", account.Number)
+ needsNewGroup = true
+ }
+
+ if needsNewGroup {
+ d.logger.Info("Creating new group", "app", mapping.AppName, "account", account.Number)
+
+ newGroupID, accountNumber, err := d.createGroup(mapping.AppName)
+ if err != nil {
+ d.logger.Error("Failed to create group", "app", mapping.AppName, "error", err)
+ return fmt.Errorf("failed to create group: %w", err)
+ }
+ signalGroupID = newGroupID
+
+ d.logger.Info("Created new group", "app", mapping.AppName, "groupID", signalGroupID, "account", accountNumber)
+
+ if err := d.store.UpdateSignal(mapping.AppName, &SignalSubscription{
+ GroupID: signalGroupID,
+ Account: accountNumber,
+ }); err != nil {
+ d.logger.Warn("Failed to update signal subscription", "error", err)
+ }
+ } else {
+ signalGroupID = mapping.Signal.GroupID
+ }
+
+ if err := d.sendGroupMessage(signalGroupID, notif); err != nil {
+ d.logger.Error("Failed to send group message", "groupID", signalGroupID, "error", err)
}
return nil
}
-func (d *Dispatcher) createGroup(appName string) (string, error) {
+func (d *Dispatcher) createGroup(appName string) (string, string, error) {
account, err := d.signalClient.GetLinkedAccount()
if err != nil {
- return "", fmt.Errorf("failed to get linked account: %w", err)
+ return "", "", fmt.Errorf("failed to get linked account: %w", err)
}
if account == nil {
- return "", fmt.Errorf("no linked Signal account")
+ return "", "", fmt.Errorf("no linked Signal account")
}
params := map[string]interface{}{
@@ -102,21 +126,21 @@ func (d *Dispatcher) createGroup(appName string) (string, error) {
result, err := d.signalClient.CallWithAccount("updateGroup", params, account.Number)
if err != nil {
- return "", err
+ return "", "", err
}
var response struct {
GroupID string `json:"groupId"`
}
if err := json.Unmarshal(result, &response); err != nil {
- return "", fmt.Errorf("failed to parse updateGroup response: %w", err)
+ return "", "", fmt.Errorf("failed to parse updateGroup response: %w", err)
}
if response.GroupID == "" {
- return "", fmt.Errorf("empty groupId in response")
+ return "", "", fmt.Errorf("empty groupId in response")
}
- return response.GroupID, nil
+ return response.GroupID, account.Number, nil
}
func (d *Dispatcher) sendGroupMessage(groupID string, notif Notification) error {
@@ -148,9 +172,9 @@ func (d *Dispatcher) sendGroupMessage(groupID string, notif Notification) error
return err
}
-func (d *Dispatcher) sendWebhook(mapping *Mapping, notif Notification) error {
- if mapping.UpEndpoint == nil || *mapping.UpEndpoint == "" {
- return fmt.Errorf("webhook endpoint not configured for %s", mapping.AppName)
+func (d *Dispatcher) sendWebPush(mapping *Mapping, notif Notification) error {
+ if mapping.WebPush == nil {
+ return fmt.Errorf("no push endpoint configured for %s", mapping.AppName)
}
payload, err := json.Marshal(notif)
@@ -158,16 +182,42 @@ func (d *Dispatcher) sendWebhook(mapping *Mapping, notif Notification) error {
return fmt.Errorf("failed to marshal notification: %w", err)
}
- resp, err := http.Post(*mapping.UpEndpoint, "application/json", bytes.NewReader(payload))
- if err != nil {
- return fmt.Errorf("failed to send webhook: %w", err)
- }
- defer resp.Body.Close()
+ if mapping.WebPush.HasEncryption() {
+ subscription := &webpush.Subscription{
+ Endpoint: mapping.WebPush.Endpoint,
+ Keys: webpush.Keys{
+ P256dh: mapping.WebPush.P256dh,
+ Auth: mapping.WebPush.Auth,
+ },
+ }
- if resp.StatusCode < 200 || resp.StatusCode >= 300 {
- return fmt.Errorf("webhook returned status %d", resp.StatusCode)
+ resp, err := webpush.SendNotification(payload, subscription, &webpush.Options{
+ VAPIDPrivateKey: mapping.WebPush.VapidPrivateKey,
+ TTL: 86400,
+ })
+ if err != nil {
+ return fmt.Errorf("failed to send webpush: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ return fmt.Errorf("webpush returned status %d", resp.StatusCode)
+ }
+
+ d.logger.Debug("Sent encrypted webpush notification", "app", mapping.AppName, "url", mapping.WebPush.Endpoint)
+ } else {
+ resp, err := http.Post(mapping.WebPush.Endpoint, "application/json", bytes.NewBuffer(payload))
+ if err != nil {
+ return fmt.Errorf("failed to send webhook: %w", err)
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ return fmt.Errorf("webhook returned status %d", resp.StatusCode)
+ }
+
+ d.logger.Debug("Sent plain webhook notification", "app", mapping.AppName, "url", mapping.WebPush.Endpoint)
}
- d.logger.Debug("Sent webhook notification", "app", mapping.AppName, "endpoint", *mapping.UpEndpoint)
return nil
}
diff --git a/service/notification/notification.go b/service/notification/notification.go
index 51d8791..8e87831 100644
--- a/service/notification/notification.go
+++ b/service/notification/notification.go
@@ -17,13 +17,28 @@ type Channel string
const (
ChannelSignal Channel = "signal"
- ChannelWebhook Channel = "webhook"
+ ChannelWebPush Channel = "webpush"
)
-type Mapping struct {
- Endpoint string
- AppName string
- Channel Channel
- GroupID *string
- UpEndpoint *string
+type WebPushSubscription struct {
+ Endpoint string
+ P256dh string
+ Auth string
+ VapidPrivateKey string
+}
+
+func (w *WebPushSubscription) HasEncryption() bool {
+ return w.P256dh != "" && w.Auth != "" && w.VapidPrivateKey != ""
+}
+
+type SignalSubscription struct {
+ GroupID string
+ Account string
+}
+
+type Mapping struct {
+ AppName string
+ Channel Channel
+ Signal *SignalSubscription
+ WebPush *WebPushSubscription
}
diff --git a/service/notification/store.go b/service/notification/store.go
index b56d3e2..76da5a4 100644
--- a/service/notification/store.go
+++ b/service/notification/store.go
@@ -39,11 +39,14 @@ func NewStore(dbPath string) (*Store, error) {
func (s *Store) createTables() error {
query := `
CREATE TABLE IF NOT EXISTS mappings (
- endpoint TEXT PRIMARY KEY,
- groupId TEXT,
- appName TEXT NOT NULL,
+ appName TEXT PRIMARY KEY,
+ signalGroupId TEXT,
+ signalAccount TEXT,
channel TEXT NOT NULL DEFAULT 'signal',
- upEndpoint TEXT
+ pushEndpoint TEXT,
+ p256dh TEXT,
+ auth TEXT,
+ vapidPrivateKey TEXT
)
`
_, err := s.db.Exec(query)
@@ -57,26 +60,57 @@ func (s *Store) Close() error {
return s.db.Close()
}
-func (s *Store) Register(endpoint, appName string, channel Channel, groupID, upEndpoint *string) error {
+func (s *Store) Register(appName string, channel *Channel, signal *SignalSubscription, webPush *WebPushSubscription) error {
+ var signalGroupID, signalAccount *string
+ if signal != nil {
+ signalGroupID = &signal.GroupID
+ signalAccount = &signal.Account
+ }
+
+ var pushEndpoint, p256dh, auth, vapidPrivateKey *string
+ if webPush != nil {
+ pushEndpoint = &webPush.Endpoint
+ p256dh = &webPush.P256dh
+ auth = &webPush.Auth
+ vapidPrivateKey = &webPush.VapidPrivateKey
+ }
+
+ ch := ChannelSignal
+ if channel != nil {
+ ch = *channel
+ }
+
query := `
- INSERT OR IGNORE INTO mappings (endpoint, groupId, appName, channel, upEndpoint)
- VALUES (?, ?, ?, ?, ?)
+ INSERT INTO mappings (appName, signalGroupId, signalAccount, channel, pushEndpoint, p256dh, auth, vapidPrivateKey)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ON CONFLICT(appName) DO UPDATE SET
+ channel = excluded.channel,
+ signalGroupId = excluded.signalGroupId,
+ signalAccount = excluded.signalAccount,
+ pushEndpoint = excluded.pushEndpoint,
+ p256dh = excluded.p256dh,
+ auth = excluded.auth,
+ vapidPrivateKey = excluded.vapidPrivateKey
`
- _, err := s.db.Exec(query, endpoint, groupID, appName, channel, upEndpoint)
+ _, err := s.db.Exec(query, appName, signalGroupID, signalAccount, ch, pushEndpoint, p256dh, auth, vapidPrivateKey)
return err
}
-func (s *Store) GetEndpointMapping(endpoint string) (*Mapping, error) {
+func (s *Store) RegisterDefault(appName string) error {
+ return s.Register(appName, nil, nil, nil)
+}
+
+func (s *Store) GetApp(appName string) (*Mapping, error) {
query := `
- SELECT endpoint, groupId, appName, channel, upEndpoint
+ SELECT appName, signalGroupId, signalAccount, channel, pushEndpoint, p256dh, auth, vapidPrivateKey
FROM mappings
- WHERE endpoint = ?
+ WHERE appName = ?
`
- row := s.db.QueryRow(query, endpoint)
+ row := s.db.QueryRow(query, appName)
var m Mapping
- var groupID, upEndpoint sql.NullString
- err := row.Scan(&m.Endpoint, &groupID, &m.AppName, &m.Channel, &upEndpoint)
+ var signalGroupID, signalAccount, pushEndpoint, p256dh, auth, vapidPrivateKey sql.NullString
+ err := row.Scan(&m.AppName, &signalGroupID, &signalAccount, &m.Channel, &pushEndpoint, &p256dh, &auth, &vapidPrivateKey)
if err == sql.ErrNoRows {
return nil, nil
}
@@ -84,11 +118,25 @@ func (s *Store) GetEndpointMapping(endpoint string) (*Mapping, error) {
return nil, err
}
- if groupID.Valid {
- m.GroupID = &groupID.String
+ if signalGroupID.Valid && signalAccount.Valid {
+ m.Signal = &SignalSubscription{
+ GroupID: signalGroupID.String,
+ Account: signalAccount.String,
+ }
}
- if upEndpoint.Valid {
- m.UpEndpoint = &upEndpoint.String
+ if pushEndpoint.Valid {
+ m.WebPush = &WebPushSubscription{
+ Endpoint: pushEndpoint.String,
+ }
+ if p256dh.Valid {
+ m.WebPush.P256dh = p256dh.String
+ }
+ if auth.Valid {
+ m.WebPush.Auth = auth.String
+ }
+ if vapidPrivateKey.Valid {
+ m.WebPush.VapidPrivateKey = vapidPrivateKey.String
+ }
}
return &m, nil
@@ -96,7 +144,7 @@ func (s *Store) GetEndpointMapping(endpoint string) (*Mapping, error) {
func (s *Store) GetAllMappings() ([]Mapping, error) {
query := `
- SELECT endpoint, groupId, appName, channel, upEndpoint
+ SELECT appName, signalGroupId, signalAccount, channel, pushEndpoint, p256dh, auth, vapidPrivateKey
FROM mappings
`
rows, err := s.db.Query(query)
@@ -108,16 +156,30 @@ func (s *Store) GetAllMappings() ([]Mapping, error) {
var mappings []Mapping
for rows.Next() {
var m Mapping
- var groupID, upEndpoint sql.NullString
- if err := rows.Scan(&m.Endpoint, &groupID, &m.AppName, &m.Channel, &upEndpoint); err != nil {
+ var signalGroupID, signalAccount, pushEndpoint, p256dh, auth, vapidPrivateKey sql.NullString
+ if err := rows.Scan(&m.AppName, &signalGroupID, &signalAccount, &m.Channel, &pushEndpoint, &p256dh, &auth, &vapidPrivateKey); err != nil {
return nil, err
}
- if groupID.Valid {
- m.GroupID = &groupID.String
+ if signalGroupID.Valid && signalAccount.Valid {
+ m.Signal = &SignalSubscription{
+ GroupID: signalGroupID.String,
+ Account: signalAccount.String,
+ }
}
- if upEndpoint.Valid {
- m.UpEndpoint = &upEndpoint.String
+ if pushEndpoint.Valid {
+ m.WebPush = &WebPushSubscription{
+ Endpoint: pushEndpoint.String,
+ }
+ if p256dh.Valid {
+ m.WebPush.P256dh = p256dh.String
+ }
+ if auth.Valid {
+ m.WebPush.Auth = auth.String
+ }
+ if vapidPrivateKey.Valid {
+ m.WebPush.VapidPrivateKey = vapidPrivateKey.String
+ }
}
mappings = append(mappings, m)
@@ -126,20 +188,48 @@ func (s *Store) GetAllMappings() ([]Mapping, error) {
return mappings, rows.Err()
}
-func (s *Store) UpdateChannel(endpoint string, channel Channel) error {
- query := `UPDATE mappings SET channel = ? WHERE endpoint = ?`
- _, err := s.db.Exec(query, channel, endpoint)
+func (s *Store) UpdateChannel(appName string, channel Channel) error {
+ query := `UPDATE mappings SET channel = ? WHERE appName = ?`
+ _, err := s.db.Exec(query, channel, appName)
return err
}
-func (s *Store) UpdateGroupID(endpoint string, groupID string) error {
- query := `UPDATE mappings SET groupId = ? WHERE endpoint = ?`
- _, err := s.db.Exec(query, groupID, endpoint)
+func (s *Store) UpdateSignal(appName string, signal *SignalSubscription) error {
+ if signal == nil {
+ return fmt.Errorf("signal cannot be nil")
+ }
+
+ query := `UPDATE mappings SET signalGroupId = ?, signalAccount = ? WHERE appName = ?`
+ _, err := s.db.Exec(query, signal.GroupID, signal.Account, appName)
return err
}
-func (s *Store) RemoveEndpoint(endpoint string) error {
- query := `DELETE FROM mappings WHERE endpoint = ?`
- _, err := s.db.Exec(query, endpoint)
+func (s *Store) UpdateWebPush(appName string, webPush *WebPushSubscription) error {
+ if webPush == nil {
+ return fmt.Errorf("webPush cannot be nil")
+ }
+
+ query := `
+ UPDATE mappings
+ SET pushEndpoint = ?, p256dh = ?, auth = ?, vapidPrivateKey = ?
+ WHERE appName = ?
+ `
+ _, err := s.db.Exec(query, webPush.Endpoint, webPush.P256dh, webPush.Auth, webPush.VapidPrivateKey, appName)
+ return err
+}
+
+func (s *Store) RemoveApp(appName string) error {
+ query := `DELETE FROM mappings WHERE appName = ?`
+ _, err := s.db.Exec(query, appName)
+ return err
+}
+
+func (s *Store) ClearWebPush(appName string) error {
+ query := `
+ UPDATE mappings
+ SET pushEndpoint = NULL, p256dh = NULL, auth = NULL, vapidPrivateKey = NULL, channel = 'signal'
+ WHERE appName = ?
+ `
+ _, err := s.db.Exec(query, appName)
return err
}
diff --git a/service/server/handlers_action.go b/service/server/handlers_action.go
index 1227616..8dd2635 100644
--- a/service/server/handlers_action.go
+++ b/service/server/handlers_action.go
@@ -4,28 +4,25 @@ import (
"net/http"
"prism/service/notification"
+
+ "github.com/go-chi/chi/v5"
)
-func (s *Server) handleDeleteEndpointAction(w http.ResponseWriter, r *http.Request) {
- if err := r.ParseForm(); err != nil {
- http.Error(w, "Invalid form data", http.StatusBadRequest)
+func (s *Server) handleDeleteAppAction(w http.ResponseWriter, r *http.Request) {
+ app := chi.URLParam(r, "appName")
+ if app == "" {
+ http.Error(w, "Missing app parameter", http.StatusBadRequest)
return
}
- endpoint := r.FormValue("endpoint")
- if endpoint == "" {
- http.Error(w, "Missing endpoint parameter", http.StatusBadRequest)
- return
- }
-
- if err := s.store.RemoveEndpoint(endpoint); err != nil {
- s.logger.Error("Failed to delete endpoint", "error", err)
- http.Error(w, "Failed to delete endpoint", http.StatusInternalServerError)
+ if err := s.store.RemoveApp(app); err != nil {
+ s.logger.Error("Failed to delete app", "error", err)
+ http.Error(w, "Failed to delete app", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/html")
- s.handleFragmentEndpoints(w, r)
+ s.handleFragmentApps(w, r)
}
func (s *Server) handleToggleChannelAction(w http.ResponseWriter, r *http.Request) {
@@ -34,25 +31,25 @@ func (s *Server) handleToggleChannelAction(w http.ResponseWriter, r *http.Reques
return
}
- endpoint := r.FormValue("endpoint")
+ app := r.FormValue("app")
channel := r.FormValue("channel")
- if endpoint == "" || channel == "" {
- http.Error(w, "Missing endpoint or channel parameter", http.StatusBadRequest)
+ if app == "" || channel == "" {
+ http.Error(w, "Missing app or channel parameter", http.StatusBadRequest)
return
}
- if channel != string(notification.ChannelSignal) && channel != string(notification.ChannelWebhook) {
+ if channel != string(notification.ChannelSignal) && channel != string(notification.ChannelWebPush) {
http.Error(w, "Invalid channel", http.StatusBadRequest)
return
}
- if err := s.store.UpdateChannel(endpoint, notification.Channel(channel)); err != nil {
+ if err := s.store.UpdateChannel(app, notification.Channel(channel)); err != nil {
s.logger.Error("Failed to update channel", "error", err)
http.Error(w, "Failed to update channel", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "text/html")
- s.handleFragmentEndpoints(w, r)
+ s.handleFragmentApps(w, r)
}
diff --git a/service/server/handlers_admin.go b/service/server/handlers_admin.go
index 6059775..6de1f5b 100644
--- a/service/server/handlers_admin.go
+++ b/service/server/handlers_admin.go
@@ -27,10 +27,9 @@ func (s *Server) handleGetMappings(w http.ResponseWriter, r *http.Request) {
}
type createMappingRequest struct {
- Endpoint string `json:"endpoint"`
- AppName string `json:"appName"`
- Channel notification.Channel `json:"channel"`
- UpEndpoint *string `json:"upEndpoint,omitempty"`
+ App string `json:"app"`
+ Channel notification.Channel `json:"channel"`
+ PushEndpoint *string `json:"pushEndpoint,omitempty"`
}
func (s *Server) handleCreateMapping(w http.ResponseWriter, r *http.Request) {
@@ -40,7 +39,7 @@ func (s *Server) handleCreateMapping(w http.ResponseWriter, r *http.Request) {
return
}
- if req.Endpoint == "" || req.AppName == "" {
+ if req.App == "" {
http.Error(w, "Missing required fields", http.StatusBadRequest)
return
}
@@ -49,12 +48,19 @@ func (s *Server) handleCreateMapping(w http.ResponseWriter, r *http.Request) {
req.Channel = notification.ChannelSignal
}
- if req.Channel == notification.ChannelWebhook && req.UpEndpoint == nil {
- http.Error(w, "upEndpoint required for webhook channel", http.StatusBadRequest)
+ if req.Channel == notification.ChannelWebPush && req.PushEndpoint == nil {
+ http.Error(w, "pushEndpoint required for webpush channel", http.StatusBadRequest)
return
}
- if err := s.store.Register(req.Endpoint, req.AppName, req.Channel, nil, req.UpEndpoint); err != nil {
+ var webPush *notification.WebPushSubscription
+ if req.Channel == notification.ChannelWebPush && req.PushEndpoint != nil {
+ webPush = ¬ification.WebPushSubscription{
+ Endpoint: *req.PushEndpoint,
+ }
+ }
+
+ if err := s.store.Register(req.App, &req.Channel, nil, webPush); err != nil {
s.logger.Error("Failed to register mapping", "error", err)
http.Error(w, "Failed to create mapping", http.StatusInternalServerError)
return
@@ -67,13 +73,13 @@ func (s *Server) handleCreateMapping(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) handleDeleteMapping(w http.ResponseWriter, r *http.Request) {
- endpoint := chi.URLParam(r, "endpoint")
- if endpoint == "" {
- http.Error(w, "Missing endpoint parameter", http.StatusBadRequest)
+ appName := chi.URLParam(r, "appName")
+ if appName == "" {
+ http.Error(w, "Missing appName parameter", http.StatusBadRequest)
return
}
- if err := s.store.RemoveEndpoint(endpoint); err != nil {
+ if err := s.store.RemoveApp(appName); err != nil {
s.logger.Error("Failed to delete mapping", "error", err)
http.Error(w, "Failed to delete mapping", http.StatusInternalServerError)
return
@@ -88,9 +94,9 @@ type updateChannelRequest struct {
}
func (s *Server) handleUpdateChannel(w http.ResponseWriter, r *http.Request) {
- endpoint := chi.URLParam(r, "endpoint")
- if endpoint == "" {
- http.Error(w, "Missing endpoint parameter", http.StatusBadRequest)
+ appName := chi.URLParam(r, "appName")
+ if appName == "" {
+ http.Error(w, "Missing appName parameter", http.StatusBadRequest)
return
}
@@ -100,12 +106,12 @@ func (s *Server) handleUpdateChannel(w http.ResponseWriter, r *http.Request) {
return
}
- if req.Channel == notification.ChannelWebhook && req.UpEndpoint == nil {
- http.Error(w, "upEndpoint required for webhook channel", http.StatusBadRequest)
+ if req.Channel == notification.ChannelWebPush && req.UpEndpoint == nil {
+ http.Error(w, "upEndpoint required for webpush channel", http.StatusBadRequest)
return
}
- if err := s.store.UpdateChannel(endpoint, req.Channel); err != nil {
+ if err := s.store.UpdateChannel(appName, req.Channel); err != nil {
s.logger.Error("Failed to update channel", "error", err)
http.Error(w, "Failed to update channel", http.StatusInternalServerError)
return
@@ -132,7 +138,7 @@ func (s *Server) handleGetStats(w http.ResponseWriter, r *http.Request) {
"uptimeSeconds": int(uptime.Seconds()),
"mappingsCount": len(mappings),
"signalCount": countByChannel(mappings, notification.ChannelSignal),
- "webhookCount": countByChannel(mappings, notification.ChannelWebhook),
+ "webpushCount": countByChannel(mappings, notification.ChannelWebPush),
"protonEnabled": s.cfg.IsProtonEnabled(),
}
diff --git a/service/server/handlers_fragment.go b/service/server/handlers_fragment.go
index 56183a4..18df732 100644
--- a/service/server/handlers_fragment.go
+++ b/service/server/handlers_fragment.go
@@ -44,11 +44,30 @@ func (s *Server) handleFragmentHealth(w http.ResponseWriter, r *http.Request) {
Proton Mail: %s%s
`, protonClass, protonStatus, protonTooltip)
}
- html += `
`
+ currentLinked := linked != nil
+ if s.lastSignalLinked == nil || *s.lastSignalLinked != currentLinked {
+ html += `
+
`
+ s.lastSignalLinked = ¤tLinked
+ }
+
+ // Check if apps changed
+ mappings, err := s.store.GetAllMappings()
+ if err == nil {
+ currentAppsCount := len(mappings)
+ if s.lastAppsCount == nil || *s.lastAppsCount != currentAppsCount {
+ html += `
+
`
+ s.lastAppsCount = ¤tAppsCount
+ }
+ }
+
_, _ = fmt.Fprint(w, html) //nolint:errcheck // Error writing to ResponseWriter is handled by HTTP server
}
@@ -98,7 +117,7 @@ func (s *Server) getQRCodeHTML() string {