fix: Correction du problème des fichiers non traités après vidage du cache

- Modification de listFolderResults pour inclure les fichiers en uploads
- Création de résultats minimaux pour les fichiers non traités
- Fonction getMimeTypeFromExtension pour détecter le type MIME
- Les fichiers non traités apparaissent maintenant avec status 'Non traité'
- Résolution du problème où les documents ne remontaient pas après vidage

Fixes: Fichiers dans uploads non visibles après vidage du cache
Fixes: listFolderResults ne regardait que le cache, pas les uploads

backend/server.js

@@ -205,37 +205,143 @@ function getJsonCacheFromFolder(folderHash, fileHash) {
   return null
 }
 
+// Fonction pour obtenir le type MIME à partir de l'extension
+function getMimeTypeFromExtension(extension) {
+  const mimeTypes = {
+    '.pdf': 'application/pdf',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.tiff': 'image/tiff',
+    '.webp': 'image/webp'
+  }
+  return mimeTypes[extension.toLowerCase()] || 'application/octet-stream'
+}
+
 // Fonction pour lister tous les résultats d'un dossier
 function listFolderResults(folderHash) {
   const cachePath = path.join('cache', folderHash)
-  if (!fs.existsSync(cachePath)) {
+  const uploadsPath = path.join('uploads', folderHash)
-    return { results: [], pending: [], hasPending: false }
+  
-  }
-
-  const files = fs.readdirSync(cachePath)
   const results = []
   const pending = []
   let hasPending = false
 
-  for (const file of files) {
+  // Traiter les fichiers en cache (avec résultats d'extraction)
-    if (file.endsWith('.json')) {
+  if (fs.existsSync(cachePath)) {
-      const fileHash = path.basename(file, '.json')
+    const cacheFiles = fs.readdirSync(cachePath)
-      const result = getJsonCacheFromFolder(folderHash, fileHash)
+    
-      if (result) {
+    for (const file of cacheFiles) {
+      if (file.endsWith('.json')) {
+        const fileHash = path.basename(file, '.json')
+        const result = getJsonCacheFromFolder(folderHash, fileHash)
+        if (result) {
+          results.push({
+            fileHash,
+            ...result
+          })
+        }
+      } else if (file.endsWith('.pending')) {
+        const fileHash = path.basename(file, '.pending')
+        try {
+          const pendingData = JSON.parse(fs.readFileSync(path.join(cachePath, file), 'utf8'))
+          pending.push(pendingData)
+          hasPending = true
+          console.log(`[CACHE] Fichier en cours de traitement détecté: ${fileHash}`)
+        } catch (error) {
+          console.error(`[CACHE] Erreur lors de la lecture du flag pending ${file}:`, error)
+        }
+      }
+    }
+  }
+
+  // Traiter les fichiers en uploads (sans résultats d'extraction)
+  if (fs.existsSync(uploadsPath)) {
+    const uploadFiles = fs.readdirSync(uploadsPath)
+    
+    for (const file of uploadFiles) {
+      // Extraire le hash du nom de fichier (format: hash.extension)
+      const fileHash = path.basename(file, path.extname(file))
+      
+      // Vérifier si ce fichier n'a pas déjà un résultat en cache
+      const hasCacheResult = results.some(result => result.fileHash === fileHash)
+      
+      if (!hasCacheResult) {
+        // Créer un résultat minimal pour les fichiers non traités
+        const filePath = path.join(uploadsPath, file)
+        const stats = fs.statSync(filePath)
+        
         results.push({
           fileHash,
-          ...result
+          document: {
+            id: `doc-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            fileName: file,
+            mimeType: getMimeTypeFromExtension(path.extname(file)),
+            fileSize: stats.size,
+            uploadTimestamp: stats.mtime.toISOString()
+          },
+          classification: {
+            documentType: 'Document',
+            confidence: 0.0,
+            subType: 'Non traité',
+            language: 'fr',
+            pageCount: 1
+          },
+          extraction: {
+            text: {
+              raw: '',
+              processed: '',
+              wordCount: 0,
+              characterCount: 0,
+              confidence: 0.0
+            },
+            entities: {
+              persons: [],
+              companies: [],
+              addresses: [],
+              financial: {
+                amounts: [],
+                totals: {},
+                payment: {}
+              },
+              dates: [],
+              contractual: {
+                clauses: [],
+                signatures: []
+              },
+              references: []
+            }
+          },
+          metadata: {
+            processing: {
+              engine: '4NK_IA_Backend',
+              version: '1.0.0',
+              processingTime: '0ms',
+              ocrEngine: 'none',
+              nerEngine: 'none',
+              preprocessing: {
+                applied: false,
+                reason: 'Fichier non traité'
+              }
+            },
+            quality: {
+              globalConfidence: 0.0,
+              textExtractionConfidence: 0.0,
+              entityExtractionConfidence: 0.0,
+              classificationConfidence: 0.0
+            }
+          },
+          status: {
+            success: false,
+            errors: ['Fichier non traité'],
+            warnings: ['Aucune extraction effectuée'],
+            timestamp: stats.mtime.toISOString()
+          }
         })
-      }
+        
-    } else if (file.endsWith('.pending')) {
+        console.log(`[FOLDER] Fichier non traité ajouté: ${file}`)
-      const fileHash = path.basename(file, '.pending')
-      try {
-        const pendingData = JSON.parse(fs.readFileSync(path.join(cachePath, file), 'utf8'))
-        pending.push(pendingData)
-        hasPending = true
-        console.log(`[CACHE] Fichier en cours de traitement détecté: ${fileHash}`)
-      } catch (error) {
-        console.error(`[CACHE] Erreur lors de la lecture du flag pending ${file}:`, error)
       }
     }
   }
@@ -1407,15 +1513,15 @@ app.get('/api/health', (req, res) => {
 // Vider le cache d'un dossier
 app.delete('/api/folders/:folderHash/cache', (req, res) => {
   const { folderHash } = req.params
-  
+
   console.log(`[CACHE] Demande de suppression du cache pour le dossier: ${folderHash}`)
-  
+
   try {
     const { cachePath, uploadsPath } = createFolderStructure(folderHash)
-    
+
     let deletedFiles = 0
     let deletedDirs = 0
-    
+
     // Supprimer le dossier cache s'il existe
     if (fs.existsSync(cachePath)) {
       const files = fs.readdirSync(cachePath)
@@ -1429,7 +1535,7 @@ app.delete('/api/folders/:folderHash/cache', (req, res) => {
           console.error(`[CACHE] Erreur lors de la suppression de ${file}:`, error.message)
         }
       }
-      
+
       // Supprimer le dossier cache vide
       try {
         fs.rmdirSync(cachePath)
@@ -1439,7 +1545,7 @@ app.delete('/api/folders/:folderHash/cache', (req, res) => {
         console.error(`[CACHE] Erreur lors de la suppression du dossier cache:`, error.message)
       }
     }
-    
+
     // Supprimer le dossier uploads s'il existe
     if (fs.existsSync(uploadsPath)) {
       const files = fs.readdirSync(uploadsPath)
@@ -1453,7 +1559,7 @@ app.delete('/api/folders/:folderHash/cache', (req, res) => {
           console.error(`[CACHE] Erreur lors de la suppression de ${file}:`, error.message)
         }
       }
-      
+
       // Supprimer le dossier uploads vide
       try {
         fs.rmdirSync(uploadsPath)
@@ -1463,9 +1569,9 @@ app.delete('/api/folders/:folderHash/cache', (req, res) => {
         console.error(`[CACHE] Erreur lors de la suppression du dossier uploads:`, error.message)
       }
     }
-    
+
     console.log(`[CACHE] Cache vidé pour le dossier ${folderHash}: ${deletedFiles} fichiers, ${deletedDirs} dossiers supprimés`)
-    
+
     res.json({
       success: true,
       message: `Cache vidé pour le dossier ${folderHash}`,
@@ -1473,7 +1579,7 @@ app.delete('/api/folders/:folderHash/cache', (req, res) => {
       deletedDirs,
       folderHash
     })
-    
+
   } catch (error) {
     console.error(`[CACHE] Erreur lors du vidage du cache:`, error)
     res.status(500).json({