From 3057c1e529282a253585c01e716eaee9dfc7efe5 Mon Sep 17 00:00:00 2001
From: Sadrinho27 <Titouan.tabere@gmail.com>
Date: Fri, 7 Nov 2025 19:41:59 +0100
Subject: [PATCH] Added : Fetching the process with folderNumber attributes

---
 lib/contexts/FourNKContext.tsx | 91 +++++++++++++++++++---------------
 1 file changed, 50 insertions(+), 41 deletions(-)

diff --git a/lib/contexts/FourNKContext.tsx b/lib/contexts/FourNKContext.tsx
index f13042b..1a6113b 100644
--- a/lib/contexts/FourNKContext.tsx
+++ b/lib/contexts/FourNKContext.tsx
@@ -6,19 +6,9 @@ import { iframeUrl } from "@/app/page";
 import UserStore from "@/lib/4nk/UserStore";
 import { FolderData } from "@/lib/4nk/models/FolderData";
 
-// --- Définition des types pour plus de clarté ---
-export interface FolderMember {
-    id: string
-    name: string
-    avatar: string
-    isOnline: boolean
-}
-
 // Interface enrichie qui inclut maintenant les membres ET les fichiers
 export interface EnrichedFolderData extends FolderData {
-    members: FolderMember[];
-    files: any[]; // <-- AJOUT DES FICHIERS
-    // notes: any[]; // 'notes' est déjà dans FolderData
+    processId: string,
 }
 // ---
 
@@ -30,7 +20,7 @@ type FourNKContextType = {
     folderProcesses: any;
     myFolderProcesses: string[];
     folderPrivateData: Record<string, Record<string, any>>;
-    folders: EnrichedFolderData[]; // <-- Utilise le type enrichi
+    folders: EnrichedFolderData[];
     loadingFolders: boolean;
     members: string[];
 
@@ -76,53 +66,72 @@ export function FourNKProvider({ children }: { children: ReactNode }) {
         let hasAllPrivateData = true;
         let hasFoldersToLoad = false;
         const missingPrivateData: Array<{ processId: string, stateId: string }> = [];
+        const EXCLUDED_STATE_ID = "0000000000000000000000000000000000000000000000000000000000000000";
 
         Object.entries(folderProcesses).forEach(([processId, process]: [string, any]) => {
             if (!myFolderProcesses.includes(processId)) return;
-            const latestState = process.states[0];
-            if (!latestState) return;
-            const folderNumber = latestState.pcd_commitment?.folderNumber;
-            if (!folderNumber) return;
-
-            hasFoldersToLoad = true;
-            const privateData = folderPrivateData[latestState.state_id];
-
-            if (!privateData) {
-                hasAllPrivateData = false;
-                missingPrivateData.push({ processId, stateId: latestState.state_id });
+            const validStates = process.states.filter(
+                state => state && state.state_id !== EXCLUDED_STATE_ID
+            );
+            if (validStates.length === 0) return;
+            const referenceState = validStates.find(
+                state => state.pcd_commitment?.folderNumber
+            );
+            const mainFolderNumber = referenceState?.pcd_commitment.folderNumber;
+            if (!mainFolderNumber) {
                 return;
             }
 
-            const ownerMembers = latestState.roles?.owner?.members || [];
-            const members: FolderMember[] = ownerMembers.map((memberId: string) => {
-                const avatar = memberId.slice(0, 2).toUpperCase();
-                return {
-                    id: memberId,
-                    name: `Membre ${memberId.slice(0, 4)}`,
-                    avatar: avatar,
-                    isOnline: Math.random() > 0.5
-                }
-            });
+            // console.log(validStates);
+
+            // validStates.forEach(state => {
+            hasFoldersToLoad = true;
+            const stateToProcess = referenceState;
+
+            const privateData = folderPrivateData[stateToProcess.state_id];
+
+            // Si on n'a pas les données pour cet état de référence...
+            if (!privateData) {
+                hasAllPrivateData = false;
+                missingPrivateData.push({ processId, stateId: stateToProcess.state_id });
+                return; // On quitte ce process, on réessaiera au prochain rendu
+            }
+            // console.log("Données déchiffrées pour le state:", stateToProcess.state_id, privateData);
+
+            /*
+            // 4. CONDITION B: On vérifie si cet état contient des messages.
+            const hasMessages = (privateData.messages && privateData.messages.length > 0);
+            const hasMessagesOwner = (privateData.messages_owner && privateData.messages_owner.length > 0);
+
+            // Si cet état n'a pas de messages, on l'ignore (return)
+            if (!hasMessages && !hasMessagesOwner) {
+                return; // Passe à l'état suivant
+            }
+            */
 
             folderData.push({
-                folderNumber: folderNumber,
-                name: privateData.name || `Dossier ${folderNumber}`,
+                processId: processId,
+                folderNumber: mainFolderNumber, // La clé unique
+                name: privateData.name || `Dossier ${mainFolderNumber}`,
                 description: privateData.description || '',
                 created_at: privateData.created_at || new Date().toISOString(),
                 updated_at: privateData.updated_at || new Date().toISOString(),
                 notes: privateData.notes || [],
-                files: privateData.files || [], // <-- AJOUT DE L'EXTRACTION DES FICHIERS
-                members: members
+                messages: privateData.messages || [],
+                messages_owner: privateData.messages_owner || [],
             });
+            // });
         });
 
+
         if (hasFoldersToLoad && !hasAllPrivateData) {
             setLoadingFolders(true);
-            missingPrivateData.forEach(({ processId, stateId }) => {
-                if (!folderPrivateData[stateId]) {
-                    fetchFolderPrivateData(processId, stateId);
+            const firstMissing = missingPrivateData[0];
+            if (firstMissing) {
+                if (!folderPrivateData[firstMissing.stateId]) {
+                    fetchFolderPrivateData(firstMissing.processId, firstMissing.stateId);
                 }
-            });
+            }
         } else {
             setFolders(folderData);
             setLoadingFolders(false);