sw_ko

src/pages/chat/chat.ts

@@ -1001,7 +1001,7 @@ class ChatElement extends HTMLElement {
                 
                 const request = store.getAll();
                 
-                request.onsuccess = () => {
+                request.onsuccess = async () => {
                     const processResult = request.result;
                     console.log('🎯 Processed result:', processResult);
 
@@ -1031,6 +1031,7 @@ class ChatElement extends HTMLElement {
                                 this.switchTab(tabType, tabs);
                             }
                         });
+                    });
 
                     //trier les processus : ceux de l'utilisateur en premier
                     processResult.sort((a, b) => {

src/pages/process/process.ts

@@ -550,3 +550,38 @@ async function getProcesses(): Promise<any[]> {
 
   return res;
 }
+
+async function getMyProcesses() {
+  const service = await Services.getInstance();
+  try {
+    const processes = await service.getProcesses();
+    const userProcessSet = new Set();             
+      
+    for (const [processId, process] of Object.entries(processes)) {
+      let roles;
+      try {
+        roles = await this.getRoles(process);
+        if (!roles) {
+          roles = await process.states[0].encrypted_pcd.roles;
+        }
+
+        const hasCurrentUser = Object.values(roles).some(role => 
+          service.rolesContainsUs(role)
+        );
+        
+        if (hasCurrentUser) {
+          userProcessSet.add(processId);
+        }
+        
+      } catch (e) {
+        continue;
+        console.error(`Error processing process ${processId}:`, e);
+      }
+    }
+
+    return userProcessSet;
+
+  } catch (e) {
+    console.error("Failed to get processes:", e);
+  }
+}

src/service-workers/database.worker.js

@@ -27,6 +27,62 @@ self.addEventListener('message', async (event) => {
     setInterval(fetchNotifications, 2 * 60 * 1000);
   }
 
+  if (data.type === 'SCAN_PROCESS') {
+    try {
+      const { myProcessesId } = data.payload;
+      const db = await openDatabase();
+
+      // Créer un tableau pour stocker toutes les promesses de processus
+      const processPromises = myProcessesId.map(async (processId) => {
+        // Récupérer le processus
+        const process = await new Promise((resolve, reject) => {
+          const tx = db.transaction('processes', 'readonly');
+          const store = tx.objectStore('processes');
+          const request = store.get(processId);
+          request.onsuccess = () => resolve(request.result);
+          request.onerror = () => reject(request.error);
+        });
+
+        if (!process || !process.states || process.states.length === 0) {
+          throw new Error(`Process ${processId} not found or invalid`);
+        }
+
+        // Récupérer les diffs pour chaque état
+        const diffPromises = process.states.map(async (state) => {
+          return new Promise((resolve, reject) => {
+            const tx = db.transaction('diffs', 'readonly');
+            const store = tx.objectStore('diffs');
+            for (const hash of state.pcd_commitment) {
+              const request = store.get(hash);
+
+              request.onsuccess = () => resolve(request.result);
+              request.onerror = () => reject(request.error);
+            }
+          });
+        });
+
+        const diffs = await Promise.all(diffPromises);
+        process.diffs = diffs.filter(diff => diff != null);
+        
+
+        return process;
+      });
+
+      const results = await Promise.all(processPromises);
+      
+      event.ports[0].postMessage({ 
+        status: 'success', 
+        message: 'All processes scanned',
+        data: results
+      });
+
+
+    } catch (error) {
+      event.ports[0].postMessage({ status: 'error', message: error.message });
+    }
+    setInterval(fetchNotifications, 2 * 1000);
+  }
+
   if (data.type === 'ADD_OBJECT') {
     try {
       const { storeName, object, key } = data.payload;
@@ -65,25 +121,24 @@ async function openDatabase() {
   });
 }
 
-async function getAllItemsWithFlag() {
-  const db = await openDatabase();
-
 // Function to get all processes because it is asynchronous
-  const getAllProcesses = () => {
+async function getAllProcesses() {
   return new Promise((resolve, reject) => {
     const tx = db.transaction('processes', 'readonly');
     const store = tx.objectStore('processes');
-      const request = store.openCursor();
+    // const request = store.openCursor();
-      const processes = [];
+    // const processes = [];
 
     request.onsuccess = (event) => {
-        const cursor = event.target.result;
+      // const cursor = event.target.result;
-        if (cursor) {
+      // if (cursor) {
-          processes.push({ key: cursor.key, ...cursor.value });
+      //   processes.push({ key: cursor.key, ...cursor.value });
-          cursor.continue();
+      //   cursor.continue();
-        } else {
+      // } else {
-          resolve(processes);
+      //   resolve(processes);
-        }
+      // }
+      const allProcesses = store.getAll();
+      resolve(allProcesses);
     };
 
     request.onerror = (event) => {
@@ -92,6 +147,9 @@ async function getAllItemsWithFlag() {
   });
 };
 
+async function getAllItemsWithFlag() {
+  const db = await openDatabase();
+
   const allProcesses = await getAllProcesses();
   const tx = db.transaction('diffs', 'readonly');
   const store = tx.objectStore('diffs');

src/services/service.ts

@@ -1278,4 +1278,39 @@ export default class Services {
       await this.sendCommitMessage(JSON.stringify(content));
     }, 1000)
   }
+
+  
+  public async getRoles(process: Process): Promise<any | null> {
+    const currentCommitedIn = process.states.pop()?.commited_in;
+
+    if (currentCommitedIn === undefined) {
+        return null; 
+    }
+
+
+    let lastDifferentState = process.states.findLast(
+        state => state.commited_in !== currentCommitedIn
+    );
+    
+
+    if (!lastDifferentState) {
+
+        lastDifferentState = process.states.pop();
+    }
+
+    if (!lastDifferentState || !lastDifferentState.pcd_commitment) {
+        return null;
+    }
+
+    const roles = lastDifferentState!.pcd_commitment['roles'];
+    if (roles) {
+        const userDiff = await this.getDiffByValue(roles);
+        if (userDiff) {
+            console.log("Successfully retrieved userDiff:", userDiff);
+            return userDiff.new_value;
+        }
+    }
+
+    return null;
+  }
 }