Update app.py

app.py

@@ -1,4 +1,4 @@
-from fastapi import FastAPI, Request, HTTPException,Depends, Response
+from fastapi import FastAPI, Request, HTTPException,Depends,File, UploadFile, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
@@ -15,6 +15,9 @@ import os
 from pymongo import MongoClient
 from datetime import datetime  
 from passlib.hash import bcrypt  
+import PyPDF2
+from io import BytesIO
+import uuid
 
 SECRET_KEY = secrets.token_hex(32)  
 
@@ -53,6 +56,153 @@ app.add_middleware(
 )
 
 
+async def get_admin_user(request: Request):
+    user = await get_current_user(request)
+    if user["role"] != "Administrateur":
+        raise HTTPException(status_code=403, detail="Accès interdit: Droits d'administrateur requis")
+    return user
+
+
+# Initialiser le modèle d'embedding (à faire une seule fois au démarrage)
+try:
+    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+except Exception as e:
+    print(f"Erreur lors du chargement du modèle d'embedding: {str(e)}")
+    embedder = None
+@app.post("/api/admin/knowledge/upload")
+async def upload_pdf(
+    file: UploadFile = File(...),
+    title: str = None,
+    tags: str = None,
+    current_user: dict = Depends(get_admin_user)
+):
+    try:
+        # Vérifier que le fichier est un PDF
+        if not file.filename.endswith('.pdf'):
+            raise HTTPException(status_code=400, detail="Le fichier doit être un PDF")
+        
+        # Lire le contenu du PDF
+        contents = await file.read()
+        pdf_file = BytesIO(contents)
+        
+        # Extraire le texte du PDF
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text_content = ""
+        for page_num in range(len(pdf_reader.pages)):
+            text_content += pdf_reader.pages[page_num].extract_text() + "\n"
+        
+        # Générer un embedding pour l'ensemble du texte si le modèle est disponible
+        embedding = None
+        if embedder:
+            try:
+                # Limiter la taille du texte si nécessaire
+                max_length = 5000
+                truncated_text = text_content[:max_length]
+                embedding = embedder.encode(truncated_text).tolist()
+            except Exception as e:
+                print(f"Erreur lors de la génération de l'embedding: {str(e)}")
+        
+        # Générer un identifiant unique pour le document
+        doc_id = ObjectId()
+        
+        # Enregistrer le fichier original 
+        pdf_path = f"files/{str(doc_id)}.pdf"
+        os.makedirs("files", exist_ok=True)
+        with open(pdf_path, "wb") as f:
+            pdf_file.seek(0)
+            f.write(contents)
+        
+        # Créer un objet document dans MongoDB
+        document = {
+            "_id": doc_id,
+            "text": text_content,
+            "embedding": embedding,
+            "title": title or file.filename,
+            "tags": tags.split(",") if tags else [],
+            "uploaded_by": str(current_user["_id"]),
+            "upload_date": datetime.utcnow()
+        }
+        
+        print(f"Tentative d'insertion du document avec ID: {doc_id}")
+        result = db.connaissances.insert_one(document)
+        print(f"Document inséré avec ID: {result.inserted_id}")
+        
+        # Vérification de l'insertion
+        verification = db.connaissances.find_one({"_id": doc_id})
+        if verification:
+            print(f"Document vérifié et trouvé dans la base de données")
+            return {"success": True, "document_id": str(doc_id)}
+        else:
+            print(f"ERREUR: Document non trouvé après insertion")
+            return {"success": False, "error": "Document non trouvé après insertion"}
+        
+    except Exception as e:
+        import traceback
+        print(f"Erreur lors de l'upload du PDF: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Erreur: {str(e)}")
+
+@app.get("/api/admin/knowledge")
+async def list_documents(current_user: dict = Depends(get_admin_user)):
+    try:
+        # Récupérer les documents triés par date (plus récents en premier)
+        documents = list(db.connaissances.find().sort("upload_date", -1))
+        
+        # Convertir les types non sérialisables (ObjectId, datetime, etc.)
+        result = []
+        for doc in documents:
+            doc_safe = {
+                "id": str(doc["_id"]),
+                "title": doc.get("title", "Sans titre"),
+                "tags": doc.get("tags", []),
+                "date": doc.get("upload_date").isoformat() if "upload_date" in doc else None,
+                "text_preview": doc.get("text", "")[:100] + "..." if len(doc.get("text", "")) > 100 else doc.get("text", "")
+            }
+            result.append(doc_safe)
+        
+        return {"documents": result}
+    except Exception as e:
+        print(f"Erreur lors de la liste des documents: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Erreur: {str(e)}")
+
+
+
+@app.delete("/api/admin/knowledge/{document_id}")
+async def delete_document(document_id: str, current_user: dict = Depends(get_admin_user)):
+    try:
+        # Convertir l'ID string en ObjectId
+        try:
+            doc_id = ObjectId(document_id)
+        except Exception:
+            raise HTTPException(status_code=400, detail="ID de document invalide")
+        
+        # Vérifier si le document existe
+        document = db.connaissances.find_one({"_id": doc_id})
+        if not document:
+            raise HTTPException(status_code=404, detail="Document non trouvé")
+        
+        # Supprimer le document de la base de données
+        result = db.connaissances.delete_one({"_id": doc_id})
+        
+        if result.deleted_count == 0:
+            raise HTTPException(status_code=500, detail="Échec de la suppression du document")
+        
+        # Supprimer le fichier PDF associé s'il existe
+        pdf_path = f"files/{document_id}.pdf"
+        if os.path.exists(pdf_path):
+            try:
+                os.remove(pdf_path)
+                print(f"Fichier supprimé: {pdf_path}")
+            except Exception as e:
+                print(f"Erreur lors de la suppression du fichier: {str(e)}")
+                # On continue même si la suppression du fichier échoue
+        
+        return {"success": True, "message": "Document supprimé avec succès"}
+        
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur lors de la suppression: {str(e)}")
+
 
 @app.post("/api/login")
 async def login(request: Request, response: Response):
@@ -95,7 +245,9 @@ async def login(request: Request, response: Response):
             "success": True, 
             "username": username, 
             "user_id": user_id,
-            "session_id": session_id  
+            "session_id": session_id,
+            "role": user.get("role", "user")  
+
         }
     
     except Exception as e:
@@ -165,7 +317,9 @@ async def register(request: Request):
             "nom": data["nom"],
             "email": data["email"],
             "password": hashed_password,
-            "createdAt": datetime.utcnow()
+            "createdAt": datetime.utcnow(),
+            "role": data.get("role", "user"),  
+
         }
         
         result = db.users.insert_one(user)