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)) {
-    return { results: [], pending: [], hasPending: false }
-  }
+  const uploadsPath = path.join('uploads', folderHash)
   
-  const files = fs.readdirSync(cachePath)
   const results = []
   const pending = []
   let hasPending = false
 
-  for (const file of files) {
-    if (file.endsWith('.json')) {
-      const fileHash = path.basename(file, '.json')
-      const result = getJsonCacheFromFolder(folderHash, fileHash)
-      if (result) {
+  // Traiter les fichiers en cache (avec résultats d'extraction)
+  if (fs.existsSync(cachePath)) {
+    const cacheFiles = fs.readdirSync(cachePath)
+    
+    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')) {
-      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)
+        
+        console.log(`[FOLDER] Fichier non traité ajouté: ${file}`)
       }
     }
   }