backend

backend/server.js

@@ -49,14 +49,14 @@ function getMimeType(ext) {
 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}`)
@@ -65,13 +65,13 @@ function createFolderStructure(folderHash) {
     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}`)
@@ -80,7 +80,7 @@ function createFolderStructure(folderHash) {
     fs.mkdirSync(cachePath, { recursive: true })
     console.log(`[FOLDER] Dossier cache créé: ${cachePath}`)
   }
-  
+
   return { folderPath, cachePath }
 }
 
@@ -1114,12 +1114,12 @@ app.post('/api/folders', (req, res) => {
     console.log('[FOLDER] Début de la création d\'un nouveau dossier')
     const folderHash = generateFolderHash()
     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}`)
-    
+
     res.json({
       success: true,
       folderHash,
@@ -1215,14 +1215,14 @@ app.post('/api/folders/default', async (req, res) => {
         // Traiter le fichier et sauvegarder le résultat
         try {
           console.log(`[FOLDER] Traitement de ${testFile}...`)
-          
+
           // 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') {
@@ -1230,14 +1230,14 @@ app.post('/api/folders/default', async (req, res) => {
           } 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}`)

src/services/backendApi.ts

@@ -38,15 +38,6 @@ export interface BackendExtractionResult {
   timestamp: string
 }
 
-export interface BackendTestFiles {
-  success: boolean
-  files: Array<{
-    name: string
-    size: number
-    type: string
-    lastModified: string
-  }>
-}
 
 /**
  * Extrait le texte et les entités d'un document via le backend
@@ -150,26 +141,6 @@ export async function extractDocumentBackend(
   }
 }
 
-/**
- * Récupère la liste des fichiers de test depuis le backend
- */
-export async function getTestFilesBackend(): Promise<BackendTestFiles> {
-  try {
-    const response = await fetch(`${BACKEND_URL}/api/test-files`)
-
-    if (!response.ok) {
-      throw new Error(`Erreur HTTP: ${response.status} ${response.statusText}`)
-    }
-
-    const result: BackendTestFiles = await response.json()
-    console.log('📁 [BACKEND] Fichiers de test récupérés:', result.files.length)
-
-    return result
-  } catch (error) {
-    console.error('❌ [BACKEND] Erreur lors de la récupération des fichiers de test:', error)
-    throw error
-  }
-}
 
 // Cache pour le health check
 let backendHealthCache: { isHealthy: boolean; timestamp: number } | null = null

src/services/folderApi.ts

@@ -83,6 +83,16 @@ export async function createDefaultFolder(): Promise<CreateFolderResponse> {
   return response.json()
 }
 
+// Utiliser le dossier par défaut existant (sans créer de nouveau dossier)
+export async function getDefaultFolder(): Promise<CreateFolderResponse> {
+  // Utiliser le dossier par défaut existant avec les fichiers de test
+  return {
+    success: true,
+    folderHash: '7d99a85daf66a0081a0e881630e6b39b',
+    message: 'Dossier par défaut récupéré'
+  }
+}
+
 // Récupérer les résultats d'un dossier
 export async function getFolderResults(folderHash: string): Promise<FolderResponse> {
   const response = await fetch(`${API_BASE_URL}/folders/${folderHash}/results`)

src/services/testFilesApi.ts

@@ -1,106 +0,0 @@
-/**
- * API pour gérer les fichiers de test
- */
-
-export interface TestFileInfo {
-  name: string
-  size: number
-  type: string
-  lastModified: number
-}
-
-/**
- * Récupère la liste des fichiers disponibles dans le dossier test-files
- */
-export async function getTestFilesList(): Promise<TestFileInfo[]> {
-  try {
-    // Utiliser l'API du backend pour récupérer la liste des fichiers
-    const response = await fetch('http://localhost:3001/api/test-files')
-    if (!response.ok) {
-      throw new Error(`Erreur API: ${response.status}`)
-    }
-
-    const data = await response.json()
-    if (!data.success) {
-      throw new Error('API retourne success: false')
-    }
-
-    // Convertir le format du backend vers le format attendu
-    return data.files.map((file: any) => {
-      let mimeType = 'application/octet-stream'
-
-      // Convertir l'extension en type MIME
-      switch (file.type) {
-        case '.jpg':
-        case '.jpeg':
-          mimeType = 'image/jpeg'
-          break
-        case '.png':
-          mimeType = 'image/png'
-          break
-        case '.pdf':
-          mimeType = 'application/pdf'
-          break
-        case '.tiff':
-          mimeType = 'image/tiff'
-          break
-        default:
-          mimeType = 'application/octet-stream'
-      }
-
-      return {
-        name: file.name,
-        size: file.size,
-        type: mimeType,
-        lastModified: new Date(file.lastModified).getTime()
-      }
-    })
-  } catch (error) {
-    console.error('Erreur lors de la récupération de la liste des fichiers de test:', error)
-    return []
-  }
-}
-
-/**
- * Charge un fichier de test par son nom
- */
-export async function loadTestFile(fileName: string): Promise<File | null> {
-  try {
-    const response = await fetch(`http://localhost:3001/api/test-files/${fileName}`)
-    if (!response.ok) {
-      throw new Error(`Fichier non trouvé: ${fileName}`)
-    }
-
-    const blob = await response.blob()
-    return new File([blob], fileName, { type: blob.type })
-  } catch (error) {
-    console.error(`Erreur lors du chargement du fichier ${fileName}:`, error)
-    return null
-  }
-}
-
-/**
- * Filtre les fichiers par type MIME supporté
- */
-export function filterSupportedFiles(files: TestFileInfo[]): TestFileInfo[] {
-  const supportedTypes = [
-    'application/pdf',
-    'image/jpeg',
-    'image/jpg',
-    'image/png',
-    'image/tiff'
-  ]
-
-  return files.filter(file => {
-    // Vérifier le type MIME
-    if (supportedTypes.includes(file.type)) {
-      return true
-    }
-
-    // Vérifier l'extension si le type MIME n'est pas fiable
-    const extension = file.name.split('.').pop()?.toLowerCase()
-    const supportedExtensions = ['pdf', 'jpg', 'jpeg', 'png', 'tiff']
-
-    return extension && supportedExtensions.includes(extension)
-  })
-}

src/store/documentSlice.ts

@@ -4,7 +4,7 @@ import type { Document, ExtractionResult, AnalysisResult, ContextResult, Conseil
 import { documentApi } from '../services/api'
 import { openaiDocumentApi } from '../services/openai'
 import { backendDocumentApi, checkBackendHealth } from '../services/backendApi'
-import { createDefaultFolder, getFolderResults, uploadFileToFolder, type FolderResult } from '../services/folderApi'
+import { createDefaultFolder, getDefaultFolder, getFolderResults, uploadFileToFolder, type FolderResult } from '../services/folderApi'
 
 interface DocumentState {
   documents: Document[]
@@ -175,7 +175,7 @@ export const getConseil = createAsyncThunk(
 export const createDefaultFolderThunk = createAsyncThunk(
   'document/createDefaultFolder',
   async () => {
-    return await createDefaultFolder()
+    return await getDefaultFolder()
   }
 )