Merge pull request #9 from biranchikulesika/fix/ContributionsCount

Fixed contributions count local storage

Author: biranchikulesika

frontend/components/lipyd/ContributorSetup.tsx

@@ -2,7 +2,7 @@
 import React, { useState, useEffect } from 'react';
 import CharacterSearch from './CharacterSearch';
 import { generateSessionId } from '@/lib/lipyd/filenameService';
-import { getAllSamples, saveContributor } from '@/lib/lipyd/storageService';
+import { saveContributor, getLifetimeCount, clearContributorData, getUploadedSampleCount } from '@/lib/lipyd/storageService';
 import { OdiaCharacter } from '@/lib/lipyd/odiaCharacters';
 import { exportDataset } from '@/lib/lipyd/exportService';
 
@@ -75,6 +75,23 @@ export default function ContributorSetup({ onStart, isSearchFocused, onSearchFoc
 
   useEffect(() => {
     if (!contributorId) {
+      try {
+        const savedId = getCookie('lipy_contributorId');
+        if (savedId) {
+          setContributorId(savedId);
+          return;
+        }
+      } catch (e) { }
+      try {
+        const raw = localStorage.getItem('lipy_session_config');
+        if (raw) {
+          const cfg = JSON.parse(raw);
+          if (cfg?.contributorId) {
+            setContributorId(cfg.contributorId);
+            return;
+          }
+        }
+      } catch (e) { }
       try {
         const id = typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : `c_${Math.random().toString(36).slice(2, 9)}`;
         setContributorId(id);
@@ -94,24 +111,14 @@ export default function ContributorSetup({ onStart, isSearchFocused, onSearchFoc
       }
 
       try {
-        const devKey = `lipy_device_sample_count_${String(contributorId || '').trim()}`;
-        const cachedDev = Number(localStorage.getItem(devKey) || 0) || 0;
-
-        const samples = await getAllSamples();
-        const dbCount = samples.filter((sample) => {
-          try {
-            const sCid = sample?.contributorId != null ? String(sample.contributorId).trim() : '';
-            const cCid = String(contributorId || '').trim();
-            return sCid && cCid && sCid === cCid;
-          } catch (e) {
-            return false;
-          }
-        }).length;
-
-        const count = Math.max(dbCount, cachedDev);
-        if (count > cachedDev) {
-            try { localStorage.setItem(devKey, String(count)); } catch(e) {}
-        }
+        // Lifetime count = successfully *synchronized* samples (durable across
+        // sessions).  We reconcile the localStorage cache with the IndexedDB
+        // uploaded count so the displayed number stays accurate even if one
+        // source was cleared.  Only uploaded samples count toward the lifetime
+        // total.
+        const cachedLifetime = getLifetimeCount(contributorId);
+        const uploadedCount = await getUploadedSampleCount(contributorId);
+        const count = Math.max(uploadedCount, cachedLifetime);
 
         if (mounted) setDeviceSampleCount(count);
       } catch (e) {
@@ -325,7 +332,7 @@ export default function ContributorSetup({ onStart, isSearchFocused, onSearchFoc
             <div className="text-base text-slate-400 mt-2">{leaveConfirmMsg || 'Clear saved contributor and start over?'}</div>
             <div className="mt-6 flex gap-3 justify-end">
               <button className="rounded-xl border border-verdigris-800 bg-verdigris-900 px-4 py-2 text-sm font-medium text-slate-300 hover:bg-verdigris-800" onClick={() => setShowLeaveConfirm(false)}>Cancel</button>
-              <button className="rounded-xl bg-verdigris-100 px-4 py-2 text-sm font-medium text-slate-900 hover:bg-verdigris-200" onClick={() => { deleteCookie('lipy_name'); deleteCookie('lipy_contributorId'); setName(''); setContributorId(''); setEditing(true); setShowLeaveConfirm(false); }}>Confirm</button>
+              <button className="rounded-xl bg-verdigris-100 px-4 py-2 text-sm font-medium text-slate-900 hover:bg-verdigris-200" onClick={() => { deleteCookie('lipy_name'); deleteCookie('lipy_contributorId'); clearContributorData(contributorId); setName(''); setContributorId(''); setEditing(true); setShowLeaveConfirm(false); }}>Confirm</button>
             </div>
           </div>
         </div>

frontend/lib/lipyd/datasetSyncService.ts

@@ -1,4 +1,4 @@
-import db, { getPendingUploadCount, updateSampleSyncState, SampleRecord } from './storageService';
+import db, { getPendingUploadCount, updateSampleSyncState, SampleRecord, incrementLifetimeCount } from './storageService';
 import { getSupabaseClient, isSupabaseConfigured } from './supabaseClient';
 import { odiaCharacters } from './odiaCharacters';
 import { ensureValidSessionId, isValidContributorName, isValidMode } from './validators';
@@ -286,6 +286,15 @@ async function markUploaded(item: any) {
     });
   }
   await db.uploadQueue.delete(item.clientSampleId);
+
+  // Increment the lifetime contribution count only after a successful upload.
+  // This ensures the lifetime stat reflects *synchronized* samples, not just
+  // locally-saved ones, and survives across sessions.
+  if (item?.contributorId) {
+    try {
+      incrementLifetimeCount(item.contributorId);
+    } catch (e) { }
+  }
 }
 
 async function markFailed(item: any, error: any) {

frontend/lib/lipyd/randomCharacterService.ts

@@ -1,5 +1,5 @@
 import { odiaCharacters, OdiaCharacter, CharacterType } from './odiaCharacters';
-import { getAllSamples } from './storageService';
+import { getAllSamples, getLifetimeCount, getContributorSampleCount } from './storageService';
 
 const STATE_VERSION = 1;
 const STORAGE_PREFIX = 'lipy_mixed_scheduler_state_v1_';
@@ -405,13 +405,13 @@ async function loadSessionTotals(sessionConfig: any) {
     }
   }
 
-  let cachedDev = 0;
-  try {
-    const devKey = `lipy_device_sample_count_${String(sessionConfig?.contributorId || '').trim()}`;
-    cachedDev = Number(localStorage.getItem(devKey) || 0) || 0;
-  } catch(e) {}
+  // Lifetime count reflects all completed samples (durable across sessions).
+  // Reconcile it with the IndexedDB count so the scheduler's baseline stays
+  // accurate even if localStorage was cleared.
+  const cachedLifetime = getLifetimeCount(sessionConfig?.contributorId || '');
+  const dbCount = await getContributorSampleCount(sessionConfig?.contributorId || '');
 
-  return { datasetCounts, contributorCompletedCount: Math.max(contributorCompletedCount, cachedDev) };
+  return { datasetCounts, contributorCompletedCount: Math.max(contributorCompletedCount, cachedLifetime, dbCount) };
 }
 
 async function ensureSessionState(sessionConfig: any) {

frontend/lib/lipyd/storageService.ts

@@ -1,4 +1,4 @@
-import Dexie, { Table } from 'dexie';
+import Dexie, { Table } from 'dexie';
 
 export interface SampleRecord {
   id?: number;
@@ -79,6 +79,11 @@ export class LiPyDatabase extends Dexie {
       contributors: '++id,contributorId,sessionId,[contributorId+sessionId]',
       uploadQueue: 'clientSampleId,contributorId,sessionId,characterId,status,nextAttemptAt,updatedAt',
     });
+    this.version(5).stores({
+      samples: '++id,clientSampleId,characterId,contributorId,sessionId,filename,timestamp,syncStatus,uploadedAt,[characterId+contributorId+sessionId],[contributorId+syncStatus]',
+      contributors: '++id,contributorId,sessionId,[contributorId+sessionId]',
+      uploadQueue: 'clientSampleId,contributorId,sessionId,characterId,status,nextAttemptAt,updatedAt',
+    });
   }
 }
 
@@ -102,13 +107,11 @@ export async function saveSample(sample: Omit<SampleRecord, 'id'>) {
     uploadedAt: sample?.uploadedAt || null,
   };
   const id = await db.samples.add(record);
+  // Session statistics reset per session; lifetime statistics are incremented
+  // only after a sample has been successfully synchronized (see
+  // datasetSyncService.markUploaded -> incrementLifetimeCount).
   try {
-    const devKey = `lipy_device_sample_count_${record.contributorId}`;
     const sessKey = `lipy_session_sample_count_${record.contributorId}_${record.sessionId}`;
-    try {
-      const prevDev = Number(localStorage.getItem(devKey) || 0) || 0;
-      localStorage.setItem(devKey, String(prevDev + 1));
-    } catch (e) { }
     try {
       const prevSess = Number(localStorage.getItem(sessKey) || 0) || 0;
       localStorage.setItem(sessKey, String(prevSess + 1));
@@ -163,4 +166,124 @@ export async function getPendingUploadCount() {
   return db.uploadQueue.count();
 }
 
+/**
+ * Lifetime contribution count helpers.
+ *
+ * The lifetime count represents the total number of samples a contributor has
+ * *synchronized* (uploaded) across all sessions. It is stored in localStorage
+ * under `lipy_device_sample_count_{contributorId}` and is incremented only
+ * after a successful upload (see datasetSyncService.markUploaded). This
+ * ensures the count persists across sessions, only ever increases on sync,
+ * and is cleared by Reset Profile or by clearing browser storage.
+ */
+
+export function getLifetimeCount(contributorId: string): number {
+  if (!contributorId) return 0;
+  try {
+    const key = `lipy_device_sample_count_${String(contributorId).trim()}`;
+    return Number(localStorage.getItem(key) || 0) || 0;
+  } catch (e) {
+    return 0;
+  }
+}
+
+export function incrementLifetimeCount(contributorId: string): number {
+  if (!contributorId) return 0;
+  try {
+    const key = `lipy_device_sample_count_${String(contributorId).trim()}`;
+    const prev = Number(localStorage.getItem(key) || 0) || 0;
+    const next = prev + 1;
+    localStorage.setItem(key, String(next));
+    return next;
+  } catch (e) {
+    return 0;
+  }
+}
+
+export function clearLifetimeCount(contributorId: string) {
+  if (!contributorId) return;
+  try {
+    const key = `lipy_device_sample_count_${String(contributorId).trim()}`;
+    localStorage.removeItem(key);
+  } catch (e) { }
+}
+
+/**
+ * Counts ALL samples in the local IndexedDB for a given contributor (across
+ * all sessions, regardless of sync status).
+ */
+export async function getContributorSampleCount(contributorId: string): Promise<number> {
+  if (!contributorId) return 0;
+  try {
+    const cid = String(contributorId).trim();
+    return await db.samples.where('contributorId').equals(cid).count();
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Counts only *uploaded* samples in the local IndexedDB for a given
+ * contributor (across all sessions).  Used to reconcile the displayed
+ * lifetime contribution count so it reflects only successfully synchronized
+ * samples.
+ */
+export async function getUploadedSampleCount(contributorId: string): Promise<number> {
+  if (!contributorId) return 0;
+  try {
+    const cid = String(contributorId).trim();
+    return await db.samples.where({ contributorId: cid, syncStatus: 'uploaded' }).count();
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Clears ALL local data associated with a contributor profile:
+ * - Lifetime contribution count (localStorage)
+ * - Session config (localStorage)
+ * - Session sample counts (localStorage)
+ * - Last-sample timestamps (localStorage)
+ * - Scheduler state (localStorage)
+ * - Sample counter keys (localStorage)
+ * - IndexedDB samples, contributors, and uploadQueue tables
+ *
+ * After calling this the contributor profile is fully reset.
+ */
+export async function clearContributorData(contributorId: string) {
+  if (!contributorId) return;
+  const cid = String(contributorId).trim();
+
+  // 1. Remove known localStorage keys for this contributor
+  try {
+    const keysToRemove: string[] = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const k = localStorage.key(i);
+      if (k && (
+        k.startsWith(`lipy_device_sample_count_${cid}`) ||
+        k.startsWith(`lipy_session_sample_count_${cid}`) ||
+        k.startsWith(`lipy_sample_counter_${cid}`) ||
+        k.startsWith(`lipy_last_sample_ts_${cid}`) ||
+        k.startsWith(`lipy_last_export_ts_${cid}`) ||
+        k.startsWith(`lipy_mixed_scheduler_state_v1_${cid}`)
+      )) {
+        keysToRemove.push(k);
+      }
+    }
+    keysToRemove.forEach((k) => localStorage.removeItem(k));
+  } catch (e) { }
+
+  // 2. Remove session config (global, not contributor-scoped)
+  try { localStorage.removeItem('lipy_session_config'); } catch (e) { }
+
+  // 3. Clear IndexedDB tables for this contributor
+  try {
+    await db.transaction('rw', db.samples, db.contributors, db.uploadQueue, async () => {
+      await db.samples.where('contributorId').equals(cid).delete();
+      await db.contributors.where('contributorId').equals(cid).delete();
+      await db.uploadQueue.where('contributorId').equals(cid).delete();
+    });
+  } catch (e) { }
+}
+
 export default db;

frontend/lib/lipyd/supabaseClient.ts

@@ -28,6 +28,11 @@ export function getSupabaseClient() {
           autoRefreshToken: false,
           persistSession: false,
           detectSessionInUrl: false,
+          storage: {
+            getItem: () => null,
+            setItem: () => {},
+            removeItem: () => {},
+          },
         },
       });
       if (typeof window !== 'undefined') {