Merge remote-tracking branch 'origin/main' into unittest-coverage-yihao-sprint15

Whyle · Whyle · commit de49329e1875 · 2025-05-09T21:40:42.000+02:00
diff --git a/app/main.py b/app/main.py
@@ -8,7 +8,7 @@
 
 from app.database import init_db, get_db, MONGODB_URL
 
-from app.routes import auth, chat, document, user, faq
+from app.routes import auth, chat, document, user, faq, setting
 from app.repositories.user_repository import UserRepository
 
 load_dotenv()
@@ -77,3 +77,4 @@ async def lifespan(app: FastAPI):
 app.include_router(document.router)
 app.include_router(user.router)
 app.include_router(faq.router)
+app.include_router(setting.router)
diff --git a/app/repositories/chat_repository.py b/app/repositories/chat_repository.py
@@ -55,6 +55,9 @@ async def update_chat(self, chat_id, data):
         )
 
     async def add_message(self, chat_id, message: schemas.MessageCreate):
+        """
+        Aggiunge un messaggio alla chat.
+        """
         message_data = {
             "_id": ObjectId(),
             "sender": message.sender,
@@ -71,6 +74,9 @@ async def add_message(self, chat_id, message: schemas.MessageCreate):
         return message_data
 
     async def update_chat_title(self, chat_id, title):
+        """
+        Aggiorna il titolo della chat.
+        """
         return await self.collection.update_one(
             {"_id": ObjectId(chat_id)}, {"$set": {"name": title}}
         )
diff --git a/app/repositories/setting_repository.py b/app/repositories/setting_repository.py
@@ -0,0 +1,109 @@
+from fastapi import Depends, HTTPException, status
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from app.database import get_db
+from app.schemas import Settings
+
+
+def get_setting_repository(db: AsyncIOMotorDatabase = Depends(get_db)):
+    """
+    Restituisce il repository della collection settings.
+    """
+    return SettingRepository(db)
+
+
+class SettingRepository:
+    def __init__(self, database):
+        self.database = database
+        self.collection = database.get_collection("settings")
+
+        print("SettingRepository initialization")
+
+        insert_payload = {
+                "color_primary": "#5e5c64",
+                "color_primary_hover": "#44424a",
+                "color_primary_text": "white",
+                "message_history": 100,
+        }
+        self.collection.update_one(
+            {"_id": "main"},
+            { 
+                "$setOnInsert": insert_payload,
+            },
+            upsert=True,
+        )
+
+    async def get_settings(self):
+        """
+        Restituisce le impostazioni dell'applicazione.
+        """
+        return await self.collection.find_one({"_id": "main"})
+
+    async def update_settings(self, settings: Settings):
+        """
+        Aggiorna le impostazioni dell'applicazione.
+        """
+        try:
+            current_settings = await self.get_settings()
+
+            if not current_settings:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Settings not found",
+                )
+
+            # Controlla se le impostazioni sono state modificate
+            if (
+                current_settings.get("color_primary") == settings.color_primary
+                and current_settings.get("color_primary_hover")
+                == settings.color_primary_hover
+                and current_settings.get("color_primary_text")
+                == settings.color_primary_text
+                and current_settings.get("message_history") == settings.message_history
+            ):
+                print("Settings data is already up to date.")
+                raise HTTPException(
+                    status_code=status.HTTP_304_NOT_MODIFIED,
+                    detail="Settings data is already up to date.",
+                )
+
+            # Prepara il payload di aggiornamento
+            update_payload = {
+                "color_primary": (
+                    settings.color_primary
+                    if settings.color_primary
+                    else current_settings.get("color_primary")
+                ),
+                "color_primary_hover": (
+                    settings.color_primary_hover
+                    if settings.color_primary_hover
+                    else current_settings.get("color_primary_hover")
+                ),
+                "color_primary_text": (
+                    settings.color_primary_text
+                    if settings.color_primary_text
+                    else current_settings.get("color_primary_text")
+                ),
+                "message_history": (
+                    settings.message_history
+                    if settings.message_history
+                    else current_settings.get("message_history")
+                ),
+            }
+
+            result = await self.collection.update_one(
+                {"_id": "main"},
+                {
+                    "$set": update_payload,
+                },
+            )
+
+            # Controlla se l'aggiornamento ha avuto effetto
+            if result.matched_count == 0:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Settings not found during update attempt",
+                )
+        except Exception as e:
+            print(f"Error updating settings: {e}")
+            raise Exception(f"Error updating settings: {e}")
diff --git a/app/repositories/user_repository.py b/app/repositories/user_repository.py
@@ -1,8 +1,6 @@
-import uuid
 from fastapi import HTTPException, status, Depends
 from pydantic import EmailStr
 from motor.motor_asyncio import AsyncIOMotorDatabase
-from bson import ObjectId
 from app.database import get_db
 
 
@@ -124,14 +122,18 @@ async def update_user(self, user_id: EmailStr, user_data: schemas.UserUpdate):
             update_payload["remember_me"] = user_data.remember_me
         if user_data.scopes is not None and user_data.scopes != user_current_data.get("scopes"):
             update_payload["scopes"] = user_data.scopes
-
-        # Controlla se ci sono stati cambiamenti nei dati
-        if update_payload == {}:
+        if user_data.name is not None and user_data.name != user_current_data.get(
+            "name"
+        ):
+            update_payload["name"] = user_data.name
+            
+        print(f"[USER REPO] Update payload: {update_payload}")
+        if not update_payload or len(update_payload) == 0:
+            print("empty update payload")
             raise HTTPException(
                 status_code=status.HTTP_304_NOT_MODIFIED,
                 detail="User data provided matches existing data. No update performed.",
             )
