4nk/docv
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added : Fetching the process with folderNumber attributes

Browse Source
This commit is contained in:
Sadrinho27 2025-11-07 19:41:59 +01:00
parent 464f38b062
commit 3057c1e529
1 changed files with 50 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
lib/contexts/FourNKContext.tsx
View File

@ -6,19 +6,9 @@ import { iframeUrl } from "@/app/page";
import UserStore from "@/lib/4nk/UserStore"; import UserStore from "@/lib/4nk/UserStore";
import { FolderData } from "@/lib/4nk/models/FolderData"; 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 // Interface enrichie qui inclut maintenant les membres ET les fichiers
export interface EnrichedFolderData extends FolderData { export interface EnrichedFolderData extends FolderData {
members: FolderMember[]; processId: string,
files: any[]; // <-- AJOUT DES FICHIERS
// notes: any[]; // 'notes' est déjà dans FolderData
} }
// --- // ---
@ -30,7 +20,7 @@ type FourNKContextType = {
folderProcesses: any; folderProcesses: any;
myFolderProcesses: string[]; myFolderProcesses: string[];
folderPrivateData: Record<string, Record<string, any>>; folderPrivateData: Record<string, Record<string, any>>;
folders: EnrichedFolderData[]; // <-- Utilise le type enrichi folders: EnrichedFolderData[];
loadingFolders: boolean; loadingFolders: boolean;
members: string[]; members: string[];
@ -76,53 +66,72 @@ export function FourNKProvider({ children }: { children: ReactNode }) {
let hasAllPrivateData = true; let hasAllPrivateData = true;
let hasFoldersToLoad = false; let hasFoldersToLoad = false;
const missingPrivateData: Array<{ processId: string, stateId: string }> = []; const missingPrivateData: Array<{ processId: string, stateId: string }> = [];
const EXCLUDED_STATE_ID = "0000000000000000000000000000000000000000000000000000000000000000";
Object.entries(folderProcesses).forEach(([processId, process]: [string, any]) => { Object.entries(folderProcesses).forEach(([processId, process]: [string, any]) => {
if (!myFolderProcesses.includes(processId)) return; if (!myFolderProcesses.includes(processId)) return;
const latestState = process.states[0]; const validStates = process.states.filter(
if (!latestState) return; state => state && state.state_id !== EXCLUDED_STATE_ID
const folderNumber = latestState.pcd_commitment?.folderNumber; );
if (!folderNumber) return; if (validStates.length === 0) return;
const referenceState = validStates.find(
hasFoldersToLoad = true; state => state.pcd_commitment?.folderNumber
const privateData = folderPrivateData[latestState.state_id]; );
const mainFolderNumber = referenceState?.pcd_commitment.folderNumber;
if (!privateData) { if (!mainFolderNumber) {
hasAllPrivateData = false;
missingPrivateData.push({ processId, stateId: latestState.state_id });
return; return;
} }
const ownerMembers = latestState.roles?.owner?.members || []; // console.log(validStates);
const members: FolderMember[] = ownerMembers.map((memberId: string) => {
const avatar = memberId.slice(0, 2).toUpperCase(); // validStates.forEach(state => {
return { hasFoldersToLoad = true;
id: memberId, const stateToProcess = referenceState;
name: `Membre ${memberId.slice(0, 4)}`,
avatar: avatar, const privateData = folderPrivateData[stateToProcess.state_id];
isOnline: Math.random() > 0.5
} // 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({ folderData.push({
folderNumber: folderNumber, processId: processId,
name: privateData.name || `Dossier ${folderNumber}`, folderNumber: mainFolderNumber, // La clé unique
name: privateData.name || `Dossier ${mainFolderNumber}`,
description: privateData.description || '', description: privateData.description || '',
created_at: privateData.created_at || new Date().toISOString(), created_at: privateData.created_at || new Date().toISOString(),
updated_at: privateData.updated_at || new Date().toISOString(), updated_at: privateData.updated_at || new Date().toISOString(),
notes: privateData.notes || [], notes: privateData.notes || [],
files: privateData.files || [], // <-- AJOUT DE L'EXTRACTION DES FICHIERS messages: privateData.messages || [],
members: members messages_owner: privateData.messages_owner || [],
}); });
// });
}); });
if (hasFoldersToLoad && !hasAllPrivateData) { if (hasFoldersToLoad && !hasAllPrivateData) {
setLoadingFolders(true); setLoadingFolders(true);
missingPrivateData.forEach(({ processId, stateId }) => { const firstMissing = missingPrivateData[0];
if (!folderPrivateData[stateId]) { if (firstMissing) {
fetchFolderPrivateData(processId, stateId); if (!folderPrivateData[firstMissing.stateId]) {
fetchFolderPrivateData(firstMissing.processId, firstMissing.stateId);
} }
}); }
} else { } else {
setFolders(folderData); setFolders(folderData);
setLoadingFolders(false); setLoadingFolders(false);