Upload 2 files

app/database.py

@@ -45,11 +45,25 @@ def fetch_tags() -> List[str]:
     Récupère la liste de tous les tags disponibles dans la base de données.
 
     Returns:
-        List[str]: Une liste de chaînes de caractères correspondant aux noms des tags, triés par ordre alphabétique.
+        Dict: Un dictionnaire contenant le statut et les résultats.
+            - Si succès :
+                {
+                    "status": "ok",
+                    "result": List[str]  # Liste des noms de tags triés par ordre alphabétique
+                }
+            - En cas d'erreur :
+                {
+                    "status": "error",
+                    "code": str,        # Nom de l'exception
+                    "message": str      # Message de l'exception
+                }
     """
-    query = "SELECT tag_name FROM tags ORDER BY tag_name"
-    result = con.execute(query).fetchall()
-    return [row[0] for row in result]
+    try:
+        query = "SELECT tag_name FROM tags ORDER BY tag_name"
+        result = con.execute(query).fetchall()
+        return {"status": "ok", "result": [row[0] for row in result]}
+    except Exception as e:
+        return {"status": "error", "code": type(e).__name__, "message": str(e)}
 
 def fetch_articles_by_tags(tags: List[str]) -> List[Dict]:
     """
@@ -59,24 +73,39 @@ def fetch_articles_by_tags(tags: List[str]) -> List[Dict]:
         tags (List[str]): Une liste de noms de tags pour filtrer les articles.
 
     Returns:
-        List[Dict]: Une liste de dictionnaires, chacun représentant un article avec les clés:
-                    - 'article_id': ID de l'article
-                    - 'article_title': Titre de l'article
-                    - 'article_url': URL de l'article
+        Dict: Un dictionnaire contenant le statut et les résultats.
+            - Si succès :
+                {
+                    "status": "ok",
+                    "result": List[Dict]  # Liste de dictionnaires représentant les articles
+                }
+                Chaque dictionnaire contient les clés :
+                    - 'article_id': int, ID de l'article
+                    - 'article_title': str, Titre de l'article
+                    - 'article_url': str, URL de l'article
+            - En cas d'erreur ou si aucun tag fourni :
+                {
+                    "status": "error",
+                    "code": str,        # Code d'erreur ou nom de l'exception
+                    "message": str      # Message d'erreur
+                }
 
     Notes:
         - Si la liste `tags` est vide, la fonction retourne une liste vide.
         - Les résultats incluent uniquement les articles correspondant à au moins un des tags fournis.
     """
     if not tags:
-        return []
+        return {"status": "error", "code": "no_tags", "message": "Aucun tag fourni."}
 
-    placeholders = ",".join(["?"] * len(tags))
-    query = f"""SELECT distinct a.article_id, a.article_title, a.article_url
-                  FROM tags t, tag_article ta, articles a
-                 WHERE t.tag_id = ta.tag_id
-                   AND ta.article_id = a.article_id
-                   AND t.tag_name IN ({placeholders})
-             """
-    result = con.execute(query, tags).fetchdf()
-    return result.to_dict(orient="records")
+    try:
+        placeholders = ",".join(["?"] * len(tags))
+        query = f"""SELECT distinct a.article_id, a.article_title, a.article_url
+                    FROM tags t, tag_article ta, articles a
+                    WHERE t.tag_id = ta.tag_id
+                    AND ta.article_id = a.article_id
+                    AND t.tag_name IN ({placeholders})
+                """
+        result = con.execute(query, tags).fetchdf()
+        return {"status": "ok", "result": result.to_dict(orient="records")}
+    except Exception as e:
+        return {"status": "error", "code": type(e).__name__, "message": str(e)}

app/main.py

@@ -21,18 +21,71 @@ app.add_middleware(
 @app.get("/get_tags")
 def get_tags():
     """
-    Retourne la liste de tous les tags
+    Récupère la liste de tous les tags disponibles via l'API.
+
+    Returns:
+        Dict: Un dictionnaire contenant soit la liste des tags, soit les informations d'erreur.
+            - Si succès :
+                {
+                    "tags": List[str]  # Liste des noms de tags triés par ordre alphabétique
+                }
+            - En cas d'erreur :
+                {
+                    "status": "error",
+                    "code": str,      # Nom de l'exception
+                    "message": str    # Message de l'exception
+                }
+
+    Notes:
+        - L'appel de cet endpoint effectue un accès à la base de données via la fonction `fetch_tags`.
+        - En cas de problème avec la base de données, un message d'erreur détaillé est retourné.
     """
-    tags = database.fetch_tags()
-    return {"tags": tags}
+    try:
+        dict_result = database.fetch_tags()
+        if dict_result["status"] == "ok":
+            return {"tags": dict_result["result"]}
+        else:
+            return dict_result
+    except Exception as e:
+        return {"status": "error", "code": type(e).__name__, "message": str(e)}
 
 @app.get("/get_articles_with_tags")
-def get_articles_with_tags(
-    tags: List[str] = Query(..., description="Liste des tags à filtrer")
-):
+def get_articles_with_tags(tags: List[str] = Query(..., description="Liste des tags à filtrer")):
     """
-    Retourne les articles correspondant aux tags donnés
+    Récupère les articles associés à une ou plusieurs tags spécifiés.
+
+    Args:
+        tags (List[str]): Liste des noms de tags utilisés pour filtrer les articles.
+                          Doit contenir au moins un tag.
+
+    Returns:
+        Dict: Un dictionnaire contenant soit les articles correspondants, soit les informations d'erreur.
+            - Si succès :
+                {
+                    "tags": List[str],        # Tags utilisés pour filtrer
+                    "articles": List[Dict]    # Liste des articles correspondants
+                }
+                Chaque article est un dictionnaire contenant :
+                    - 'article_id': int, ID de l'article
+                    - 'article_title': str, Titre de l'article
+                    - 'article_url': str, URL de l'article
+            - En cas d'erreur :
+                {
+                    "status": "error",
+                    "code": str,             # Code d'erreur ou nom de l'exception
+                    "message": str           # Message d'erreur
+                }
+
+    Notes:
+        - Si la liste `tags` est vide, la fonction retourne une erreur avec le code "no_tags".
+        - L'appel de cet endpoint utilise la fonction `fetch_articles_by_tags` pour récupérer les articles.
     """
-    articles = database.fetch_articles_by_tags(tags)
-    return {"tags": tags,
-            "articles": articles}
+    try:
+        dict_result = database.fetch_articles_by_tags(tags)
+        if dict_result["status"] == "ok":
+            return {"tags": tags,
+                    "articles": dict_result["result"]}
+        else:
+            return dict_result
+    except Exception as e:
+        return {"status": "error", "code": type(e).__name__, "message": str(e)}