🥊🛀🏼 ↝ [SSG-270 SSG-280]: Notifications are now logged weekly to prevent duplications

Author: Gizmotronn

public/sw.js

@@ -13,11 +13,27 @@ self.addEventListener("push", function (event) {
     const title = data?.title || "New Discovery!";
     const options = {
         body: data?.body || "A new anomaly has been unlocked",
-        icon: data?.icon || '/assets/Captn.jpg',
-        badge: data?.icon || '/assets/Captn.jpg',
-        data: { url: data?.url || "/" },
-        requireInteraction: true,
-        silent: false
+        icon: data?.icon || '/assets/Captn.jpg', // Use Captn.jpg as fallback
+        badge: data?.badge || '/assets/Captn.jpg', // Badge for Android
+        image: data?.image || '/assets/Captn.jpg', // Large image for rich notifications
+        data: { 
+            url: data?.url || "/",
+            action: 'default'
+        },
+        tag: data?.tag || 'discovery-notification', // Prevent notification stacking
+        requireInteraction: data?.requireInteraction || true,
+        silent: false,
+        vibrate: [200, 100, 200], // Vibration pattern for Android
+        actions: data?.actions || [
+            {
+                action: 'classify',
+                title: '🔬 Classify Now'
+            },
+            {
+                action: 'dismiss', 
+                title: 'Later'
+            }
+        ]
     };
 
     console.log('Showing notification:', title, options);
@@ -34,7 +50,33 @@ self.addEventListener("push", function (event) {
 });
 
 self.addEventListener("notificationclick", function (event) {
-    console.log('Notification clicked:', event.notification);
+    console.log('Notification clicked:', event.notification, 'Action:', event.action);
+    
     event.notification.close();
-    event.waitUntil(clients.openWindow(event.notification.data.url));
+    
+    let targetUrl = event.notification.data.url || '/';
+    
+    // Handle different actions
+    if (event.action === 'classify') {
+        targetUrl = '/structures/telescope'; // Direct to classification page
+    } else if (event.action === 'dismiss') {
+        // Just close the notification, don't open anything
+        return;
+    }
+    
+    event.waitUntil(
+        clients.matchAll({ type: 'window', includeUncontrolled: true })
+            .then(clientList => {
+                // Check if there's already a window open
+                for (let client of clientList) {
+                    if (client.url.includes(self.location.origin) && 'focus' in client) {
+                        // Focus existing window and navigate
+                        client.focus();
+                        return client.navigate(targetUrl);
+                    }
+                }
+                // No existing window, open a new one
+                return clients.openWindow(targetUrl);
+            })
+    );
 });

scripts/notify-unclassified-discoveries.js

@@ -19,7 +19,7 @@ const supabase = createClient(supabaseUrl, supabaseServiceKey);
 
 // Configure webpush
 webpush.setVapidDetails(
-  'mailto:admin@starsailors.app',
+  'mailto:teddy@scroobl.es',
   vapidPublicKey,
   vapidPrivateKey
 );
@@ -48,6 +48,19 @@ async function findUsersWithUnclassifiedDiscoveries() {
 
     console.log(`Found ${linkedAnomalies?.length || 0} linked anomalies`);
 
+    // Get already notified anomalies from push_anomaly_log
+    const { data: notifiedAnomalies, error: notifiedError } = await supabase
+      .from('push_anomaly_log')
+      .select('anomaly_id');
+
+    if (notifiedError) {
+      console.error('Error fetching notified anomalies:', notifiedError);
+      return [];
+    }
+
+    console.log(`Found ${notifiedAnomalies?.length || 0} already notified anomalies`);
+    const notifiedAnomalyIds = new Set(notifiedAnomalies?.map(log => log.anomaly_id) || []);
+
     // Get all classifications
     const { data: classifications, error: classError } = await supabase
       .from('classifications')
@@ -75,12 +88,18 @@ async function findUsersWithUnclassifiedDiscoveries() {
     linkedAnomalies?.forEach(linkedAnomaly => {
       const userId = linkedAnomaly.author;
       const anomalyId = linkedAnomaly.anomaly_id;
+      const linkedAnomalyId = linkedAnomaly.id;
 
+      // Skip if already notified about this linked anomaly
+      if (notifiedAnomalyIds.has(linkedAnomalyId)) {
+        return;
+      }
+
       // Check if this user has classified this specific anomaly
       const userClassifications = userClassifiedAnomalies.get(userId) || new Set();
 
       if (!userClassifications.has(anomalyId)) {
-        // This is an unclassified discovery
+        // This is an unclassified discovery that hasn't been notified about
         if (!usersWithUnclassified.has(userId)) {
           usersWithUnclassified.set(userId, []);
         }
@@ -94,7 +113,7 @@ async function findUsersWithUnclassifiedDiscoveries() {
       }
     });
 
-    console.log(`Found ${usersWithUnclassified.size} users with unclassified discoveries`);
+    console.log(`Found ${usersWithUnclassified.size} users with unclassified discoveries (excluding already notified)`);
 
     return Array.from(usersWithUnclassified.entries()).map(([userId, discoveries]) => ({
       userId,
@@ -107,6 +126,34 @@ async function findUsersWithUnclassifiedDiscoveries() {
   }
 }
 
+async function logNotifiedAnomalies(discoveries) {
+  try {
+    if (discoveries.length === 0) return;
+
+    console.log(`Logging ${discoveries.length} anomalies as notified...`);
+    
+    const logEntries = discoveries.map(discovery => ({
+      anomaly_id: discovery.linkedAnomalyId
+    }));
+
+    const { data, error } = await supabase
+      .from('push_anomaly_log')
+      .insert(logEntries)
+      .select();
+
+    if (error) {
+      console.error('Error logging notified anomalies:', error);
+      return false;
+    }
+
+    console.log(`Successfully logged ${data?.length || 0} anomalies as notified`);
+    return true;
+  } catch (error) {
+    console.error('Error in logNotifiedAnomalies:', error);
+    return false;
+  }
+}
+
 async function sendNotificationsToUser(userId, discoveries) {
   try {
     // Get user's push subscriptions with deduplication by endpoint
@@ -151,8 +198,22 @@ async function sendNotificationsToUser(userId, discoveries) {
     const payload = JSON.stringify({
       title,
       body,
-      icon: '/assets/Captn.jpg',
-      url: '/structures/telescope' // Or wherever users go to classify
+      icon: '/assets/Captn.jpg', // Keep using Captn.jpg for both iOS and Android
+      badge: '/assets/Captn.jpg', // Badge for Android
+      image: '/assets/Captn.jpg', // Large image for rich notifications
+      url: '/structures/telescope', // Or wherever users go to classify
+      tag: 'unclassified-discoveries', // Prevent multiple notifications from stacking
+      requireInteraction: true, // Keep notification visible until user interacts
+      actions: [
+        {
+          action: 'classify',
+          title: '🔬 Classify Now'
+        },
+        {
+          action: 'dismiss',
+          title: 'Later'
+        }
+      ]
     });
 
     // Send notifications to all user's endpoints
@@ -179,6 +240,14 @@ async function sendNotificationsToUser(userId, discoveries) {
     const successful = results.filter(r => r.success).length;
     const failed = results.filter(r => !r.success).length;
 
+    if (successful > 0) {
+      // Log the anomalies as notified only if at least one notification was successful
+      const logged = await logNotifiedAnomalies(discoveries);
+      if (!logged) {
+        console.warn(`Failed to log anomalies for user ${userId}, but notifications were sent`);
+      }
+    }
+
     console.log(`User ${userId}: ${successful} notifications sent, ${failed} failed`);
     return { success: true, sent: successful, failed };
 

supabase/migrations/20250811040753_create_push_anomaly_log_fixed.sql

@@ -0,0 +1,28 @@
+-- Create push_anomaly_log table to track which anomalies have been notified about
+create table if not exists public.push_anomaly_log (
+  id uuid not null default gen_random_uuid (),
+  anomaly_id bigint not null,
+  sent_at timestamp with time zone null default now(),
+  constraint push_anomaly_log_pkey primary key (id),
+  constraint unique_anomaly_push_log unique (anomaly_id),
+  constraint push_anomaly_log_anomaly_id_fkey foreign key (anomaly_id) references linked_anomalies (id) on delete cascade
+) tablespace pg_default;
+
+-- Enable RLS
+alter table public.push_anomaly_log enable row level security;
+
+-- Create policy to allow service role to manage logs
+do $$
+begin
+  if not exists (select 1 from pg_policies where tablename = 'push_anomaly_log' and policyname = 'Service role can manage push anomaly logs') then
+    create policy "Service role can manage push anomaly logs"
+      on public.push_anomaly_log
+      for all
+      using (auth.role() = 'service_role');
+  end if;
+end
+$$;
+
+-- Add index for efficient querying
+create index if not exists idx_push_anomaly_log_anomaly_id on public.push_anomaly_log (anomaly_id);
+create index if not exists idx_push_anomaly_log_sent_at on public.push_anomaly_log (sent_at);