backend

backend/server.js

@@ -33,16 +33,52 @@ function generateFolderHash() {
   return crypto.randomBytes(16).toString('hex')
 }
 
+// Fonction pour obtenir le type MIME à partir de l'extension
+function getMimeType(ext) {
+  const mimeTypes = {
+    '.pdf': 'application/pdf',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.tiff': 'image/tiff'
+  }
+  return mimeTypes[ext.toLowerCase()] || 'application/octet-stream'
+}
+
 // Fonction pour créer la structure de dossiers
 function createFolderStructure(folderHash) {
-  const folderPath = path.join('uploads', folderHash)
+  console.log(`[FOLDER] Création de la structure pour le hash: ${folderHash}`)
-  const cachePath = path.join('cache', folderHash)
+  console.log(`[FOLDER] Répertoire de travail: ${process.cwd()}`)
+  
+  // Créer les dossiers racines s'ils n'existent pas
+  const uploadsDir = 'uploads'
+  const cacheDir = 'cache'
+  
+  console.log(`[FOLDER] Vérification de l'existence de ${uploadsDir}: ${fs.existsSync(uploadsDir)}`)
+  console.log(`[FOLDER] Vérification de l'existence de ${cacheDir}: ${fs.existsSync(cacheDir)}`)
+  
+  if (!fs.existsSync(uploadsDir)) {
+    fs.mkdirSync(uploadsDir, { recursive: true })
+    console.log(`[FOLDER] Dossier racine créé: ${uploadsDir}`)
+  }
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true })
+    console.log(`[FOLDER] Dossier racine créé: ${cacheDir}`)
+  }
+  
+  const folderPath = path.join(uploadsDir, folderHash)
+  const cachePath = path.join(cacheDir, folderHash)
+  
+  console.log(`[FOLDER] Chemin du dossier uploads: ${folderPath}`)
+  console.log(`[FOLDER] Chemin du dossier cache: ${cachePath}`)
   
   if (!fs.existsSync(folderPath)) {
     fs.mkdirSync(folderPath, { recursive: true })
+    console.log(`[FOLDER] Dossier uploads créé: ${folderPath}`)
   }
   if (!fs.existsSync(cachePath)) {
     fs.mkdirSync(cachePath, { recursive: true })
+    console.log(`[FOLDER] Dossier cache créé: ${cachePath}`)
   }
   
   return { folderPath, cachePath }
@@ -1075,8 +1111,12 @@ app.delete('/api/cache/:hash', (req, res) => {
 // Route pour créer un nouveau dossier
 app.post('/api/folders', (req, res) => {
   try {
+    console.log('[FOLDER] Début de la création d\'un nouveau dossier')
     const folderHash = generateFolderHash()
-    createFolderStructure(folderHash)
+    console.log(`[FOLDER] Hash généré: ${folderHash}`)
+    
+    const result = createFolderStructure(folderHash)
+    console.log(`[FOLDER] Structure créée:`, result)
     
     console.log(`[FOLDER] Nouveau dossier créé: ${folderHash}`)
     
@@ -1174,9 +1214,36 @@ app.post('/api/folders/default', async (req, res) => {
 
         // Traiter le fichier et sauvegarder le résultat
         try {
-          const result = await processDocument(fileBuffer, newFileName, testFile)
+          console.log(`[FOLDER] Traitement de ${testFile}...`)
-          saveJsonCacheInFolder(folderHash, fileHash, result)
+          
-          console.log(`[FOLDER] Fichier de test traité: ${testFile} -> ${fileHash}`)
+          // Simuler un objet req.file pour la logique existante
+          const mockFile = {
+            path: destPath,
+            originalname: testFile,
+            mimetype: getMimeType(ext)
+          }
+          
+          // Extraction de texte selon le type de fichier
+          let ocrResult = null
+          if (ext.toLowerCase() === '.pdf') {
+            ocrResult = await extractTextFromPdf(destPath)
+          } else if (['.jpg', '.jpeg', '.png', '.tiff'].includes(ext.toLowerCase())) {
+            ocrResult = await extractTextFromImage(destPath)
+          }
+          
+          if (ocrResult && ocrResult.text) {
+            // Extraction des entités
+            const entities = extractEntitiesFromText(ocrResult.text)
+            
+            // Génération du résultat au format standard
+            const result = generateStandardJSON(mockFile, ocrResult, entities, 0)
+            
+            // Sauvegarde dans le cache du dossier
+            saveJsonCacheInFolder(folderHash, fileHash, result)
+            console.log(`[FOLDER] Fichier de test traité: ${testFile} -> ${fileHash}`)
+          } else {
+            console.warn(`[FOLDER] Aucun texte extrait de ${testFile}`)
+          }
         } catch (error) {
           console.warn(`[FOLDER] Erreur lors du traitement de ${testFile}:`, error.message)
         }
@@ -1211,6 +1278,7 @@ app.listen(PORT, () => {
   console.log(`📡 API disponible sur: http://localhost:${PORT}/api`)
   console.log(`🏥 Health check: http://localhost:${PORT}/api/health`)
   console.log(`📁 Test files: http://localhost:${PORT}/api/test-files`)
+  console.log(`📂 Répertoire de travail: ${process.cwd()}`)
 })
 
 module.exports = app

test-folders.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Fonction pour générer un hash de dossier
+function generateFolderHash() {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+// Fonction pour créer la structure de dossiers
+function createFolderStructure(folderHash) {
+  console.log(`[FOLDER] Création de la structure pour le hash: ${folderHash}`);
+  console.log(`[FOLDER] Répertoire de travail: ${process.cwd()}`);
+  
+  // Créer les dossiers racines s'ils n'existent pas
+  const uploadsDir = 'uploads';
+  const cacheDir = 'cache';
+  
+  console.log(`[FOLDER] Vérification de l'existence de ${uploadsDir}: ${fs.existsSync(uploadsDir)}`);
+  console.log(`[FOLDER] Vérification de l'existence de ${cacheDir}: ${fs.existsSync(cacheDir)}`);
+  
+  if (!fs.existsSync(uploadsDir)) {
+    fs.mkdirSync(uploadsDir, { recursive: true });
+    console.log(`[FOLDER] Dossier racine créé: ${uploadsDir}`);
+  }
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    console.log(`[FOLDER] Dossier racine créé: ${cacheDir}`);
+  }
+  
+  const folderPath = path.join(uploadsDir, folderHash);
+  const cachePath = path.join(cacheDir, folderHash);
+  
+  console.log(`[FOLDER] Chemin du dossier uploads: ${folderPath}`);
+  console.log(`[FOLDER] Chemin du dossier cache: ${cachePath}`);
+  
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, { recursive: true });
+    console.log(`[FOLDER] Dossier uploads créé: ${folderPath}`);
+  }
+  if (!fs.existsSync(cachePath)) {
+    fs.mkdirSync(cachePath, { recursive: true });
+    console.log(`[FOLDER] Dossier cache créé: ${cachePath}`);
+  }
+  
+  return { folderPath, cachePath };
+}
+
+// Test
+console.log('=== Test de création de dossier ===');
+const folderHash = generateFolderHash();
+console.log(`Hash généré: ${folderHash}`);
+
+const result = createFolderStructure(folderHash);
+console.log('Résultat:', result);
+
+console.log('\n=== Vérification des dossiers créés ===');
+console.log('Dossiers uploads:', fs.readdirSync('uploads'));
+console.log('Dossiers cache:', fs.readdirSync('cache'));