-            
 
         try:
             result = await self.collection.update_one(
@@ -145,6 +147,7 @@ async def update_user(self, user_id: EmailStr, user_data: schemas.UserUpdate):
                 detail=f"Failed to update user: {e}",
             )
 
+
 def get_user_repository(db: AsyncIOMotorDatabase = Depends(get_db)):
     """
     Restituisce il repository della collection users.
diff --git a/app/routes/auth.py b/app/routes/auth.py
@@ -32,6 +32,10 @@
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/token")
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
+def init_router(app_instance):
+    yield
+
+
 def security_check(): # pragma: no cover
     if SECRET_KEY_JWT == "$2b$12$zqt9Rgv1PzORjG5ghJSb6OSdYrt7f7cLc38a21DgX/DMyqt80AUCi":
         print(
@@ -40,6 +44,7 @@ def security_check(): # pragma: no cover
         print("Please set SECRET_KEY_JWT in your environment variables.")
 security_check()
 
+
 async def authenticate_user(email: str, password: str, user_repo: UserRepository):
     """
     Ritorna true se l'utente esiste e se la password inserita è quella associata alla mail passata come parametro; altrimenti false.
diff --git a/app/routes/document.py b/app/routes/document.py
@@ -56,7 +56,9 @@ async def upload_document(
         )
 
 
-@router.get("/", response_model=List[schemas.DocumentResponse], status_code=status.HTTP_200_OK)
+@router.get(
+    "", response_model=List[schemas.DocumentResponse]
+)
 async def get_documents(
     current_user=Depends(verify_admin),
     document_repository=Depends(get_document_repository),
diff --git a/app/routes/faq.py b/app/routes/faq.py
@@ -2,11 +2,9 @@
 from motor.motor_asyncio import AsyncIOMotorDatabase
 from pymongo.errors import DuplicateKeyError
 from bson import ObjectId
-from bson.errors import InvalidId
 
 import app.schemas as schemas
 from typing import List
-from app.database import get_db
 from app.repositories.faq_repository import FaqRepository, get_faq_repository
 from app.repositories.user_repository import UserRepository, get_user_repository
 from app.routes.auth import verify_admin, authenticate_user
@@ -80,7 +78,9 @@ async def get_faqs(
     return faqs
 
 
-@router.put("/{faq_id}")
+@router.patch(
+    "/{faq_id}",
+)
 async def update_faq(
     faq_id: str,
     faq: schemas.FAQUpdate,
diff --git a/app/routes/setting.py b/app/routes/setting.py
@@ -0,0 +1,77 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+
+import app.schemas as schemas
+from app.routes.auth import verify_admin
+from app.repositories.setting_repository import (
+    SettingRepository,
+    get_setting_repository,
+)
+
+router = APIRouter(prefix="/settings", tags=["setting"])
+
+
+@router.get(
+    "",
+    response_model=schemas.Settings,
+)
+async def get_settings(
+    setting_repository: SettingRepository = Depends(get_setting_repository),
+):
+    """
+    Restituisce le impostazioni dell'applicazione.
+
+    ### Returns:
+    * **schemas.Settings**: Le impostazioni dell'applicazione.
+
+    ### Raises:
+    * **HTTPException.HTTP_404_NOT_FOUND**: Se le impostazioni non sono state trovate.
+    * **HTTPException.HTTP_500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante il recupero delle impostazioni.
+    """
+    try:
+        settings = await setting_repository.get_settings()
+        if not settings:
+            raise HTTPException(
+                status_code=404,
+                detail="Settings not found",
+            )
+        return settings
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error retrieving settings: {str(e)}",
+        )
+
+
+@router.patch(
+    "",
+)
+async def update_settings(
+    settings: schemas.Settings,
+    current_user=Depends(verify_admin),
+    setting_repository: SettingRepository = Depends(get_setting_repository),
+):
+    """
+    Aggiorna le impostazioni dell'applicazione.
+
+    ### Args:
+    * **settings**: Le impostazioni da aggiornare.
+
+    ### Raises:
+    * **HTTPException.HTTP_401_UNAUTHORIZED**: Se l'utente non è autorizzato a compiere questa azione.
+    * **HTTPException.HTTP_500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante l'aggiornamento delle impostazioni.
+    * **HTTPException.HTTP_304_NOT_MODIFIED**: Se le impostazioni non sono state modificate.
+    * **HTTPException.HTTP_404_NOT_FOUND**: Se le impostazioni non sono state trovate.
+    """
+    if not current_user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authorized",
+        )
+
+    try:
+        await setting_repository.update_settings(settings)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Error updating settings: {str(e)}",
+        )
diff --git a/app/routes/user.py b/app/routes/user.py
diff --git a/app/schemas.py b/app/schemas.py
diff --git a/requirements.txt b/requirements.txt

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,9 @@ async def upload_document(`
`56`	`56`	`)`
`57`	`57`
`58`	`58`
`59`		`-@router.get("/", response_model=List[schemas.DocumentResponse], status_code=status.HTTP_200_OK)`
	`59`	`+@router.get(`
	`60`	`+ "", response_model=List[schemas.DocumentResponse]`
	`61`	`+)`
`60`	`62`	`async def get_documents(`
`61`	`63`	`current_user=Depends(verify_admin),`
`62`	`64`	`document_repository=Depends(get_document_repository),`